kdeui Library API Documentation

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