lib Library API Documentation

koSconfig.cpp

00001 /* This file is part of the KDE libraries
00002    Copyright (C) 1997 David Sweet <dsweet@kde.org>
00003    Copyright (C) 2000-2001 Wolfram Diestel <wolfram@steloj.de>
00004    Copyright (C) 2002 Laurent Montel <lmontel@mandrakesoft.com>
00005 
00006    This library is free software; you can redistribute it and/or
00007    modify it under the terms of the GNU Library General Public
00008    License version 2 as published by the Free Software Foundation.
00009 
00010    This library is distributed in the hope that it will be useful,
00011    but WITHOUT ANY WARRANTY; without even the implied warranty of
00012    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00013    Library General Public License for more details.
00014 
00015    You should have received a copy of the GNU Library General Public License
00016    along with this library; see the file COPYING.LIB.  If not, write to
00017    the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
00018    Boston, MA 02111-1307, USA.
00019 */
00020 
00021 #include <qcheckbox.h>
00022 #include <qcombobox.h>
00023 #include <qlabel.h>
00024 #include <qlayout.h>
00025 #include <kpushbutton.h>
00026 #include <qwhatsthis.h>
00027 #include <kapplication.h>
00028 #include <kconfig.h>
00029 #include <kdebug.h>
00030 #include <kdialog.h>
00031 #include <kfiledialog.h>
00032 #include <kglobal.h>
00033 #include <klineedit.h>
00034 #include <klocale.h>
00035 #include <kstdguiitem.h>
00036 
00037 #include "koSconfig.h"
00038 
00039 class KOSpellConfigPrivate
00040 {
00041 public:
00042     KOSpellConfigPrivate() : shown( false ) {}
00043     QStringList replacelist;
00044     bool shown; // false initially, true after the first showEvent
00045 };
00046 
00047 
00048 KOSpellConfig::KOSpellConfig (const KOSpellConfig &_ksc)
00049   : QWidget(0, 0), nodialog(true)
00050   , kc(0)
00051   , cb1(0)
00052   , cb2(0)
00053   , dictlist(0)
00054   , dictcombo(0)
00055   , encodingcombo(0)
00056   ,clientcombo(0)
00057   ,cbIgnoreCase(0)
00058   ,cbIgnoreAccent(0)
00059   ,cbSpellWordWithNumber(0)
00060   ,cbDontCheckUpperWord(0)
00061   ,cbDontCheckTitleCase(0)
00062 
00063 {
00064     m_bIgnoreCase = false;
00065     m_bIgnoreAccent = false;
00066     d= new KOSpellConfigPrivate;
00067     setReplaceAllList( _ksc.replaceAllList ());
00068     setNoRootAffix (_ksc.noRootAffix());
00069     setRunTogether (_ksc.runTogether());
00070     setDictionary  (_ksc.dictionary());
00071     setDictFromList (_ksc.dictFromList());
00072     setIgnoreCase ( _ksc.ignoreCase ());
00073     setIgnoreAccent( _ksc.ignoreAccent());
00074     setIgnoreList (_ksc.ignoreList());
00075     setEncoding (_ksc.encoding());
00076     setSpellWordWithNumber( _ksc.spellWordWithNumber());
00077     setDontCheckTitleCase( _ksc.dontCheckTitleCase());
00078     setDontCheckUpperWord( _ksc.dontCheckUpperWord());
00079     setClient (_ksc.client());
00080 }
00081 
00082 
00083 KOSpellConfig::KOSpellConfig( QWidget *parent, const char *name,
00084                 KOSpellConfig *_ksc, bool addHelpButton )
00085   : QWidget (parent, name), nodialog(false)
00086   , kc(0)
00087   , cb1(0)
00088   , cb2(0)
00089   , dictlist(0)
00090   , dictcombo(0)
00091   , encodingcombo(0)
00092   ,clientcombo(0)
00093   ,cbIgnoreCase(0)
00094   ,cbIgnoreAccent(0)
00095   ,cbSpellWordWithNumber(0)
00096   ,cbDontCheckUpperWord(0)
00097   ,cbDontCheckTitleCase(0)
00098 {
00099     m_bIgnoreCase = false;
00100     m_bIgnoreAccent = false;
00101     m_bSpellWordWithNumber = false;
00102     d= new KOSpellConfigPrivate;
00103     kc = KGlobal::config();
00104     if( _ksc == 0 )
00105     {
00106         readGlobalSettings();
00107     }
00108     else
00109     {
00110         setReplaceAllList( _ksc->replaceAllList ());
00111         setNoRootAffix (_ksc->noRootAffix());
00112         setRunTogether (_ksc->runTogether());
00113         setDictionary  (_ksc->dictionary());
00114         setDictFromList (_ksc->dictFromList());
00115         setIgnoreList (_ksc->ignoreList());
00116         setEncoding (_ksc->encoding());
00117         setIgnoreCase ( _ksc->ignoreCase ());
00118         setIgnoreAccent( _ksc->ignoreAccent());
00119         setSpellWordWithNumber( _ksc->spellWordWithNumber());
00120         setDontCheckTitleCase( _ksc->dontCheckTitleCase());
00121         setDontCheckUpperWord( _ksc->dontCheckUpperWord());
00122         setClient (_ksc->client());
00123     }
00124 
00125     QGridLayout *glay = new QGridLayout (this, 8, 3, 0, KDialog::spacingHint() );
00126     cb1 = new QCheckBox(i18n("Create root/affix combinations"
00127                              " not in dictionary"), this );
00128     connect( cb1, SIGNAL(toggled(bool)), SLOT(sNoAff(bool)) );
00129     glay->addMultiCellWidget( cb1, 0, 0, 0, 2 );
00130 
00131     cb2 = new QCheckBox( i18n("Consider run-together words"
00132                               " as spelling errors"), this );
00133     connect( cb2, SIGNAL(toggled(bool)), SLOT(sRunTogether(bool)) );
00134     glay->addMultiCellWidget( cb2, 1, 1, 0, 2 );
00135 
00136     dictcombo = new QComboBox( this );
00137     dictcombo->setInsertionPolicy (QComboBox::NoInsertion);
00138     connect (dictcombo, SIGNAL (activated (int)),
00139              this, SLOT (sSetDictionary (int)));
00140     glay->addMultiCellWidget( dictcombo, 2, 2, 1, 2 );
00141 
00142     dictlist = new QLabel (dictcombo, i18n("Dictionary:"), this);
00143     glay->addWidget( dictlist, 2 ,0 );
00144 
00145     encodingcombo = new QComboBox( this );
00146     encodingcombo->insertItem ("US-ASCII");
00147     encodingcombo->insertItem ("ISO 8859-1");
00148     encodingcombo->insertItem ("ISO 8859-2");
00149     encodingcombo->insertItem ("ISO 8859-3");
00150     encodingcombo->insertItem ("ISO 8859-4");
00151     encodingcombo->insertItem ("ISO 8859-5");
00152     encodingcombo->insertItem ("ISO 8859-7");
00153     encodingcombo->insertItem ("ISO 8859-8");
00154     encodingcombo->insertItem ("ISO 8859-9");
00155     encodingcombo->insertItem ("ISO 8859-13");
00156     encodingcombo->insertItem ("ISO 8859-15");
00157     encodingcombo->insertItem ("UTF-8");
00158     encodingcombo->insertItem ("KOI8-R");
00159     encodingcombo->insertItem ("KOI8-U");
00160     encodingcombo->insertItem ("CP1251");
00161 
00162     connect (encodingcombo, SIGNAL (activated(int)), this,
00163              SLOT (sChangeEncoding(int)));
00164     glay->addMultiCellWidget (encodingcombo, 3, 3, 1, 2);
00165 
00166     QLabel *tmpQLabel = new QLabel( encodingcombo, i18n("Encoding:"), this);
00167     glay->addWidget( tmpQLabel, 3, 0 );
00168 
00169   clientcombo = new QComboBox( this );
00170   clientcombo->insertItem (i18n("International Ispell"));
00171   clientcombo->insertItem (i18n("Aspell"));
00172   clientcombo->insertItem (i18n("Hspell"));
00173   connect (clientcombo, SIGNAL (activated(int)), this,
00174        SLOT (sChangeClient(int)));
00175   glay->addMultiCellWidget( clientcombo, 4, 4, 1, 2 );
00176 
00177   tmpQLabel = new QLabel( clientcombo, i18n("Client:"), this );
00178   glay->addWidget( tmpQLabel, 4, 0 );
00179 
00180     if( addHelpButton == true )
00181     {
00182         QPushButton *pushButton = new KPushButton( KStdGuiItem::help(), this );
00183         connect( pushButton, SIGNAL(clicked()), this, SLOT(sHelp()) );
00184         glay->addWidget(pushButton, 10, 2);
00185     }
00186 
00187     cbIgnoreCase = new QCheckBox(i18n("Ignore case when checking words"), this );
00188     connect( cbIgnoreCase , SIGNAL(toggled(bool)), this, SLOT(slotIgnoreCase(bool)) );
00189 
00190     cbIgnoreAccent = new QCheckBox(i18n("Ignore accents when checking words"), this );
00191     connect( cbIgnoreAccent , SIGNAL(toggled(bool)), this, SLOT(slotIgnoreAccent(bool)) );
00192 
00193     cbSpellWordWithNumber = new QCheckBox(i18n("Check words with numbers"), this );
00194     connect( cbSpellWordWithNumber , SIGNAL(toggled(bool)), this, SLOT(slotSpellWordWithNumber(bool)) );
00195 
00196     cbDontCheckUpperWord= new QCheckBox(i18n("Ignore uppercase words"),this);
00197     connect( cbDontCheckUpperWord , SIGNAL(toggled(bool)), this, SLOT(slotDontSpellCheckUpperWord(bool)) );
00198 
00199     QWhatsThis::add( cbDontCheckUpperWord, i18n("This option tells the spell-checker to accept words that are written in uppercase, such as KDE.") );
00200 
00201     cbDontCheckTitleCase= new QCheckBox(i18n("Ignore title case words"),this);
00202     connect( cbDontCheckTitleCase , SIGNAL(toggled(bool)), this, SLOT(slotDontCheckTitleCase(bool)) );
00203 
00204     QWhatsThis::add( cbDontCheckTitleCase, i18n("This option tells the spell-checker to accept words starting with an uppercase letter, such as United States."));
00205 
00206 
00207 
00208     glay->addMultiCellWidget( cbIgnoreCase, 5,5,0 ,2 );
00209     glay->addMultiCellWidget( cbIgnoreAccent, 6,6,0 ,2 );
00210     glay->addMultiCellWidget( cbSpellWordWithNumber, 7,7,0 ,2 );
00211     glay->addMultiCellWidget( cbDontCheckUpperWord, 8,8,0 ,2 );
00212     glay->addMultiCellWidget( cbDontCheckTitleCase, 9,9,0 ,2 );
00213 
00214 
00215     // Will be done at showEvent time
00216     //fillInDialog();
00217 }
00218 
00219 KOSpellConfig::~KOSpellConfig ()
00220 {
00221     delete d;
00222 }
00223 
00224 bool KOSpellConfig::dictFromList () const
00225 {
00226   return dictfromlist;
00227 }
00228 
00229 bool KOSpellConfig::ignoreCase () const
00230 {
00231     return m_bIgnoreCase;
00232 }
00233 
00234 bool KOSpellConfig::ignoreAccent() const
00235 {
00236     return m_bIgnoreAccent;
00237 }
00238 
00239 bool KOSpellConfig::readGlobalSettings ()
00240 {
00241   KConfigGroupSaver cs(kc,"KSpell");
00242 
00243   setNoRootAffix   (kc->readNumEntry ("KSpell_NoRootAffix", 0));
00244   setRunTogether   (kc->readNumEntry ("KSpell_RunTogether", 0));
00245   setDictionary    (kc->readEntry ("KSpell_Dictionary", ""));
00246   setDictFromList  (kc->readNumEntry ("KSpell_DictFromList", FALSE));
00247   setEncoding (kc->readNumEntry ("KSpell_Encoding", KOS_E_ASCII));
00248   setIgnoreCase( kc->readNumEntry( "KSpell_IgnoreCase", 0));
00249   setIgnoreAccent( kc->readNumEntry( "KSpell_IgnoreAccent", 0));
00250   setSpellWordWithNumber( kc->readNumEntry("KSpell_SpellWordWithNumber", false));
00251 
00252   setDontCheckTitleCase( kc->readNumEntry("KSpell_dont_check_title_case", false));
00253   setDontCheckUpperWord( kc->readNumEntry("KSpell_dont_check_upper_word",false));
00254 
00255   setClient (kc->readNumEntry ("KSpell_Client", KOS_CLIENT_ASPELL));
00256   return TRUE;
00257 }
00258 
00259 bool KOSpellConfig::writeGlobalSettings ()
00260 {
00261   KConfigGroupSaver cs(kc,"KSpell");
00262   kc->writeEntry ("KSpell_NoRootAffix",(int) noRootAffix (), TRUE, TRUE);
00263   kc->writeEntry ("KSpell_RunTogether", (int) runTogether (), TRUE, TRUE);
00264   kc->writeEntry ("KSpell_Dictionary", dictionary (), TRUE, TRUE);
00265   kc->writeEntry ("KSpell_DictFromList",(int) dictFromList(), TRUE, TRUE);
00266   kc->writeEntry ("KSpell_Encoding", (int) encoding(),
00267           TRUE, TRUE);
00268   kc->writeEntry ("KSpell_IgnoreCase",(int) ignoreCase(), TRUE, TRUE);
00269   kc->writeEntry( "KSpell_IgnoreAccent", (int)ignoreAccent(), TRUE, TRUE);
00270   kc->writeEntry( "KSpell_SpellWordWithNumber", (int)spellWordWithNumber(), TRUE, TRUE);
00271 
00272   kc->writeEntry( "KSpell_dont_check_title_case", (int)dontCheckTitleCase(),TRUE,TRUE);
00273   kc->writeEntry( "KSpell_dont_check_upper_word", (int)dontCheckUpperWord(),TRUE,TRUE);
00274 
00275 
00276   kc->writeEntry ("KSpell_Client", client(),
00277           TRUE, TRUE);
00278   kc->sync();
00279   return TRUE;
00280 }
00281 
00282 void KOSpellConfig::slotSpellWordWithNumber(bool b)
00283 {
00284     setSpellWordWithNumber ( b );
00285     emit configChanged();
00286 }
00287 
00288 void KOSpellConfig::slotDontSpellCheckUpperWord(bool b)
00289 {
00290     setDontCheckUpperWord(b);
00291     emit configChanged();
00292 }
00293 
00294 void KOSpellConfig::slotDontCheckTitleCase(bool b)
00295 {
00296     setDontCheckTitleCase(b);
00297     emit configChanged();
00298 }
00299 
00300 void KOSpellConfig::slotIgnoreCase(bool b)
00301 {
00302     setIgnoreCase ( b );
00303     emit configChanged();
00304 }
00305 
00306 void KOSpellConfig::slotIgnoreAccent(bool b)
00307 {
00308     setIgnoreAccent ( b );
00309     emit configChanged();
00310 }
00311 
00312 void KOSpellConfig::sChangeClient (int i)
00313 {
00314   setClient (i);
00315 
00316   // read in new dict list
00317   if (dictcombo) {
00318     if (iclient == KOS_CLIENT_ISPELL)
00319       getAvailDictsIspell();
00320     else if( iclient == KOS_CLIENT_ASPELL)
00321       getAvailDictsAspell();
00322     else if (iclient == KOS_CLIENT_HSPELL)
00323     {
00324       langfnames.clear();
00325       dictcombo->clear();
00326       dictcombo->insertItem(i18n("Hebrew"));
00327       sChangeEncoding(KOS_E_LATIN8);
00328     }
00329 #if 0 //for the futur :)
00330     else if( iclient == KOS_CLIENT_MYSPELL)
00331       getAvailDictsMyspell();
00332 #endif
00333   }
00334   emit configChanged();
00335 }
00336 
00337 
00338 
00339 
00340 void KOSpellConfig::sChangeEncoding(int i)
00341 {
00342     kdDebug(30006) << "KOSpellConfig::sChangeEncoding(" << i << ")" << endl;
00343   setEncoding (i);
00344   emit configChanged();
00345 }
00346 
00347 bool KOSpellConfig::interpret (QString &fname, QString &lname,
00348                   QString &hname)
00349 {
00350 
00351   kdDebug(30006) << "KOSpellConfig::interpret [" << fname << "]" << endl;
00352 
00353   QString dname(fname);
00354 
00355   if(dname.right(1)=="+")
00356     dname.remove(dname.length()-1, 1);
00357 
00358   if(dname.right(3)=="sml" || dname.right(3)=="med" || dname.right(3)=="lrg" || dname.right(3)=="xlg")
00359      dname.remove(dname.length()-3,3);
00360 
00361   QString extension;
00362 
00363   int i = dname.find('-');
00364   if (i != -1)
00365   {
00366     extension = dname.mid(i+1);
00367     dname.truncate(i);
00368   }
00369 
00370   // Aspell uses 2 alpha language codes or 2 alpha language + 2 alpha country
00371   if (dname.length() == 2) {
00372     lname = dname;
00373     hname = KGlobal::locale()->twoAlphaToLanguageName(lname);
00374   }
00375   else if ((dname.length() == 5) && (dname[2] == '_')) {
00376     lname = dname.left(2);
00377     hname = KGlobal::locale()->twoAlphaToLanguageName(lname);
00378     QString country = KGlobal::locale()->twoAlphaToCountryName(dname.right(2));
00379     if (extension.isEmpty())
00380       extension = country;
00381     else
00382       extension = country + " - " + extension;
00383   }
00384     //These are mostly the ispell-langpack defaults
00385   else if (dname=="english" || dname=="american" ||
00386       dname=="british" || dname=="canadian") {
00387     lname="en"; hname=i18n("English");
00388   }
00389   else if (dname=="espa~nol" || dname=="espanol") {
00390     lname="es"; hname=i18n("Spanish");
00391   }
00392   else if (dname=="dansk") {
00393     lname="da"; hname=i18n("Danish");
00394   }
00395   else if (dname=="deutsch") {
00396     lname="de"; hname=i18n("German");
00397   }
00398   else if (dname=="german") {
00399     lname="de"; hname=i18n("German (new spelling)");
00400   }
00401   else if (dname=="portuguesb" || dname=="br") {
00402     lname="br"; hname=i18n("Brazilian Portuguese");
00403   }
00404   else if (dname=="portugues") {
00405     lname="pt"; hname=i18n("Portuguese");
00406   }
00407   else if (dname=="esperanto") {
00408     lname="eo"; hname=i18n("Esperanto");
00409   }
00410   else if (dname=="norsk") {
00411     lname="no"; hname=i18n("Norwegian");
00412   }
00413   else if (dname=="polish") {
00414       lname="pl"; hname=i18n("Polish"); //sChangeEncoding(KOS_E_LATIN2);
00415   }
00416   else if (dname=="russian") {
00417     lname="ru"; hname=i18n("Russian");
00418   }
00419   else if (dname=="slovensko") {
00420       lname="si"; hname=i18n("Slovenian"); //sChangeEncoding(KOS_E_LATIN2);
00421   }
00422   else if (dname=="slovak"){
00423       lname="sk"; hname=i18n("Slovak"); //sChangeEncoding(KOS_E_LATIN2);
00424   }  else if (dname=="czech") {
00425       lname="cs"; hname=i18n("Czech"); //sChangeEncoding(KOS_E_LATIN2);
00426   }
00427   else if (dname=="svenska") {
00428     lname="sv"; hname=i18n("Swedish");
00429   }
00430   else if (dname=="swiss") {
00431     lname="de"; hname=i18n("Swiss German");
00432   }
00433   else if (dname=="ukrainian") {
00434     lname="uk"; hname=i18n("Ukrainian");
00435   }
00436   else if (dname=="lietuviu" || dname=="lithuanian") {
00437      lname="lt"; hname=i18n("Lithuanian");
00438   }
00439   else if (dname=="francais" || dname=="french") {
00440     lname="fr"; hname=i18n("French");
00441   }
00442   else if (dname=="belarusian") {  // waiting for post 2.2 to not dissapoint translators
00443     lname="be"; hname=i18n("Belarusian");
00444   }
00445   else if( dname == "magyar" ) {
00446     lname="hu"; hname=i18n("Hungarian");
00447     //sChangeEncoding(KOS_E_LATIN2);
00448   }
00449   else {
00450     lname=""; hname=i18n("Unknown ispell dictionary", "Unknown");
00451   }
00452   if (!extension.isEmpty())
00453   {
00454     hname = hname + " (" + extension + ")";
00455   }
00456 
00457   //We have explicitly chosen English as the default here.
00458   if ( (KGlobal::locale()->language()==QString::fromLatin1("C") &&
00459     lname==QString::fromLatin1("en")) ||
00460        KGlobal::locale()->language()==lname)
00461     return TRUE;
00462 
00463   return FALSE;
00464 }
00465 
00466 void KOSpellConfig::fillInDialog ()
00467 {
00468     if (nodialog)
00469         return;
00470 
00471     kdDebug(30006) << "KOSpellConfig::fillinDialog" << endl;
00472 
00473     cb1->setChecked (noRootAffix());
00474     cb2->setChecked (runTogether());
00475     cbIgnoreCase->setChecked(ignoreCase());
00476     cbIgnoreAccent->setChecked(ignoreAccent());
00477     cbSpellWordWithNumber->setChecked(spellWordWithNumber());
00478     cbDontCheckUpperWord->setChecked(dontCheckUpperWord());
00479     cbDontCheckTitleCase->setChecked(dontCheckTitleCase());
00480 
00481     encodingcombo->setCurrentItem (encoding());
00482     clientcombo->setCurrentItem( client() );
00483 
00484     // get list of available dictionaries
00485     // get list of available dictionaries
00486     if (iclient == KOS_CLIENT_ISPELL)
00487         getAvailDictsIspell();
00488     else
00489         getAvailDictsAspell();
00490 
00491     // select the used dictionary in the list
00492     int whichelement=-1;
00493 
00494     if (dictFromList())
00495     {
00496         QString dict = dictionary();
00497         if (iclient == KOS_CLIENT_ISPELL)
00498         {
00499             whichelement = langfnames.findIndex( dict );
00500         }
00501         else if(iclient == KOS_CLIENT_ASPELL)
00502         {
00503             whichelement = listOfLanguageFileName().findIndex( dict );
00504         }
00505         else if (iclient == KOS_CLIENT_HSPELL)
00506         {
00507             langfnames.clear();
00508             dictcombo->clear();
00509             dictcombo->insertItem(i18n("Hebrew"));
00510         }
00511 
00512     }
00513     dictcombo->setMinimumWidth (dictcombo->sizeHint().width());
00514 
00515     if (dictionary().isEmpty() || whichelement!=-1)
00516     {
00517         setDictFromList (TRUE);
00518         if (whichelement!=-1)
00519             dictcombo->setCurrentItem(whichelement);
00520     }
00521     else // i.e. not found
00522     {
00523         //don't use langname !!!!!!!!!
00524         if (langfnames.count()>=1)
00525         {
00526             setDictFromList (TRUE);
00527             dictcombo->setCurrentItem(0);
00528         }
00529         else
00530             setDictFromList (FALSE);
00531     }
00532     sDictionary (dictFromList());
00533     sPathDictionary (!dictFromList());
00534 
00535 }
00536 
00537 void KOSpellConfig::getAvailDictsIspell () {
00538 
00539   langfnames.clear();
00540   dictcombo->clear();
00541   langfnames.append(""); // Default
00542   dictcombo->insertItem (i18n("ISpell Default"));
00543 
00544   // dictionary path
00545   QFileInfo dir ("/usr/lib/ispell");
00546   if (!dir.exists() || !dir.isDir())
00547     dir.setFile ("/usr/local/lib/ispell");
00548   if (!dir.exists() || !dir.isDir())
00549     dir.setFile ("/usr/local/share/ispell");
00550   if (!dir.exists() || !dir.isDir())
00551     dir.setFile ("/usr/share/ispell");
00552   /* TODO get them all instead of just one of them.
00553    * If /usr/local/lib exists, it skips the rest
00554   if (!dir.exists() || !dir.isDir())
00555     dir.setFile ("/usr/local/lib");
00556   */
00557   if (!dir.exists() || !dir.isDir()) return;
00558 
00559   kdDebug(30006) << "KSpellConfig::getAvailDictsIspell "
00560            << dir.filePath() << " " << dir.dirPath() << endl;
00561 
00562   QDir thedir (dir.filePath(),"*.hash");
00563 
00564   kdDebug(30006) << "KSpellConfig" << thedir.path() << "\n" << endl;
00565   kdDebug(30006) << "entryList().count()="
00566            << thedir.entryList().count() << endl;
00567 
00568   for (unsigned int i=0;i<thedir.entryList().count();i++)
00569     {
00570       QString fname, lname, hname;
00571       fname = thedir [i];
00572 
00573       // remove .hash
00574       if (fname.right(5) == ".hash") fname.remove (fname.length()-5,5);
00575 
00576       if (interpret (fname, lname, hname) && langfnames[0].isEmpty())
00577     { // This one is the KDE default language
00578       // so place it first in the lists (overwrite "Default")
00579 
00580       langfnames.remove ( langfnames.begin() );
00581       langfnames.prepend ( fname );
00582 
00583       hname=i18n("default spelling dictionary"
00584              ,"Default - %1 [%2]").arg(hname).arg(fname);
00585 
00586       dictcombo->changeItem (hname,0);
00587     }
00588       else
00589     {
00590       langfnames.append (fname);
00591       hname=hname+" ["+fname+"]";
00592 
00593       dictcombo->insertItem (hname);
00594     }
00595     }
00596 }
00597 
00598 void KOSpellConfig::setClient (int c)
00599 {
00600   iclient = c;
00601   //kdDebug(30006)<<" c :"<<c<<endl;
00602   if (clientcombo)
00603       clientcombo->setCurrentItem(c);
00604 }
00605 
00606 int KOSpellConfig::client () const
00607 {
00608   return iclient;
00609 }
00610 
00611 void KOSpellConfig::getAvailDictsAspell ()
00612 {
00613     langfnames.clear();
00614     dictcombo->clear();
00615     dictcombo->insertStringList( listOfAspellLanguages() );
00616 }
00617 
00618 /*
00619  * Options setting routines.
00620  */
00621 
00622 
00623 void KOSpellConfig::setNoRootAffix (bool b)
00624 {
00625   bnorootaffix=b;
00626 
00627   if(cb1)
00628       cb1->setChecked(b);
00629 }
00630 
00631 void KOSpellConfig::setRunTogether(bool b)
00632 {
00633   bruntogether=b;
00634 
00635   if(cb2)
00636       cb2->setChecked(b);
00637 }
00638 
00639 void KOSpellConfig::setDictionary (const QString &s)
00640 {
00641     qsdict=s; //.copy();
00642 
00643     if (qsdict.endsWith(".hash"))
00644         qsdict.truncate(qsdict.length()-5);
00645 
00646     // ## duplicate code with fillInDialog
00647     if(dictcombo)
00648     {
00649         int whichelement=-1;
00650         if (dictFromList())
00651         {
00652             if (iclient == KOS_CLIENT_ISPELL)
00653             {
00654                 whichelement = langfnames.findIndex( qsdict );
00655             }
00656             else if(iclient == KOS_CLIENT_ASPELL)
00657             {
00658                 whichelement = listOfLanguageFileName().findIndex( qsdict );
00659             }
00660 #if 0
00661             else if (iclient == KOS_CLIENT_HSPELL)
00662             {
00663                 langfnames.clear();
00664                 dictcombo->clear();
00665                 dictcombo->insertItem(i18n("Hebrew"));
00666             }
00667 #endif
00668             if(whichelement >= 0)
00669             {
00670                 dictcombo->setCurrentItem(whichelement);
00671             }
00672         }
00673     }
00674 
00675 #if 0 // keep the distinction between e.g. british and american, don't resolve all to "en"
00676     QString ab, desc;
00677     interpret( qsdict, ab, desc );
00678     qsdict = ab;
00679 #endif
00680 }
00681 
00682 void KOSpellConfig::setDictFromList (bool dfl)
00683 {
00684   dictfromlist=dfl;
00685 }
00686 
00687 void KOSpellConfig::setEncoding (int enctype)
00688 {
00689   enc=enctype;
00690 
00691   if(encodingcombo)
00692     encodingcombo->setCurrentItem(enctype);
00693 }
00694 
00695 
00696 bool KOSpellConfig::noRootAffix () const
00697 {
00698   return bnorootaffix;
00699 }
00700 
00701 bool KOSpellConfig::runTogether() const
00702 {
00703   return bruntogether;
00704 }
00705 
00706 const QString KOSpellConfig::dictionary () const
00707 {
00708   return qsdict;
00709 }
00710 
00711 int KOSpellConfig::encoding () const
00712 {
00713   return enc;
00714 }
00715 
00716 void KOSpellConfig::sRunTogether(bool)
00717 {
00718   setRunTogether (cb2->isChecked());
00719   emit configChanged();
00720 }
00721 
00722 void KOSpellConfig::sNoAff(bool)
00723 {
00724   setNoRootAffix (cb1->isChecked());
00725   emit configChanged();
00726 }
00727 
00728 
00729 QString KOSpellConfig::getLanguage( int i )
00730 {
00731     if (iclient == KOS_CLIENT_ISPELL)
00732     {
00733         return langfnames[i];
00734     }
00735     else if(iclient == KOS_CLIENT_ASPELL)
00736     {
00737         return listOfLanguageFileName()[i];
00738     }
00739 #if 0
00740     else if (iclient == KOS_CLIENT_HSPELL)
00741     {
00742         langfnames.clear();
00743         dictcombo->clear();
00744         dictcombo->insertItem(i18n("Hebrew"));
00745     }
00746 #endif
00747     else
00748         return QString::null;
00749 }
00750 
00751 void KOSpellConfig::sSetDictionary (int i)
00752 {
00753   setDictionary (getLanguage( i ));
00754   setDictFromList (TRUE);
00755   emit configChanged();
00756 }
00757 
00758 void
00759 KOSpellConfig::sDictionary(bool on)
00760 {
00761   if (on)
00762     {
00763       dictcombo->setEnabled (TRUE);
00764       setDictionary (getLanguage( dictcombo->currentItem() ));
00765       setDictFromList (TRUE);
00766     }
00767   else
00768     {
00769       dictcombo->setEnabled (FALSE);
00770     }
00771   emit configChanged();
00772 }
00773 
00774 void
00775 KOSpellConfig::sPathDictionary(bool on)
00776 {
00777   return; //enough for now
00778 
00779   if (on)
00780     {
00781       //kle1->setEnabled (TRUE);
00782       //      browsebutton1->setEnabled (TRUE);
00783       //setDictionary (kle1->text());
00784       setDictFromList (FALSE);
00785     }
00786   else
00787     {
00788       //kle1->setEnabled (FALSE);
00789       //browsebutton1->setEnabled (FALSE);
00790     }
00791   emit configChanged();
00792 }
00793 
00794 
00795 void KOSpellConfig::activateHelp( void )
00796 {
00797   sHelp();
00798 }
00799 
00800 void KOSpellConfig::sHelp( void )
00801 {
00802   kapp->invokeHelp("configuration", "kspell");
00803 }
00804 
00805 void KOSpellConfig::operator= (const KOSpellConfig &ksc)
00806 {
00807   //We want to copy the data members, but not the
00808   //pointers to the child widgets
00809   setNoRootAffix (ksc.noRootAffix());
00810   setRunTogether (ksc.runTogether());
00811   setDictionary (ksc.dictionary());
00812   setDictFromList (ksc.dictFromList());
00813   //  setPersonalDict (ksc.personalDict());
00814   setEncoding (ksc.encoding());
00815   setIgnoreAccent (ksc.ignoreAccent());
00816   setIgnoreCase (ksc.ignoreCase());
00817 
00818   if ( isVisible() )
00819       fillInDialog();
00820   else
00821       d->shown = false; // will force a fillInDialog when showing
00822 }
00823 
00824 void KOSpellConfig::setIgnoreList (QStringList _ignorelist)
00825 {
00826   ignorelist=_ignorelist;
00827 }
00828 
00829 QStringList KOSpellConfig::ignoreList () const
00830 {
00831   return ignorelist;
00832 }
00833 
00834 bool KOSpellConfig::spellWordWithNumber()const
00835 {
00836     return m_bSpellWordWithNumber;
00837 }
00838 
00839 bool KOSpellConfig::dontCheckTitleCase()const
00840 {
00841     return m_bDontCheckTitleCase;
00842 }
00843 
00844 bool KOSpellConfig::dontCheckUpperWord()const
00845 {
00846     return m_bDontCheckUpperWord;
00847 }
00848 
00849 void KOSpellConfig::setReplaceAllList (QStringList _replacelist)
00850 {
00851   d->replacelist=_replacelist;
00852 }
00853 
00854 QStringList KOSpellConfig::replaceAllList () const
00855 {
00856   return d->replacelist;
00857 }
00858 
00859 void KOSpellConfig::setIgnoreCase ( bool b )
00860 {
00861     m_bIgnoreCase=b;
00862     if(cbIgnoreCase)
00863       cbIgnoreCase->setChecked(b);
00864 
00865 }
00866 
00867 void KOSpellConfig::setIgnoreAccent ( bool b )
00868 {
00869     m_bIgnoreAccent=b;
00870     if(cbIgnoreAccent)
00871       cbIgnoreAccent->setChecked(b);
00872 
00873 }
00874 
00875 void KOSpellConfig::setSpellWordWithNumber ( bool b )
00876 {
00877     m_bSpellWordWithNumber = b;
00878     if(cbSpellWordWithNumber)
00879       cbSpellWordWithNumber->setChecked(b);
00880 
00881 }
00882 
00883 void KOSpellConfig::setDontCheckTitleCase(bool b)
00884 {
00885     m_bDontCheckTitleCase = b;
00886     if(cbDontCheckTitleCase)
00887       cbDontCheckTitleCase->setChecked(b);
00888 
00889 }
00890 
00891 void KOSpellConfig::setDontCheckUpperWord(bool b)
00892 {
00893     m_bDontCheckUpperWord=b;
00894     if(cbDontCheckUpperWord)
00895       cbDontCheckUpperWord->setChecked(b);
00896 
00897 }
00898 
00899 
00900 QStringList KOSpellConfig::s_aspellLanguageList = QStringList();
00901 QStringList KOSpellConfig::s_aspellLanguageFileName = QStringList();
00902 
00903 QStringList KOSpellConfig::listOfAspellLanguages()
00904 {
00905     if ( s_aspellLanguageList.count()==0 )
00906         createListOfLanguages();
00907     return s_aspellLanguageList;
00908 }
00909 
00910 QStringList KOSpellConfig::listOfLanguageFileName()
00911 {
00912     if ( s_aspellLanguageFileName.count()==0 )
00913         createListOfLanguages();
00914     return s_aspellLanguageFileName;
00915 }
00916 
00917 QString KOSpellConfig::fileNameFromLanguage( const QString & _lang)
00918 {
00919     int pos = s_aspellLanguageList.findIndex( _lang );
00920     if ( pos != -1)
00921     {
00922         return s_aspellLanguageFileName[ pos ];
00923     }
00924     return QString::null;
00925 }
00926 
00927 QString KOSpellConfig::languageFromFileName( const QString &_lang )
00928 {
00929     int pos = s_aspellLanguageFileName.findIndex( _lang );
00930     if ( pos != -1)
00931         return s_aspellLanguageList[ pos ];
00932     else
00933         return QString::null;
00934 }
00935 
00936 void KOSpellConfig::createListOfLanguages()
00937 {
00938     s_aspellLanguageFileName.append(""); // Default
00939     s_aspellLanguageList.append(i18n("ASpell Default"));
00940 
00941     // dictionary path
00942     // FIXME: use "aspell dump config" to find out the dict-dir
00943     QFileInfo dir ("/usr/lib/aspell");
00944     if (!dir.exists() || !dir.isDir())
00945         dir.setFile ("/usr/local/lib/aspell");
00946     if (!dir.exists() || !dir.isDir())
00947         dir.setFile ("/usr/share/aspell");
00948     if (!dir.exists() || !dir.isDir())
00949         dir.setFile ("/usr/local/share/aspell");
00950     if (!dir.exists() || !dir.isDir()) return;
00951 
00952     kdDebug(30006) << "KOSpellConfig::getAvailDictsAspell "
00953                  << dir.filePath() << " " << dir.dirPath() << endl;
00954 
00955     QDir thedir (dir.filePath(),"*");
00956 
00957     kdDebug(30006) << "KOSpellConfig" << thedir.path() << "\n" << endl;
00958     kdDebug(30006) << "entryList().count()="
00959                  << thedir.entryList().count() << endl;
00960 
00961     for (unsigned int i=0; i<thedir.entryList().count(); i++)
00962     {
00963         QString fname, lname, hname;
00964         fname = thedir [i];
00965 
00966         // consider only simple dicts without '-' in the name
00967         // FIXME: may be this is wrong an the list should contain
00968         // all *.multi files too, to allow using special dictionaries
00969         if (fname[0] != '.')
00970     {
00971 
00972             // remove .multi
00973             if (fname.right(6) == ".multi")
00974                 fname.remove (fname.length()-6,6);
00975 
00976             if (interpret (fname, lname, hname) && s_aspellLanguageFileName[0].isEmpty())
00977         { // This one is the KDE default language
00978           // so place it first in the lists (overwrite "Default")
00979 
00980                 s_aspellLanguageFileName.remove ( s_aspellLanguageFileName.begin() );
00981                 s_aspellLanguageFileName.prepend ( fname );
00982 
00983                 hname=i18n("default spelling dictionary"
00984                            ,"Default - %1").arg(hname);
00985                 s_aspellLanguageList[0]=hname;
00986         }
00987             else
00988         {
00989                 s_aspellLanguageFileName.append( fname);
00990                 s_aspellLanguageList.append( hname );
00991         }
00992     }
00993     }
00994 
00995 }
00996 
00997 int KOSpellConfig::indexFromLanguageFileName( const QString &name)
00998 {
00999     int whichelement = 0;
01000     for (unsigned int i=0; i<listOfLanguageFileName().count(); i++)
01001       {
01002     if (listOfLanguageFileName()[i] == name)
01003         {
01004       whichelement=i;
01005           break;
01006         }
01007       }
01008     return whichelement;
01009 }
01010 
01011 
01012 void KOSpellConfig::showEvent( QShowEvent* ev )
01013 {
01014     if ( !d->shown )
01015     {
01016         d->shown = true;
01017         fillInDialog();
01018     }
01019     QWidget::showEvent( ev );
01020 }
01021 
01022 #include "koSconfig.moc"
01023 
01024 
01025 
KDE Logo
This file is part of the documentation for lib Library Version 1.3.5.
Documentation copyright © 1996-2004 the KDE developers.
Generated on Sun Mar 20 14:25:26 2005 by doxygen 1.3.9.1 written by Dimitri van Heesch, © 1997-2003