kdecore Library API Documentation

kconfigbase.cpp

00001 // -*- c-basic-offset: 2 -*-
00002 /*
00003    This file is part of the KDE libraries
00004    Copyright (c) 1999 Preston Brown <pbrown@kde.org>
00005    Copyright (c) 1997 Matthias Kalle Dalheimer <kalle@kde.org>
00006 
00007    This library is free software; you can redistribute it and/or
00008    modify it under the terms of the GNU Library General Public
00009    License as published by the Free Software Foundation; either
00010    version 2 of the License, or (at your option) any later version.
00011 
00012    This library is distributed in the hope that it will be useful,
00013    but WITHOUT ANY WARRANTY; without even the implied warranty of
00014    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00015    Library General Public License for more details.
00016 
00017    You should have received a copy of the GNU Library General Public License
00018    along with this library; see the file COPYING.LIB.  If not, write to
00019    the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
00020    Boston, MA 02111-1307, USA.
00021 */
00022 
00023 #include <stdlib.h>
00024 #include <string.h>
00025 
00026 #include <qfile.h>
00027 #include <qdir.h>
00028 #include <qtextstream.h>
00029 
00030 #include <kapplication.h>
00031 #include <kglobal.h>
00032 #include <klocale.h>
00033 #include <kcharsets.h>
00034 
00035 #include "kconfigbase.h"
00036 #include "kconfigbackend.h"
00037 #include "kdebug.h"
00038 #include "kstandarddirs.h"
00039 #undef Bool
00040 
00041 static bool isUtf8(const char *buf) {
00042   int i, n;
00043   register unsigned char c;
00044   bool gotone = false;
00045 
00046 #define F 0   /* character never appears in text */
00047 #define T 1   /* character appears in plain ASCII text */
00048 #define I 2   /* character appears in ISO-8859 text */
00049 #define X 3   /* character appears in non-ISO extended ASCII (Mac, IBM PC) */
00050 
00051   static const unsigned char text_chars[256] = {
00052   /*                  BEL BS HT LF    FF CR    */
00053         F, F, F, F, F, F, F, T, T, T, T, F, T, T, F, F,  /* 0x0X */
00054         /*                              ESC          */
00055         F, F, F, F, F, F, F, F, F, F, F, T, F, F, F, F,  /* 0x1X */
00056         T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T,  /* 0x2X */
00057         T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T,  /* 0x3X */
00058         T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T,  /* 0x4X */
00059         T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T,  /* 0x5X */
00060         T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T,  /* 0x6X */
00061         T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, F,  /* 0x7X */
00062         /*            NEL                            */
00063         X, X, X, X, X, T, X, X, X, X, X, X, X, X, X, X,  /* 0x8X */
00064         X, X, X, X, X, X, X, X, X, X, X, X, X, X, X, X,  /* 0x9X */
00065         I, I, I, I, I, I, I, I, I, I, I, I, I, I, I, I,  /* 0xaX */
00066         I, I, I, I, I, I, I, I, I, I, I, I, I, I, I, I,  /* 0xbX */
00067         I, I, I, I, I, I, I, I, I, I, I, I, I, I, I, I,  /* 0xcX */
00068         I, I, I, I, I, I, I, I, I, I, I, I, I, I, I, I,  /* 0xdX */
00069         I, I, I, I, I, I, I, I, I, I, I, I, I, I, I, I,  /* 0xeX */
00070         I, I, I, I, I, I, I, I, I, I, I, I, I, I, I, I   /* 0xfX */
00071   };
00072 
00073   /* *ulen = 0; */
00074   for (i = 0; (c = buf[i]); i++) {
00075     if ((c & 0x80) == 0) {        /* 0xxxxxxx is plain ASCII */
00076       /*
00077        * Even if the whole file is valid UTF-8 sequences,
00078        * still reject it if it uses weird control characters.
00079        */
00080 
00081       if (text_chars[c] != T)
00082         return false;
00083 
00084     } else if ((c & 0x40) == 0) { /* 10xxxxxx never 1st byte */
00085       return false;
00086     } else {                           /* 11xxxxxx begins UTF-8 */
00087       int following;
00088 
00089     if ((c & 0x20) == 0) {             /* 110xxxxx */
00090       following = 1;
00091     } else if ((c & 0x10) == 0) {      /* 1110xxxx */
00092       following = 2;
00093     } else if ((c & 0x08) == 0) {      /* 11110xxx */
00094       following = 3;
00095     } else if ((c & 0x04) == 0) {      /* 111110xx */
00096       following = 4;
00097     } else if ((c & 0x02) == 0) {      /* 1111110x */
00098       following = 5;
00099     } else
00100       return false;
00101 
00102       for (n = 0; n < following; n++) {
00103         i++;
00104         if (!(c = buf[i]))
00105           goto done;
00106 
00107         if ((c & 0x80) == 0 || (c & 0x40))
00108           return false;
00109       }
00110       gotone = true;
00111     }
00112   }
00113 done:
00114   return gotone;   /* don't claim it's UTF-8 if it's all 7-bit */
00115 }
00116 
00117 #undef F
00118 #undef T
00119 #undef I
00120 #undef X
00121 
00122 
00123 KConfigBase::KConfigBase()
00124   : backEnd(0L), bDirty(false), bLocaleInitialized(false),
00125     bReadOnly(false), bExpand(false)
00126 {
00127     setGroup(QString::null);
00128 }
00129 
00130 KConfigBase::~KConfigBase()
00131 {
00132 }
00133 
00134 void KConfigBase::setLocale()
00135 {
00136   bLocaleInitialized = true;
00137 
00138   if (KGlobal::locale())
00139     aLocaleString = KGlobal::locale()->language().utf8();
00140   else
00141     aLocaleString = KLocale::defaultLanguage().utf8();
00142   if (backEnd)
00143      backEnd->setLocaleString(aLocaleString);
00144 }
00145 
00146 QString KConfigBase::locale() const
00147 {
00148   return QString::fromUtf8(aLocaleString);
00149 }
00150 
00151 void KConfigBase::setGroup( const QString& group )
00152 {
00153   if ( group.isEmpty() )
00154     mGroup = "<default>";
00155   else
00156     mGroup = group.utf8();
00157 }
00158 
00159 void KConfigBase::setGroup( const char *pGroup )
00160 {
00161   setGroup(QCString(pGroup));
00162 }
00163 
00164 void KConfigBase::setGroup( const QCString &group )
00165 {
00166   if ( group.isEmpty() )
00167     mGroup = "<default>";
00168   else
00169     mGroup = group;
00170 }
00171 
00172 QString KConfigBase::group() const {
00173   return QString::fromUtf8(mGroup);
00174 }
00175 
00176 void KConfigBase::setDesktopGroup()
00177 {
00178   mGroup = "Desktop Entry";
00179 }
00180 
00181 bool KConfigBase::hasKey(const QString &key) const
00182 {
00183    return hasKey(key.utf8().data());
00184 }
00185 
00186 bool KConfigBase::hasKey(const char *pKey) const
00187 {
00188   KEntryKey aEntryKey(mGroup, 0);
00189   aEntryKey.c_key = pKey;
00190 
00191   if (!locale().isNull()) {
00192     // try the localized key first
00193     aEntryKey.bLocal = true;
00194     KEntry entry = lookupData(aEntryKey);
00195     if (!entry.mValue.isNull())
00196        return true;
00197     aEntryKey.bLocal = false;
00198   }
00199 
00200   // try the non-localized version
00201   KEntry entry = lookupData(aEntryKey);
00202   return !entry.mValue.isNull();
00203 }
00204 
00205 bool KConfigBase::hasGroup(const QString &group) const
00206 {
00207   return internalHasGroup( group.utf8());
00208 }
00209 
00210 bool KConfigBase::hasGroup(const char *_pGroup) const
00211 {
00212   return internalHasGroup( QCString(_pGroup));
00213 }
00214 
00215 bool KConfigBase::hasGroup(const QCString &_pGroup) const
00216 {
00217   return internalHasGroup( _pGroup);
00218 }
00219 
00220 bool KConfigBase::isImmutable() const
00221 {
00222   return (getConfigState() != ReadWrite);
00223 }
00224 
00225 bool KConfigBase::groupIsImmutable(const QString &group) const
00226 {
00227   if (getConfigState() != ReadWrite)
00228      return true;
00229 
00230   KEntryKey groupKey(group.utf8(), 0);
00231   KEntry entry = lookupData(groupKey);
00232   return entry.bImmutable;
00233 }
00234 
00235 bool KConfigBase::entryIsImmutable(const QString &key) const
00236 {
00237   if (getConfigState() != ReadWrite)
00238      return true;
00239 
00240   KEntryKey entryKey(mGroup, 0);
00241   KEntry aEntryData = lookupData(entryKey); // Group
00242   if (aEntryData.bImmutable)
00243     return true;
00244 
00245   QCString utf8_key = key.utf8();
00246   entryKey.c_key = utf8_key.data();
00247   aEntryData = lookupData(entryKey); // Normal entry
00248   if (aEntryData.bImmutable)
00249     return true;
00250 
00251   entryKey.bLocal = true;
00252   aEntryData = lookupData(entryKey); // Localized entry
00253   return aEntryData.bImmutable;
00254 }
00255 
00256 
00257 QString KConfigBase::readEntryUntranslated( const QString& pKey,
00258                                 const QString& aDefault ) const
00259 {
00260    return KConfigBase::readEntryUntranslated(pKey.utf8().data(), aDefault);
00261 }
00262 
00263 
00264 QString KConfigBase::readEntryUntranslated( const char *pKey,
00265                                 const QString& aDefault ) const
00266 {
00267    QCString result = readEntryUtf8(pKey);
00268    if (result.isNull())
00269       return aDefault;
00270    return QString::fromUtf8(result);
00271 }
00272 
00273 
00274 QString KConfigBase::readEntry( const QString& pKey,
00275                                 const QString& aDefault ) const
00276 {
00277    return KConfigBase::readEntry(pKey.utf8().data(), aDefault);
00278 }
00279 
00280 QString KConfigBase::readEntry( const char *pKey,
00281                                 const QString& aDefault ) const
00282 {
00283   // we need to access _locale instead of the method locale()
00284   // because calling locale() will create a locale object if it
00285   // doesn't exist, which requires KConfig, which will create a infinite
00286   // loop, and nobody likes those.
00287   if (!bLocaleInitialized && KGlobal::_locale) {
00288     // get around const'ness.
00289     KConfigBase *that = const_cast<KConfigBase *>(this);
00290     that->setLocale();
00291   }
00292 
00293   QString aValue;
00294 
00295   bool expand = false;
00296   // construct a localized version of the key
00297   // try the localized key first
00298   KEntry aEntryData;
00299   KEntryKey entryKey(mGroup, 0);
00300   entryKey.c_key = pKey;
00301   entryKey.bLocal = true;
00302   aEntryData = lookupData(entryKey);
00303   if (!aEntryData.mValue.isNull()) {
00304 
00305     // for GNOME .desktop
00306     // const char *data = aEntryData.mValue.char();
00307     if ( isUtf8(aEntryData.mValue.data() ) )
00308       aValue = QString::fromUtf8( aEntryData.mValue.data() );
00309     else
00310       aValue = QString::fromLocal8Bit(aEntryData.mValue.data());
00311     expand = aEntryData.bExpand;
00312 
00313     // Ok this sucks. QString::fromUtf8("").isNull() is true,
00314     // but QString::fromLatin1("").isNull() returns false.
00315     if (aValue.isNull())
00316     {
00317       static const QString &emptyString = KGlobal::staticQString("");
00318       aValue = emptyString;
00319     }
00320   } else {
00321     entryKey.bLocal = false;
00322     aEntryData = lookupData(entryKey);
00323     if (!aEntryData.mValue.isNull()) {
00324       aValue = QString::fromUtf8(aEntryData.mValue.data());
00325       if (aValue.isNull())
00326       {
00327         static const QString &emptyString = KGlobal::staticQString("");
00328         aValue = emptyString;
00329       }
00330       expand = aEntryData.bExpand;
00331     } else {
00332       aValue = aDefault;
00333     }
00334   }
00335 
00336   // only do dollar expansion if so desired
00337   if( expand || bExpand )
00338     {
00339       // check for environment variables and make necessary translations
00340       int nDollarPos = aValue.find( '$' );
00341 
00342       while( nDollarPos != -1 && nDollarPos+1 < static_cast<int>(aValue.length())) {
00343         // there is at least one $
00344         if( (aValue)[nDollarPos+1] == '(' ) {
00345           uint nEndPos = nDollarPos+1;
00346           // the next character is no $
00347           while ( (nEndPos <= aValue.length()) && (aValue[nEndPos]!=')') )
00348               nEndPos++;
00349           nEndPos++;
00350           QString cmd = aValue.mid( nDollarPos+2, nEndPos-nDollarPos-3 );
00351 
00352           QString result;
00353           FILE *fs = popen(QFile::encodeName(cmd).data(), "r");
00354           if (fs)
00355           {
00356              QTextStream ts(fs, IO_ReadOnly);
00357              result = ts.read().stripWhiteSpace();
00358              pclose(fs);
00359           }
00360           aValue.replace( nDollarPos, nEndPos-nDollarPos, result );
00361         } else if( (aValue)[nDollarPos+1] != '$' ) {
00362           uint nEndPos = nDollarPos+1;
00363           // the next character is no $
00364           QString aVarName;
00365           if (aValue[nEndPos]=='{')
00366           {
00367             while ( (nEndPos <= aValue.length()) && (aValue[nEndPos]!='}') )
00368                 nEndPos++;
00369             nEndPos++;
00370             aVarName = aValue.mid( nDollarPos+2, nEndPos-nDollarPos-3 );
00371           }
00372           else
00373           {
00374             while ( nEndPos <= aValue.length() && (aValue[nEndPos].isNumber()
00375                     || aValue[nEndPos].isLetter() || aValue[nEndPos]=='_' )  )
00376                 nEndPos++;
00377             aVarName = aValue.mid( nDollarPos+1, nEndPos-nDollarPos-1 );
00378           }
00379           const char* pEnv = 0;
00380           if (!aVarName.isEmpty())
00381                pEnv = getenv( aVarName.ascii() );
00382           if( pEnv ) {
00383         // !!! Sergey A. Sukiyazov <corwin@micom.don.ru> !!!
00384         // A environment variables may contain values in 8bit
00385         // locale cpecified encoding or in UTF8 encoding.
00386         if (isUtf8( pEnv ))
00387         aValue.replace( nDollarPos, nEndPos-nDollarPos, QString::fromUtf8(pEnv) );
00388         else
00389         aValue.replace( nDollarPos, nEndPos-nDollarPos, QString::fromLocal8Bit(pEnv) );
00390           } else
00391             aValue.remove( nDollarPos, nEndPos-nDollarPos );
00392         } else {
00393           // remove one of the dollar signs
00394           aValue.remove( nDollarPos, 1 );
00395           nDollarPos++;
00396         }
00397         nDollarPos = aValue.find( '$', nDollarPos );
00398       }
00399     }
00400 
00401   return aValue;
00402 }
00403 
00404 QCString KConfigBase::readEntryUtf8( const char *pKey) const
00405 {
00406   // We don't try the localized key
00407   KEntryKey entryKey(mGroup, 0);
00408   entryKey.c_key = pKey;
00409   KEntry aEntryData = lookupData(entryKey);
00410   if (aEntryData.bExpand)
00411   {
00412      // We need to do fancy, take the slow route.
00413      return readEntry(pKey, QString::null).utf8();
00414   }
00415   return aEntryData.mValue;
00416 }
00417 
00418 QVariant KConfigBase::readPropertyEntry( const QString& pKey,
00419                                           QVariant::Type type ) const
00420 {
00421   return readPropertyEntry(pKey.utf8().data(), type);
00422 }
00423 
00424 QVariant KConfigBase::readPropertyEntry( const char *pKey,
00425                                           QVariant::Type type ) const
00426 {
00427   QVariant va;
00428   if ( !hasKey( pKey ) ) return va;
00429   (void)va.cast(type);
00430   return readPropertyEntry(pKey, va);
00431 }
00432 
00433 QVariant KConfigBase::readPropertyEntry( const QString& pKey,
00434                                          const QVariant &aDefault ) const
00435 {
00436   return readPropertyEntry(pKey.utf8().data(), aDefault);
00437 }
00438 
00439 QVariant KConfigBase::readPropertyEntry( const char *pKey,
00440                                          const QVariant &aDefault ) const
00441 {
00442   if ( !hasKey( pKey ) ) return aDefault;
00443 
00444   QVariant tmp = aDefault;
00445 
00446   switch( aDefault.type() )
00447   {
00448       case QVariant::Invalid:
00449           return QVariant();
00450       case QVariant::String:
00451           return QVariant( readEntry( pKey, aDefault.toString() ) );
00452       case QVariant::StringList:
00453           return QVariant( readListEntry( pKey ) );
00454       case QVariant::List: {
00455           QStringList strList = readListEntry( pKey );
00456           QStringList::ConstIterator it = strList.begin();
00457           QStringList::ConstIterator end = strList.end();
00458           QValueList<QVariant> list;
00459 
00460           for (; it != end; ++it ) {
00461               tmp = *it;
00462               list.append( tmp );
00463           }
00464           return QVariant( list );
00465       }
00466       case QVariant::Font:
00467           return QVariant( readFontEntry( pKey, &tmp.asFont() ) );
00468       case QVariant::Point:
00469           return QVariant( readPointEntry( pKey, &tmp.asPoint() ) );
00470       case QVariant::Rect:
00471           return QVariant( readRectEntry( pKey, &tmp.asRect() ) );
00472       case QVariant::Size:
00473           return QVariant( readSizeEntry( pKey, &tmp.asSize() ) );
00474       case QVariant::Color:
00475           return QVariant( readColorEntry( pKey, &tmp.asColor() ) );
00476       case QVariant::Int:
00477           return QVariant( readNumEntry( pKey, aDefault.toInt() ) );
00478       case QVariant::UInt:
00479           return QVariant( readUnsignedNumEntry( pKey, aDefault.toUInt() ) );
00480       case QVariant::Bool:
00481           return QVariant( readBoolEntry( pKey, aDefault.toBool() ), 0 );
00482       case QVariant::Double:
00483           return QVariant( readDoubleNumEntry( pKey, aDefault.toDouble() ) );
00484       case QVariant::DateTime:
00485           return QVariant( readDateTimeEntry( pKey, &tmp.asDateTime() ) );
00486       case QVariant::Date:
00487           return QVariant(readDateTimeEntry( pKey, &tmp.asDateTime() ).date());
00488 
00489       case QVariant::Pixmap:
00490       case QVariant::Image:
00491       case QVariant::Brush:
00492       case QVariant::Palette:
00493       case QVariant::ColorGroup:
00494       case QVariant::Map:
00495       case QVariant::IconSet:
00496       case QVariant::CString:
00497       case QVariant::PointArray:
00498       case QVariant::Region:
00499       case QVariant::Bitmap:
00500       case QVariant::Cursor:
00501       case QVariant::SizePolicy:
00502       case QVariant::Time:
00503       case QVariant::ByteArray:
00504       case QVariant::BitArray:
00505       case QVariant::KeySequence:
00506       case QVariant::Pen:
00507           break;
00508   }
00509 
00510   Q_ASSERT( 0 );
00511   return QVariant();
00512 }
00513 
00514 int KConfigBase::readListEntry( const QString& pKey,
00515                                 QStrList &list, char sep ) const
00516 {
00517   return readListEntry(pKey.utf8().data(), list, sep);
00518 }
00519 
00520 int KConfigBase::readListEntry( const char *pKey,
00521                                 QStrList &list, char sep ) const
00522 {
00523   if( !hasKey( pKey ) )
00524     return 0;
00525 
00526   QCString str_list = readEntryUtf8( pKey );
00527   if (str_list.isEmpty())
00528     return 0;
00529 
00530   list.clear();
00531   QCString value = "";
00532   int len = str_list.length();
00533 
00534   for (int i = 0; i < len; i++) {
00535     if (str_list[i] != sep && str_list[i] != '\\') {
00536       value += str_list[i];
00537       continue;
00538     }
00539     if (str_list[i] == '\\') {
00540       i++;
00541       value += str_list[i];
00542       continue;
00543     }
00544     // if we fell through to here, we are at a separator.  Append
00545     // contents of value to the list
00546     // !!! Sergey A. Sukiyazov <corwin@micom.don.ru> !!!
00547     // A QStrList may contain values in 8bit locale cpecified
00548     // encoding
00549     list.append( value );
00550     value.truncate(0);
00551   }
00552 
00553   if ( str_list[len-1] != sep || ( len > 1 && str_list[len-2] == '\\' ) )
00554     list.append( value );
00555   return list.count();
00556 }
00557 
00558 QStringList KConfigBase::readListEntry( const QString& pKey, char sep ) const
00559 {
00560   return readListEntry(pKey.utf8().data(), sep);
00561 }
00562 
00563 QStringList KConfigBase::readListEntry( const char *pKey, char sep ) const
00564 {
00565   QStringList list;
00566   if( !hasKey( pKey ) )
00567     return list;
00568   QString str_list = readEntry( pKey );
00569   if( str_list.isEmpty() )
00570     return list;
00571   QString value = "";
00572   int len = str_list.length();
00573   for( int i = 0; i < len; i++ )
00574     {
00575       if( str_list[i] != sep && str_list[i] != '\\' )
00576         {
00577           value += str_list[i];
00578           continue;
00579         }
00580       if( str_list[i] == '\\' )
00581         {
00582           i++;
00583           value += str_list[i];
00584           continue;
00585         }
00586       list.append( value );
00587       value.truncate(0);
00588     }
00589   if ( str_list[len-1] != sep || ( len > 1 && str_list[len-2] == '\\' ) )
00590     list.append( value );
00591   return list;
00592 }
00593 
00594 QValueList<int> KConfigBase::readIntListEntry( const QString& pKey ) const
00595 {
00596   return readIntListEntry(pKey.utf8().data());
00597 }
00598 
00599 QValueList<int> KConfigBase::readIntListEntry( const char *pKey ) const
00600 {
00601   QStringList strlist = readListEntry(pKey);
00602   QValueList<int> list;
00603   for (QStringList::ConstIterator it = strlist.begin(); it != strlist.end(); it++)
00604     // I do not check if the toInt failed because I consider the number of items
00605     // more important than their value
00606     list << (*it).toInt();
00607 
00608   return list;
00609 }
00610 
00611 QString KConfigBase::readPathEntry( const QString& pKey, const QString& pDefault ) const
00612 {
00613   return readPathEntry(pKey.utf8().data(), pDefault);
00614 }
00615 
00616 QString KConfigBase::readPathEntry( const char *pKey, const QString& pDefault ) const
00617 {
00618   const bool bExpandSave = bExpand;
00619   bExpand = true;
00620   QString aValue = readEntry( pKey, pDefault );
00621   bExpand = bExpandSave;
00622   return aValue;
00623 }
00624 
00625 QStringList KConfigBase::readPathListEntry( const QString& pKey, char sep ) const
00626 {
00627   return readPathListEntry(pKey.utf8().data(), sep);
00628 }
00629 
00630 QStringList KConfigBase::readPathListEntry( const char *pKey, char sep ) const
00631 {
00632   const bool bExpandSave = bExpand;
00633   bExpand = true;
00634   QStringList aValue = readListEntry( pKey, sep );
00635   bExpand = bExpandSave;
00636   return aValue;
00637 }
00638 
00639 int KConfigBase::readNumEntry( const QString& pKey, int nDefault) const
00640 {
00641   return readNumEntry(pKey.utf8().data(), nDefault);
00642 }
00643 
00644 int KConfigBase::readNumEntry( const char *pKey, int nDefault) const
00645 {
00646   QCString aValue = readEntryUtf8( pKey );
00647   if( aValue.isNull() )
00648     return nDefault;
00649   else if( aValue == "true" || aValue == "on" || aValue == "yes" )
00650     return 1;
00651   else
00652     {
00653       bool ok;
00654       int rc = aValue.toInt( &ok );
00655       return( ok ? rc : nDefault );
00656     }
00657 }
00658 
00659 
00660 unsigned int KConfigBase::readUnsignedNumEntry( const QString& pKey, unsigned int nDefault) const
00661 {
00662   return readUnsignedNumEntry(pKey.utf8().data(), nDefault);
00663 }
00664 
00665 unsigned int KConfigBase::readUnsignedNumEntry( const char *pKey, unsigned int nDefault) const
00666 {
00667   QCString aValue = readEntryUtf8( pKey );
00668   if( aValue.isNull() )
00669     return nDefault;
00670   else
00671     {
00672       bool ok;
00673       unsigned int rc = aValue.toUInt( &ok );
00674       return( ok ? rc : nDefault );
00675     }
00676 }
00677 
00678 
00679 long KConfigBase::readLongNumEntry( const QString& pKey, long nDefault) const
00680 {
00681   return readLongNumEntry(pKey.utf8().data(), nDefault);
00682 }
00683 
00684 long KConfigBase::readLongNumEntry( const char *pKey, long nDefault) const
00685 {
00686   QCString aValue = readEntryUtf8( pKey );
00687   if( aValue.isNull() )
00688     return nDefault;
00689   else
00690     {
00691       bool ok;
00692       long rc = aValue.toLong( &ok );
00693       return( ok ? rc : nDefault );
00694     }
00695 }
00696 
00697 
00698 unsigned long KConfigBase::readUnsignedLongNumEntry( const QString& pKey, unsigned long nDefault) const
00699 {
00700   return readUnsignedLongNumEntry(pKey.utf8().data(), nDefault);
00701 }
00702 
00703 unsigned long KConfigBase::readUnsignedLongNumEntry( const char *pKey, unsigned long nDefault) const
00704 {
00705   QCString aValue = readEntryUtf8( pKey );
00706   if( aValue.isNull() )
00707     return nDefault;
00708   else
00709     {
00710       bool ok;
00711       unsigned long rc = aValue.toULong( &ok );
00712       return( ok ? rc : nDefault );
00713     }
00714 }
00715 
00716 double KConfigBase::readDoubleNumEntry( const QString& pKey, double nDefault) const
00717 {
00718   return readDoubleNumEntry(pKey.utf8().data(), nDefault);
00719 }
00720 
00721 double KConfigBase::readDoubleNumEntry( const char *pKey, double nDefault) const
00722 {
00723   QCString aValue = readEntryUtf8( pKey );
00724   if( aValue.isNull() )
00725     return nDefault;
00726   else
00727     {
00728       bool ok;
00729       double rc = aValue.toDouble( &ok );
00730       return( ok ? rc : nDefault );
00731     }
00732 }
00733 
00734 
00735 bool KConfigBase::readBoolEntry( const QString& pKey, const bool bDefault ) const
00736 {
00737    return readBoolEntry(pKey.utf8().data(), bDefault);
00738 }
00739 
00740 bool KConfigBase::readBoolEntry( const char *pKey, const bool bDefault ) const
00741 {
00742   QCString aValue = readEntryUtf8( pKey );
00743 
00744   if( aValue.isNull() )
00745     return bDefault;
00746   else
00747     {
00748       if( aValue == "true" || aValue == "on" || aValue == "yes" || aValue == "1" )
00749         return true;
00750       else
00751         {
00752           bool bOK;
00753           int val = aValue.toInt( &bOK );
00754           if( bOK && val != 0 )
00755             return true;
00756           else
00757             return false;
00758         }
00759     }
00760 }
00761 
00762 QFont KConfigBase::readFontEntry( const QString& pKey, const QFont* pDefault ) const
00763 {
00764   return readFontEntry(pKey.utf8().data(), pDefault);
00765 }
00766 
00767 QFont KConfigBase::readFontEntry( const char *pKey, const QFont* pDefault ) const
00768 {
00769   QFont aRetFont;
00770 
00771   QString aValue = readEntry( pKey );
00772   if( !aValue.isNull() ) {
00773     if ( aValue.contains( ',' ) > 5 ) {
00774       // KDE3 and upwards entry
00775       if ( !aRetFont.fromString( aValue ) && pDefault )
00776         aRetFont = *pDefault;
00777     }
00778     else {
00779       // backward compatibility with older font formats
00780       // ### remove KDE 3.1 ?
00781       // find first part (font family)
00782       int nIndex = aValue.find( ',' );
00783       if( nIndex == -1 ){
00784         if( pDefault )
00785           aRetFont = *pDefault;
00786         return aRetFont;
00787       }
00788       aRetFont.setFamily( aValue.left( nIndex ) );
00789 
00790       // find second part (point size)
00791       int nOldIndex = nIndex;
00792       nIndex = aValue.find( ',', nOldIndex+1 );
00793       if( nIndex == -1 ){
00794         if( pDefault )
00795           aRetFont = *pDefault;
00796         return aRetFont;
00797       }
00798 
00799       aRetFont.setPointSize( aValue.mid( nOldIndex+1,
00800                                          nIndex-nOldIndex-1 ).toInt() );
00801 
00802       // find third part (style hint)
00803       nOldIndex = nIndex;
00804       nIndex = aValue.find( ',', nOldIndex+1 );
00805 
00806       if( nIndex == -1 ){
00807         if( pDefault )
00808           aRetFont = *pDefault;
00809         return aRetFont;
00810       }
00811 
00812       aRetFont.setStyleHint( (QFont::StyleHint)aValue.mid( nOldIndex+1, nIndex-nOldIndex-1 ).toUInt() );
00813 
00814       // find fourth part (char set)
00815       nOldIndex = nIndex;
00816       nIndex = aValue.find( ',', nOldIndex+1 );
00817 
00818       if( nIndex == -1 ){
00819         if( pDefault )
00820           aRetFont = *pDefault;
00821         return aRetFont;
00822       }
00823 
00824       QString chStr=aValue.mid( nOldIndex+1,
00825                                 nIndex-nOldIndex-1 );
00826       // find fifth part (weight)
00827       nOldIndex = nIndex;
00828       nIndex = aValue.find( ',', nOldIndex+1 );
00829 
00830       if( nIndex == -1 ){
00831         if( pDefault )
00832           aRetFont = *pDefault;
00833         return aRetFont;
00834       }
00835 
00836       aRetFont.setWeight( aValue.mid( nOldIndex+1,
00837                                       nIndex-nOldIndex-1 ).toUInt() );
00838 
00839       // find sixth part (font bits)
00840       uint nFontBits = aValue.right( aValue.length()-nIndex-1 ).toUInt();
00841 
00842       aRetFont.setItalic( nFontBits & 0x01 );
00843       aRetFont.setUnderline( nFontBits & 0x02 );
00844       aRetFont.setStrikeOut( nFontBits & 0x04 );
00845       aRetFont.setFixedPitch( nFontBits & 0x08 );
00846       aRetFont.setRawMode( nFontBits & 0x20 );
00847     }
00848   }
00849   else
00850     {
00851       if( pDefault )
00852         aRetFont = *pDefault;
00853     }
00854 
00855   return aRetFont;
00856 }
00857 
00858 
00859 QRect KConfigBase::readRectEntry( const QString& pKey, const QRect* pDefault ) const
00860 {
00861   return readRectEntry(pKey.utf8().data(), pDefault);
00862 }
00863 
00864 QRect KConfigBase::readRectEntry( const char *pKey, const QRect* pDefault ) const
00865 {
00866   QCString aValue = readEntryUtf8(pKey);
00867 
00868   if (!aValue.isEmpty())
00869   {
00870     int left, top, width, height;
00871 
00872     if (sscanf(aValue.data(), "%d,%d,%d,%d", &left, &top, &width, &height) == 4)
00873     {
00874        return QRect(left, top, width, height);
00875     }
00876   }
00877   if (pDefault)
00878     return *pDefault;
00879   return QRect();
00880 }
00881 
00882 
00883 QPoint KConfigBase::readPointEntry( const QString& pKey,
00884                                     const QPoint* pDefault ) const
00885 {
00886   return readPointEntry(pKey.utf8().data(), pDefault);
00887 }
00888 
00889 QPoint KConfigBase::readPointEntry( const char *pKey,
00890                                     const QPoint* pDefault ) const
00891 {
00892   QCString aValue = readEntryUtf8(pKey);
00893 
00894   if (!aValue.isEmpty())
00895   {
00896     int x,y;
00897 
00898     if (sscanf(aValue.data(), "%d,%d", &x, &y) == 2)
00899     {
00900        return QPoint(x,y);
00901     }
00902   }
00903   if (pDefault)
00904     return *pDefault;
00905   return QPoint();
00906 }
00907 
00908 QSize KConfigBase::readSizeEntry( const QString& pKey,
00909                                   const QSize* pDefault ) const
00910 {
00911   return readSizeEntry(pKey.utf8().data(), pDefault);
00912 }
00913 
00914 QSize KConfigBase::readSizeEntry( const char *pKey,
00915                                   const QSize* pDefault ) const
00916 {
00917   QCString aValue = readEntryUtf8(pKey);
00918 
00919   if (!aValue.isEmpty())
00920   {
00921     int width,height;
00922 
00923     if (sscanf(aValue.data(), "%d,%d", &width, &height) == 2)
00924     {
00925        return QSize(width, height);
00926     }
00927   }
00928   if (pDefault)
00929     return *pDefault;
00930   return QSize();
00931 }
00932 
00933 
00934 QColor KConfigBase::readColorEntry( const QString& pKey,
00935                                     const QColor* pDefault ) const
00936 {
00937   return readColorEntry(pKey.utf8().data(), pDefault);
00938 }
00939 
00940 QColor KConfigBase::readColorEntry( const char *pKey,
00941                                     const QColor* pDefault ) const
00942 {
00943   QColor aRetColor;
00944   int nRed = 0, nGreen = 0, nBlue = 0;
00945 
00946   QString aValue = readEntry( pKey );
00947   if( !aValue.isEmpty() )
00948     {
00949       if ( aValue.at(0) == '#' )
00950         {
00951           aRetColor.setNamedColor(aValue);
00952         }
00953       else
00954         {
00955 
00956           bool bOK;
00957 
00958           // find first part (red)
00959           int nIndex = aValue.find( ',' );
00960 
00961           if( nIndex == -1 ){
00962             // return a sensible default -- Bernd
00963             if( pDefault )
00964               aRetColor = *pDefault;
00965             return aRetColor;
00966           }
00967 
00968           nRed = aValue.left( nIndex ).toInt( &bOK );
00969 
00970           // find second part (green)
00971           int nOldIndex = nIndex;
00972           nIndex = aValue.find( ',', nOldIndex+1 );
00973 
00974           if( nIndex == -1 ){
00975             // return a sensible default -- Bernd
00976             if( pDefault )
00977               aRetColor = *pDefault;
00978             return aRetColor;
00979           }
00980           nGreen = aValue.mid( nOldIndex+1,
00981                                nIndex-nOldIndex-1 ).toInt( &bOK );
00982 
00983           // find third part (blue)
00984           nBlue = aValue.right( aValue.length()-nIndex-1 ).toInt( &bOK );
00985 
00986           aRetColor.setRgb( nRed, nGreen, nBlue );
00987         }
00988     }
00989   else {
00990 
00991     if( pDefault )
00992       aRetColor = *pDefault;
00993   }
00994 
00995   return aRetColor;
00996 }
00997 
00998 
00999 QDateTime KConfigBase::readDateTimeEntry( const QString& pKey,
01000                                           const QDateTime* pDefault ) const
01001 {
01002   return readDateTimeEntry(pKey.utf8().data(), pDefault);
01003 }
01004 
01005 // ### currentDateTime() as fallback ? (Harri)
01006 QDateTime KConfigBase::readDateTimeEntry( const char *pKey,
01007                                           const QDateTime* pDefault ) const
01008 {
01009   if( !hasKey( pKey ) )
01010     {
01011       if( pDefault )
01012         return *pDefault;
01013       else
01014         return QDateTime::currentDateTime();
01015     }
01016 
01017   QStrList list;
01018   int count = readListEntry( pKey, list, ',' );
01019   if( count == 6 ) {
01020     QDate date( atoi( list.at( 0 ) ), atoi( list.at( 1 ) ),
01021                 atoi( list.at( 2 ) ) );
01022     QTime time( atoi( list.at( 3 ) ), atoi( list.at( 4 ) ),
01023                 atoi( list.at( 5 ) ) );
01024 
01025     return QDateTime( date, time );
01026   }
01027 
01028   return QDateTime::currentDateTime();
01029 }
01030 
01031 void KConfigBase::writeEntry( const QString& pKey, const QString& value,
01032                                  bool bPersistent,
01033                                  bool bGlobal,
01034                                  bool bNLS )
01035 {
01036    writeEntry(pKey.utf8().data(), value, bPersistent,  bGlobal, bNLS);
01037 }
01038 
01039 void KConfigBase::writeEntry( const char *pKey, const QString& value,
01040                                  bool bPersistent,
01041                                  bool bGlobal,
01042                                  bool bNLS )
01043 {
01044   // the KConfig object is dirty now
01045   // set this before any IO takes place so that if any derivative
01046   // classes do caching, they won't try and flush the cache out
01047   // from under us before we read. A race condition is still
01048   // possible but minimized.
01049   if( bPersistent )
01050     setDirty(true);
01051 
01052   if (!bLocaleInitialized && KGlobal::locale())
01053     setLocale();
01054 
01055   KEntryKey entryKey(mGroup, pKey);
01056   entryKey.bLocal = bNLS;
01057 
01058   KEntry aEntryData;
01059   aEntryData.mValue = value.utf8();  // set new value
01060   aEntryData.bGlobal = bGlobal;
01061   aEntryData.bNLS = bNLS;
01062 
01063   if (bPersistent)
01064     aEntryData.bDirty = true;
01065 
01066   // rewrite the new value
01067   putData(entryKey, aEntryData, true);
01068 }
01069 
01070 void KConfigBase::writePathEntry( const QString& pKey, const QString & path,
01071                                   bool bPersistent, bool bGlobal,
01072                                   bool bNLS)
01073 {
01074    writePathEntry(pKey.utf8().data(), path, bPersistent, bGlobal, bNLS);
01075 }
01076 
01077 
01078 static bool cleanHomeDirPath( QString &path, const QString &homeDir )
01079 {
01080    if (!path.startsWith(homeDir))
01081         return false;
01082 
01083    unsigned int len = homeDir.length();
01084    // replace by "$HOME" if possible
01085    if (path.length() == len || path[len] == '/') {
01086         path = path.replace(0, len, QString::fromLatin1("$HOME"));
01087         return true;
01088    } else 
01089         return false;
01090 }
01091 
01092 static QString translatePath( QString path )
01093 {
01094    if (path.isEmpty())
01095        return path;
01096 
01097    bool startsWithFile = path.left(5).lower() == QString::fromLatin1("file:");
01098 
01099    // return original path, if it refers to another type of URL (e.g. http:/), or
01100    // if the path is already relative to another directory
01101    if (!startsWithFile && path[0] != '/' ||
01102         startsWithFile && path[5] != '/')
01103     return path;
01104 
01105    if (startsWithFile)
01106         path.remove(0,5); // strip leading "file:/" off the string
01107 
01108    // we can not use KGlobal::dirs()->relativeLocation("home", path) here,
01109    // since it would not recognize paths without a trailing '/'.
01110    // All of the 3 following functions to return the user's home directory
01111    // can return different paths. We have to test all them.
01112    QString homeDir0 = QFile::decodeName(getenv("HOME"));
01113    QString homeDir1 = QDir::homeDirPath();
01114    QString homeDir2 = QDir(homeDir1).canonicalPath();
01115    if (cleanHomeDirPath(path, homeDir0) || 
01116        cleanHomeDirPath(path, homeDir1) ||
01117        cleanHomeDirPath(path, homeDir2) ) {
01118      // kdDebug() << "Path was replaced\n";
01119    }
01120 
01121    if (startsWithFile)
01122       path.prepend( "file:" );
01123 
01124    return path;
01125 }
01126 
01127 void KConfigBase::writePathEntry( const char *pKey, const QString & path,
01128                                   bool bPersistent, bool bGlobal,
01129                                   bool bNLS)
01130 {
01131    writeEntry(pKey, translatePath(path), bPersistent, bGlobal, bNLS);
01132 }
01133 
01134 void KConfigBase::writePathEntry ( const QString& pKey, const QStringList &list,
01135                                char sep , bool bPersistent,
01136                                bool bGlobal, bool bNLS )
01137 {
01138   writePathEntry(pKey.utf8().data(), list, sep, bPersistent, bGlobal, bNLS);
01139 }
01140 
01141 void KConfigBase::writePathEntry ( const char *pKey, const QStringList &list,
01142                                char sep , bool bPersistent,
01143                                bool bGlobal, bool bNLS )
01144 {
01145   if( list.isEmpty() )
01146     {
01147       writeEntry( pKey, QString::fromLatin1(""), bPersistent );
01148       return;
01149     }
01150   QStringList new_list;
01151   QStringList::ConstIterator it = list.begin();
01152   for( ; it != list.end(); ++it )
01153     {
01154       QString value = *it;
01155       new_list.append( translatePath(value) );
01156     }
01157   writeEntry( pKey, new_list, sep, bPersistent, bGlobal, bNLS );
01158 }
01159 
01160 void KConfigBase::deleteEntry( const QString& pKey,
01161                                  bool bNLS,
01162                                  bool bGlobal)
01163 {
01164    deleteEntry(pKey.utf8().data(), bNLS, bGlobal);
01165 }
01166 
01167 void KConfigBase::deleteEntry( const char *pKey,
01168                                  bool bNLS,
01169                                  bool bGlobal)
01170 {
01171   // the KConfig object is dirty now
01172   // set this before any IO takes place so that if any derivative
01173   // classes do caching, they won't try and flush the cache out
01174   // from under us before we read. A race condition is still
01175   // possible but minimized.
01176   setDirty(true);
01177 
01178   if (!bLocaleInitialized && KGlobal::locale())
01179     setLocale();
01180 
01181   KEntryKey entryKey(mGroup, pKey);
01182   KEntry aEntryData;
01183 
01184   aEntryData.bGlobal = bGlobal;
01185   aEntryData.bNLS = bNLS;
01186   aEntryData.bDirty = true;
01187   aEntryData.bDeleted = true;
01188 
01189   // rewrite the new value
01190   putData(entryKey, aEntryData, true);
01191 }
01192 
01193 bool KConfigBase::deleteGroup( const QString& group, bool bDeep, bool bGlobal )
01194 {
01195   KEntryMap aEntryMap = internalEntryMap(group);
01196 
01197   if (!bDeep) {
01198     // Check if it empty
01199     return aEntryMap.isEmpty();
01200   }
01201 
01202   bool dirty = false;
01203   bool checkGroup = true;
01204   // we want to remove all entries in the group
01205   KEntryMapIterator aIt;
01206   for (aIt = aEntryMap.begin(); aIt != aEntryMap.end(); ++aIt)
01207   {
01208     if (!aIt.key().mKey.isEmpty() && !aIt.key().bDefault && !(*aIt).bDeleted)
01209     {
01210       (*aIt).bDeleted = true;
01211       (*aIt).bDirty = true;
01212       (*aIt).bGlobal = bGlobal;
01213       (*aIt).mValue = 0;
01214       putData(aIt.key(), *aIt, checkGroup);
01215       checkGroup = false;
01216       dirty = true;
01217     }
01218   }
01219   if (dirty)
01220      setDirty(true);
01221   return true;
01222 }
01223 
01224 void KConfigBase::writeEntry ( const QString& pKey, const QVariant &prop,
01225                                bool bPersistent,
01226                                bool bGlobal, bool bNLS )
01227 {
01228   writeEntry(pKey.utf8().data(), prop, bPersistent, bGlobal, bNLS);
01229 }
01230 
01231 void KConfigBase::writeEntry ( const char *pKey, const QVariant &prop,
01232                                bool bPersistent,
01233                                bool bGlobal, bool bNLS )
01234 {
01235   switch( prop.type() )
01236     {
01237     case QVariant::Invalid:
01238       writeEntry( pKey, "", bPersistent, bGlobal, bNLS );
01239       return;
01240     case QVariant::String:
01241       writeEntry( pKey, prop.toString(), bPersistent, bGlobal, bNLS );
01242       return;
01243     case QVariant::StringList:
01244       writeEntry( pKey, prop.toStringList(), ',', bPersistent, bGlobal, bNLS );
01245       return;
01246     case QVariant::List: {
01247         QValueList<QVariant> list = prop.toList();
01248         QValueList<QVariant>::ConstIterator it = list.begin();
01249         QValueList<QVariant>::ConstIterator end = list.end();
01250         QStringList strList;
01251 
01252         for (; it != end; ++it )
01253             strList.append( (*it).toString() );
01254 
01255         writeEntry( pKey, strList, ',', bPersistent, bGlobal, bNLS );
01256 
01257         return;
01258     }
01259     case QVariant::Font:
01260       writeEntry( pKey, prop.toFont(), bPersistent, bGlobal, bNLS );
01261       return;
01262     case QVariant::Point:
01263       writeEntry( pKey, prop.toPoint(), bPersistent, bGlobal, bNLS );
01264       return;
01265     case QVariant::Rect:
01266       writeEntry( pKey, prop.toRect(), bPersistent, bGlobal, bNLS );
01267       return;
01268     case QVariant::Size:
01269       writeEntry( pKey, prop.toSize(), bPersistent, bGlobal, bNLS );
01270       return;
01271     case QVariant::Color:
01272       writeEntry( pKey, prop.toColor(), bPersistent, bGlobal, bNLS );
01273       return;
01274     case QVariant::Int:
01275       writeEntry( pKey, prop.toInt(), bPersistent, bGlobal, bNLS );
01276       return;
01277     case QVariant::UInt:
01278       writeEntry( pKey, prop.toUInt(), bPersistent, bGlobal, bNLS );
01279       return;
01280     case QVariant::Bool:
01281       writeEntry( pKey, prop.toBool(), bPersistent, bGlobal, bNLS );
01282       return;
01283     case QVariant::Double:
01284       writeEntry( pKey, prop.toDouble(), bPersistent, bGlobal, 'g', 6, bNLS );
01285       return;
01286     case QVariant::DateTime:
01287       writeEntry( pKey, prop.toDateTime(), bPersistent, bGlobal, bNLS);
01288       return;
01289     case QVariant::Date:
01290       writeEntry( pKey, QDateTime(prop.toDate()), bPersistent, bGlobal, bNLS);
01291       return;
01292 
01293     case QVariant::Pixmap:
01294     case QVariant::Image:
01295     case QVariant::Brush:
01296     case QVariant::Palette:
01297     case QVariant::ColorGroup:
01298     case QVariant::Map:
01299     case QVariant::IconSet:
01300     case QVariant::CString:
01301     case QVariant::PointArray:
01302     case QVariant::Region:
01303     case QVariant::Bitmap:
01304     case QVariant::Cursor:
01305     case QVariant::SizePolicy:
01306     case QVariant::Time:
01307     case QVariant::ByteArray:
01308     case QVariant::BitArray:
01309     case QVariant::KeySequence:
01310     case QVariant::Pen:
01311         break;
01312     }
01313 
01314   Q_ASSERT( 0 );
01315 }
01316 
01317 void KConfigBase::writeEntry ( const QString& pKey, const QStrList &list,
01318                                char sep , bool bPersistent,
01319                                bool bGlobal, bool bNLS )
01320 {
01321   writeEntry(pKey.utf8().data(), list, sep, bPersistent, bGlobal, bNLS);
01322 }
01323 
01324 void KConfigBase::writeEntry ( const char *pKey, const QStrList &list,
01325                                char sep , bool bPersistent,
01326                                bool bGlobal, bool bNLS )
01327 {
01328   if( list.isEmpty() )
01329     {
01330       writeEntry( pKey, QString::fromLatin1(""), bPersistent );
01331       return;
01332     }
01333   QString str_list;
01334   QStrListIterator it( list );
01335   for( ; it.current(); ++it )
01336     {
01337       uint i;
01338       QString value;
01339       // !!! Sergey A. Sukiyazov <corwin@micom.don.ru> !!!
01340       // A QStrList may contain values in 8bit locale cpecified
01341       // encoding or in UTF8 encoding.
01342       if (isUtf8(it.current()))
01343         value = QString::fromUtf8(it.current());
01344       else
01345         value = QString::fromLocal8Bit(it.current());
01346       for( i = 0; i < value.length(); i++ )
01347         {
01348           if( value[i] == sep || value[i] == '\\' )
01349             str_list += '\\';
01350           str_list += value[i];
01351         }
01352       str_list += sep;
01353     }
01354   if( str_list.at(str_list.length() - 1) == sep )
01355     str_list.truncate( str_list.length() -1 );
01356   writeEntry( pKey, str_list, bPersistent, bGlobal, bNLS );
01357 }
01358 
01359 void KConfigBase::writeEntry ( const QString& pKey, const QStringList &list,
01360                                char sep , bool bPersistent,
01361                                bool bGlobal, bool bNLS )
01362 {
01363   writeEntry(pKey.utf8().data(), list, sep, bPersistent, bGlobal, bNLS);
01364 }
01365 
01366 void KConfigBase::writeEntry ( const char *pKey, const QStringList &list,
01367                                char sep , bool bPersistent,
01368                                bool bGlobal, bool bNLS )
01369 {
01370   if( list.isEmpty() )
01371     {
01372       writeEntry( pKey, QString::fromLatin1(""), bPersistent );
01373       return;
01374     }
01375   QString str_list;
01376   QStringList::ConstIterator it = list.begin();
01377   for( ; it != list.end(); ++it )
01378     {
01379       QString value = *it;
01380       uint i;
01381       for( i = 0; i < value.length(); i++ )
01382         {
01383           if( value[i] == sep || value[i] == '\\' )
01384             str_list += '\\';
01385           str_list += value[i];
01386         }
01387       str_list += sep;
01388     }
01389   if( str_list.at(str_list.length() - 1) == sep )
01390     str_list.truncate( str_list.length() -1 );
01391   writeEntry( pKey, str_list, bPersistent, bGlobal, bNLS );
01392 }
01393 
01394 void KConfigBase::writeEntry ( const QString& pKey, const QValueList<int> &list,
01395                                bool bPersistent, bool bGlobal, bool bNLS )
01396 {
01397   writeEntry(pKey.utf8().data(), list, bPersistent, bGlobal, bNLS);
01398 }
01399 
01400 void KConfigBase::writeEntry ( const char *pKey, const QValueList<int> &list,
01401                                bool bPersistent, bool bGlobal, bool bNLS )
01402 {
01403     QStringList strlist;
01404     QValueList<int>::ConstIterator end = list.end();
01405     for (QValueList<int>::ConstIterator it = list.begin(); it != end; it++)
01406         strlist << QString::number(*it);
01407     writeEntry(pKey, strlist, ',', bPersistent, bGlobal, bNLS );
01408 }
01409 
01410 void KConfigBase::writeEntry( const QString& pKey, int nValue,
01411                                  bool bPersistent, bool bGlobal,
01412                                  bool bNLS )
01413 {
01414   writeEntry( pKey, QString::number(nValue), bPersistent, bGlobal, bNLS );
01415 }
01416 
01417 void KConfigBase::writeEntry( const char *pKey, int nValue,
01418                                  bool bPersistent, bool bGlobal,
01419                                  bool bNLS )
01420 {
01421   writeEntry( pKey, QString::number(nValue), bPersistent, bGlobal, bNLS );
01422 }
01423 
01424 
01425 void KConfigBase::writeEntry( const QString& pKey, unsigned int nValue,
01426                                  bool bPersistent, bool bGlobal,
01427                                  bool bNLS )
01428 {
01429   writeEntry( pKey, QString::number(nValue), bPersistent, bGlobal, bNLS );
01430 }
01431 
01432 void KConfigBase::writeEntry( const char *pKey, unsigned int nValue,
01433                                  bool bPersistent, bool bGlobal,
01434                                  bool bNLS )
01435 {
01436   writeEntry( pKey, QString::number(nValue), bPersistent, bGlobal, bNLS );
01437 }
01438 
01439 
01440 void KConfigBase::writeEntry( const QString& pKey, long nValue,
01441                                  bool bPersistent, bool bGlobal,
01442                                  bool bNLS )
01443 {
01444   writeEntry( pKey, QString::number(nValue), bPersistent, bGlobal, bNLS );
01445 }
01446 
01447 void KConfigBase::writeEntry( const char *pKey, long nValue,
01448                                  bool bPersistent, bool bGlobal,
01449                                  bool bNLS )
01450 {
01451   writeEntry( pKey, QString::number(nValue), bPersistent, bGlobal, bNLS );
01452 }
01453 
01454 
01455 void KConfigBase::writeEntry( const QString& pKey, unsigned long nValue,
01456                                  bool bPersistent, bool bGlobal,
01457                                  bool bNLS )
01458 {
01459   writeEntry( pKey, QString::number(nValue), bPersistent, bGlobal, bNLS );
01460 }
01461 
01462 void KConfigBase::writeEntry( const char *pKey, unsigned long nValue,
01463                                  bool bPersistent, bool bGlobal,
01464                                  bool bNLS )
01465 {
01466   writeEntry( pKey, QString::number(nValue), bPersistent, bGlobal, bNLS );
01467 }
01468 
01469 
01470 void KConfigBase::writeEntry( const QString& pKey, double nValue,
01471                                  bool bPersistent, bool bGlobal,
01472                                  char format, int precision,
01473                                  bool bNLS )
01474 {
01475   writeEntry( pKey, QString::number(nValue, format, precision),
01476                      bPersistent, bGlobal, bNLS );
01477 }
01478 
01479 void KConfigBase::writeEntry( const char *pKey, double nValue,
01480                                  bool bPersistent, bool bGlobal,
01481                                  char format, int precision,
01482                                  bool bNLS )
01483 {
01484   writeEntry( pKey, QString::number(nValue, format, precision),
01485                      bPersistent, bGlobal, bNLS );
01486 }
01487 
01488 
01489 void KConfigBase::writeEntry( const QString& pKey, bool bValue,
01490                                  bool bPersistent,
01491                                  bool bGlobal,
01492                                  bool bNLS )
01493 {
01494   writeEntry(pKey.utf8().data(), bValue, bPersistent, bGlobal, bNLS);
01495 }
01496 
01497 void KConfigBase::writeEntry( const char *pKey, bool bValue,
01498                                  bool bPersistent,
01499                                  bool bGlobal,
01500                                  bool bNLS )
01501 {
01502   QString aValue;
01503 
01504   if( bValue )
01505     aValue = "true";
01506   else
01507     aValue = "false";
01508 
01509   writeEntry( pKey, aValue, bPersistent, bGlobal, bNLS );
01510 }
01511 
01512 
01513 void KConfigBase::writeEntry( const QString& pKey, const QFont& rFont,
01514                                  bool bPersistent, bool bGlobal,
01515                                  bool bNLS )
01516 {
01517   writeEntry(pKey.utf8().data(), rFont, bPersistent, bGlobal, bNLS);
01518 }
01519 
01520 void KConfigBase::writeEntry( const char *pKey, const QFont& rFont,
01521                                  bool bPersistent, bool bGlobal,
01522                                  bool bNLS )
01523 {
01524   writeEntry( pKey, rFont.toString(), bPersistent, bGlobal, bNLS );
01525 }
01526 
01527 
01528 void KConfigBase::writeEntry( const QString& pKey, const QRect& rRect,
01529                               bool bPersistent, bool bGlobal,
01530                               bool bNLS )
01531 {
01532   writeEntry(pKey.utf8().data(), rRect, bPersistent, bGlobal, bNLS);
01533 }
01534 
01535 void KConfigBase::writeEntry( const char *pKey, const QRect& rRect,
01536                               bool bPersistent, bool bGlobal,
01537                               bool bNLS )
01538 {
01539   QStrList list;
01540   QCString tempstr;
01541   list.insert( 0, tempstr.setNum( rRect.left() ) );
01542   list.insert( 1, tempstr.setNum( rRect.top() ) );
01543   list.insert( 2, tempstr.setNum( rRect.width() ) );
01544   list.insert( 3, tempstr.setNum( rRect.height() ) );
01545 
01546   writeEntry( pKey, list, ',', bPersistent, bGlobal, bNLS );
01547 }
01548 
01549 
01550 void KConfigBase::writeEntry( const QString& pKey, const QPoint& rPoint,
01551                               bool bPersistent, bool bGlobal,
01552                               bool bNLS )
01553 {
01554   writeEntry(pKey.utf8().data(), rPoint, bPersistent, bGlobal, bNLS);
01555 }
01556 
01557 void KConfigBase::writeEntry( const char *pKey, const QPoint& rPoint,
01558                               bool bPersistent, bool bGlobal,
01559                               bool bNLS )
01560 {
01561   QStrList list;
01562   QCString tempstr;
01563   list.insert( 0, tempstr.setNum( rPoint.x() ) );
01564   list.insert( 1, tempstr.setNum( rPoint.y() ) );
01565 
01566   writeEntry( pKey, list, ',', bPersistent, bGlobal, bNLS );
01567 }
01568 
01569 
01570 void KConfigBase::writeEntry( const QString& pKey, const QSize& rSize,
01571                               bool bPersistent, bool bGlobal,
01572                               bool bNLS )
01573 {
01574   writeEntry(pKey.utf8().data(), rSize, bPersistent, bGlobal, bNLS);
01575 }
01576 
01577 void KConfigBase::writeEntry( const char *pKey, const QSize& rSize,
01578                               bool bPersistent, bool bGlobal,
01579                               bool bNLS )
01580 {
01581   QStrList list;
01582   QCString tempstr;
01583   list.insert( 0, tempstr.setNum( rSize.width() ) );
01584   list.insert( 1, tempstr.setNum( rSize.height() ) );
01585 
01586   writeEntry( pKey, list, ',', bPersistent, bGlobal, bNLS );
01587 }
01588 
01589 void KConfigBase::writeEntry( const QString& pKey, const QColor& rColor,
01590                               bool bPersistent,
01591                               bool bGlobal,
01592                               bool bNLS  )
01593 {
01594   writeEntry( pKey.utf8().data(), rColor, bPersistent, bGlobal, bNLS);
01595 }
01596 
01597 void KConfigBase::writeEntry( const char *pKey, const QColor& rColor,
01598                               bool bPersistent,
01599                               bool bGlobal,
01600                               bool bNLS  )
01601 {
01602   QString aValue;
01603   if (rColor.isValid())
01604       aValue.sprintf( "%d,%d,%d", rColor.red(), rColor.green(), rColor.blue() );
01605   else
01606       aValue = "invalid";
01607 
01608   writeEntry( pKey, aValue, bPersistent, bGlobal, bNLS );
01609 }
01610 
01611 void KConfigBase::writeEntry( const QString& pKey, const QDateTime& rDateTime,
01612                               bool bPersistent, bool bGlobal,
01613                               bool bNLS )
01614 {
01615   writeEntry(pKey.utf8().data(), rDateTime, bPersistent, bGlobal, bNLS);
01616 }
01617 
01618 void KConfigBase::writeEntry( const char *pKey, const QDateTime& rDateTime,
01619                               bool bPersistent, bool bGlobal,
01620                               bool bNLS )
01621 {
01622   QStrList list;
01623   QCString tempstr;
01624 
01625   QTime time = rDateTime.time();
01626   QDate date = rDateTime.date();
01627 
01628   list.insert( 0, tempstr.setNum( date.year() ) );
01629   list.insert( 1, tempstr.setNum( date.month() ) );
01630   list.insert( 2, tempstr.setNum( date.day() ) );
01631 
01632   list.insert( 3, tempstr.setNum( time.hour() ) );
01633   list.insert( 4, tempstr.setNum( time.minute() ) );
01634   list.insert( 5, tempstr.setNum( time.second() ) );
01635 
01636   writeEntry( pKey, list, ',', bPersistent, bGlobal, bNLS );
01637 }
01638 
01639 void KConfigBase::parseConfigFiles()
01640 {
01641   if (!bLocaleInitialized && KGlobal::_locale) {
01642     setLocale();
01643   }
01644   if (backEnd)
01645   {
01646      backEnd->parseConfigFiles();
01647      bReadOnly = (backEnd->getConfigState() == ReadOnly);
01648   }
01649 }
01650 
01651 void KConfigBase::sync()
01652 {
01653   if (isReadOnly())
01654     return;
01655 
01656   if (backEnd)
01657      backEnd->sync();
01658   if (bDirty)
01659     rollback();
01660 }
01661 
01662 KConfigBase::ConfigState KConfigBase::getConfigState() const {
01663     if (backEnd)
01664        return backEnd->getConfigState();
01665     return ReadOnly;
01666 }
01667 
01668 void KConfigBase::rollback( bool /*bDeep = true*/ )
01669 {
01670   bDirty = false;
01671 }
01672 
01673 KConfigGroup::KConfigGroup(KConfigBase *master, const QString &group)
01674 {
01675   mMaster = master;
01676   backEnd = mMaster->backEnd; // Needed for getConfigState()
01677   bLocaleInitialized = true;
01678   bReadOnly = mMaster->bReadOnly;
01679   bExpand = false;
01680   bDirty = false; // Not used
01681   mGroup = group.utf8();
01682   aLocaleString = mMaster->aLocaleString;
01683 }
01684 
01685 KConfigGroup::KConfigGroup(KConfigBase *master, const QCString &group)
01686 {
01687   mMaster = master;
01688   backEnd = mMaster->backEnd; // Needed for getConfigState()
01689   bLocaleInitialized = true;
01690   bReadOnly = mMaster->bReadOnly;
01691   bExpand = false;
01692   bDirty = false; // Not used
01693   mGroup = group;
01694   aLocaleString = mMaster->aLocaleString;
01695 }
01696 
01697 KConfigGroup::KConfigGroup(KConfigBase *master, const char * group)
01698 {
01699   mMaster = master;
01700   backEnd = mMaster->backEnd; // Needed for getConfigState()
01701   bLocaleInitialized = true;
01702   bReadOnly = mMaster->bReadOnly;
01703   bExpand = false;
01704   bDirty = false; // Not used
01705   mGroup = group;
01706   aLocaleString = mMaster->aLocaleString;
01707 }
01708 
01709 void KConfigGroup::deleteGroup(bool bGlobal)
01710 {
01711   mMaster->deleteGroup(KConfigBase::group(), false, bGlobal);
01712 }
01713 
01714 void KConfigGroup::setDirty(bool b)
01715 {
01716   mMaster->setDirty(b);
01717 }
01718 
01719 void KConfigGroup::putData(const KEntryKey &_key, const KEntry &_data, bool _checkGroup)
01720 {
01721   mMaster->putData(_key, _data, _checkGroup);
01722 }
01723 
01724 KEntry KConfigGroup::lookupData(const KEntryKey &_key) const
01725 {
01726   return mMaster->lookupData(_key);
01727 }
01728 
01729 void KConfigGroup::sync()
01730 {
01731   mMaster->sync();
01732 }
01733 
01734 void KConfigBase::virtual_hook( int, void* )
01735 { /*BASE::virtual_hook( id, data );*/ }
01736 
01737 void KConfigGroup::virtual_hook( int id, void* data )
01738 { KConfigBase::virtual_hook( id, data ); }
01739 
01740 #include "kconfigbase.moc"
01741 
KDE Logo
This file is part of the documentation for kdelibs Version 3.1.4.
Documentation copyright © 1996-2002 the KDE developers.
Generated on Sun Feb 27 22:14:46 2005 by doxygen 1.3.4 written by Dimitri van Heesch, © 1997-2001