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 #include "kstringhandler.h"
00040 
00041 class KConfigBase::KConfigBasePrivate
00042 {
00043 public:
00044      KConfigBasePrivate() : readDefaults(false) { };
00045 
00046 public:
00047      bool readDefaults;
00048 };
00049 
00050 KConfigBase::KConfigBase()
00051   : backEnd(0L), bDirty(false), bLocaleInitialized(false),
00052     bReadOnly(false), bExpand(false), d(0)
00053 {
00054     setGroup(QString::null);
00055 }
00056 
00057 KConfigBase::~KConfigBase()
00058 {
00059     delete d;
00060 }
00061 
00062 void KConfigBase::setLocale()
00063 {
00064   bLocaleInitialized = true;
00065 
00066   if (KGlobal::locale())
00067     aLocaleString = KGlobal::locale()->language().utf8();
00068   else
00069     aLocaleString = KLocale::defaultLanguage().utf8();
00070   if (backEnd)
00071      backEnd->setLocaleString(aLocaleString);
00072 }
00073 
00074 QString KConfigBase::locale() const
00075 {
00076   return QString::fromUtf8(aLocaleString);
00077 }
00078 
00079 void KConfigBase::setGroup( const QString& group )
00080 {
00081   if ( group.isEmpty() )
00082     mGroup = "<default>";
00083   else
00084     mGroup = group.utf8();
00085 }
00086 
00087 void KConfigBase::setGroup( const char *pGroup )
00088 {
00089   setGroup(QCString(pGroup));
00090 }
00091 
00092 void KConfigBase::setGroup( const QCString &group )
00093 {
00094   if ( group.isEmpty() )
00095     mGroup = "<default>";
00096   else
00097     mGroup = group;
00098 }
00099 
00100 QString KConfigBase::group() const {
00101   return QString::fromUtf8(mGroup);
00102 }
00103 
00104 void KConfigBase::setDesktopGroup()
00105 {
00106   mGroup = "Desktop Entry";
00107 }
00108 
00109 bool KConfigBase::hasKey(const QString &key) const
00110 {
00111    return hasKey(key.utf8().data());
00112 }
00113 
00114 bool KConfigBase::hasKey(const char *pKey) const
00115 {
00116   KEntryKey aEntryKey(mGroup, 0);
00117   aEntryKey.c_key = pKey;
00118   aEntryKey.bDefault = readDefaults();
00119 
00120   if (!locale().isNull()) {
00121     // try the localized key first
00122     aEntryKey.bLocal = true;
00123     KEntry entry = lookupData(aEntryKey);
00124     if (!entry.mValue.isNull())
00125        return true;
00126     aEntryKey.bLocal = false;
00127   }
00128 
00129   // try the non-localized version
00130   KEntry entry = lookupData(aEntryKey);
00131   return !entry.mValue.isNull();
00132 }
00133 
00134 bool KConfigBase::hasGroup(const QString &group) const
00135 {
00136   return internalHasGroup( group.utf8());
00137 }
00138 
00139 bool KConfigBase::hasGroup(const char *_pGroup) const
00140 {
00141   return internalHasGroup( QCString(_pGroup));
00142 }
00143 
00144 bool KConfigBase::hasGroup(const QCString &_pGroup) const
00145 {
00146   return internalHasGroup( _pGroup);
00147 }
00148 
00149 bool KConfigBase::isImmutable() const
00150 {
00151   return (getConfigState() != ReadWrite);
00152 }
00153 
00154 bool KConfigBase::groupIsImmutable(const QString &group) const
00155 {
00156   if (getConfigState() != ReadWrite)
00157      return true;
00158 
00159   KEntryKey groupKey(group.utf8(), 0);
00160   KEntry entry = lookupData(groupKey);
00161   return entry.bImmutable;
00162 }
00163 
00164 bool KConfigBase::entryIsImmutable(const QString &key) const
00165 {
00166   if (getConfigState() != ReadWrite)
00167      return true;
00168 
00169   KEntryKey entryKey(mGroup, 0);
00170   KEntry aEntryData = lookupData(entryKey); // Group
00171   if (aEntryData.bImmutable)
00172     return true;
00173 
00174   QCString utf8_key = key.utf8();
00175   entryKey.c_key = utf8_key.data();
00176   aEntryData = lookupData(entryKey); // Normal entry
00177   if (aEntryData.bImmutable)
00178     return true;
00179 
00180   entryKey.bLocal = true;
00181   aEntryData = lookupData(entryKey); // Localized entry
00182   return aEntryData.bImmutable;
00183 }
00184 
00185 
00186 QString KConfigBase::readEntryUntranslated( const QString& pKey,
00187                                 const QString& aDefault ) const
00188 {
00189    return KConfigBase::readEntryUntranslated(pKey.utf8().data(), aDefault);
00190 }
00191 
00192 
00193 QString KConfigBase::readEntryUntranslated( const char *pKey,
00194                                 const QString& aDefault ) const
00195 {
00196    QCString result = readEntryUtf8(pKey);
00197    if (result.isNull())
00198       return aDefault;
00199    return QString::fromUtf8(result);
00200 }
00201 
00202 
00203 QString KConfigBase::readEntry( const QString& pKey,
00204                                 const QString& aDefault ) const
00205 {
00206    return KConfigBase::readEntry(pKey.utf8().data(), aDefault);
00207 }
00208 
00209 QString KConfigBase::readEntry( const char *pKey,
00210                                 const QString& aDefault ) const
00211 {
00212   // we need to access _locale instead of the method locale()
00213   // because calling locale() will create a locale object if it
00214   // doesn't exist, which requires KConfig, which will create a infinite
00215   // loop, and nobody likes those.
00216   if (!bLocaleInitialized && KGlobal::_locale) {
00217     // get around const'ness.
00218     KConfigBase *that = const_cast<KConfigBase *>(this);
00219     that->setLocale();
00220   }
00221 
00222   QString aValue;
00223 
00224   bool expand = false;
00225   // construct a localized version of the key
00226   // try the localized key first
00227   KEntry aEntryData;
00228   KEntryKey entryKey(mGroup, 0);
00229   entryKey.c_key = pKey;
00230   entryKey.bDefault = readDefaults();
00231   entryKey.bLocal = true;
00232   aEntryData = lookupData(entryKey);
00233   if (!aEntryData.mValue.isNull()) {
00234     // for GNOME .desktop
00235     aValue = KStringHandler::from8Bit( aEntryData.mValue.data() );
00236     expand = aEntryData.bExpand;
00237   } else {
00238     entryKey.bLocal = false;
00239     aEntryData = lookupData(entryKey);
00240     if (!aEntryData.mValue.isNull()) {
00241       aValue = QString::fromUtf8(aEntryData.mValue.data());
00242       if (aValue.isNull())
00243       {
00244         static const QString &emptyString = KGlobal::staticQString("");
00245         aValue = emptyString;
00246       }
00247       expand = aEntryData.bExpand;
00248     } else {
00249       aValue = aDefault;
00250     }
00251   }
00252 
00253   // only do dollar expansion if so desired
00254   if( expand || bExpand )
00255     {
00256       // check for environment variables and make necessary translations
00257       int nDollarPos = aValue.find( '$' );
00258 
00259       while( nDollarPos != -1 && nDollarPos+1 < static_cast<int>(aValue.length())) {
00260         // there is at least one $
00261         if( (aValue)[nDollarPos+1] == '(' ) {
00262           uint nEndPos = nDollarPos+1;
00263           // the next character is no $
00264           while ( (nEndPos <= aValue.length()) && (aValue[nEndPos]!=')') )
00265               nEndPos++;
00266           nEndPos++;
00267           QString cmd = aValue.mid( nDollarPos+2, nEndPos-nDollarPos-3 );
00268 
00269           QString result;
00270           FILE *fs = popen(QFile::encodeName(cmd).data(), "r");
00271           if (fs)
00272           {
00273              QTextStream ts(fs, IO_ReadOnly);
00274              result = ts.read().stripWhiteSpace();
00275              pclose(fs);
00276           }
00277           aValue.replace( nDollarPos, nEndPos-nDollarPos, result );
00278         } else if( (aValue)[nDollarPos+1] != '$' ) {
00279           uint nEndPos = nDollarPos+1;
00280           // the next character is no $
00281           QString aVarName;
00282           if (aValue[nEndPos]=='{')
00283           {
00284             while ( (nEndPos <= aValue.length()) && (aValue[nEndPos]!='}') )
00285                 nEndPos++;
00286             nEndPos++;
00287             aVarName = aValue.mid( nDollarPos+2, nEndPos-nDollarPos-3 );
00288           }
00289           else
00290           {
00291             while ( nEndPos <= aValue.length() && (aValue[nEndPos].isNumber()
00292                     || aValue[nEndPos].isLetter() || aValue[nEndPos]=='_' )  )
00293                 nEndPos++;
00294             aVarName = aValue.mid( nDollarPos+1, nEndPos-nDollarPos-1 );
00295           }
00296           const char* pEnv = 0;
00297           if (!aVarName.isEmpty())
00298                pEnv = getenv( aVarName.ascii() );
00299           if( pEnv ) {
00300         // !!! Sergey A. Sukiyazov <corwin@micom.don.ru> !!!
00301         // A environment variables may contain values in 8bit
00302         // locale cpecified encoding or in UTF8 encoding.
00303         aValue.replace( nDollarPos, nEndPos-nDollarPos, KStringHandler::from8Bit( pEnv ) );
00304           } else
00305             aValue.remove( nDollarPos, nEndPos-nDollarPos );
00306         } else {
00307           // remove one of the dollar signs
00308           aValue.remove( nDollarPos, 1 );
00309           nDollarPos++;
00310         }
00311         nDollarPos = aValue.find( '$', nDollarPos );
00312       }
00313     }
00314 
00315   return aValue;
00316 }
00317 
00318 QCString KConfigBase::readEntryUtf8( const char *pKey) const
00319 {
00320   // We don't try the localized key
00321   KEntryKey entryKey(mGroup, 0);
00322   entryKey.bDefault = readDefaults();
00323   entryKey.c_key = pKey;
00324   KEntry aEntryData = lookupData(entryKey);
00325   if (aEntryData.bExpand)
00326   {
00327      // We need to do fancy, take the slow route.
00328      return readEntry(pKey, QString::null).utf8();
00329   }
00330   return aEntryData.mValue;
00331 }
00332 
00333 QVariant KConfigBase::readPropertyEntry( const QString& pKey,
00334                                           QVariant::Type type ) const
00335 {
00336   return readPropertyEntry(pKey.utf8().data(), type);
00337 }
00338 
00339 QVariant KConfigBase::readPropertyEntry( const char *pKey,
00340                                           QVariant::Type type ) const
00341 {
00342   QVariant va;
00343   if ( !hasKey( pKey ) ) return va;
00344   (void)va.cast(type);
00345   return readPropertyEntry(pKey, va);
00346 }
00347 
00348 QVariant KConfigBase::readPropertyEntry( const QString& pKey,
00349                                          const QVariant &aDefault ) const
00350 {
00351   return readPropertyEntry(pKey.utf8().data(), aDefault);
00352 }
00353 
00354 QVariant KConfigBase::readPropertyEntry( const char *pKey,
00355                                          const QVariant &aDefault ) const
00356 {
00357   if ( !hasKey( pKey ) ) return aDefault;
00358 
00359   QVariant tmp = aDefault;
00360 
00361   switch( aDefault.type() )
00362   {
00363       case QVariant::Invalid:
00364           return QVariant();
00365       case QVariant::String:
00366           return QVariant( readEntry( pKey, aDefault.toString() ) );
00367       case QVariant::StringList:
00368           return QVariant( readListEntry( pKey ) );
00369       case QVariant::List: {
00370           QStringList strList = readListEntry( pKey );
00371           QStringList::ConstIterator it = strList.begin();
00372           QStringList::ConstIterator end = strList.end();
00373           QValueList<QVariant> list;
00374 
00375           for (; it != end; ++it ) {
00376               tmp = *it;
00377               list.append( tmp );
00378           }
00379           return QVariant( list );
00380       }
00381       case QVariant::Font:
00382           return QVariant( readFontEntry( pKey, &tmp.asFont() ) );
00383       case QVariant::Point:
00384           return QVariant( readPointEntry( pKey, &tmp.asPoint() ) );
00385       case QVariant::Rect:
00386           return QVariant( readRectEntry( pKey, &tmp.asRect() ) );
00387       case QVariant::Size:
00388           return QVariant( readSizeEntry( pKey, &tmp.asSize() ) );
00389       case QVariant::Color:
00390           return QVariant( readColorEntry( pKey, &tmp.asColor() ) );
00391       case QVariant::Int:
00392           return QVariant( readNumEntry( pKey, aDefault.toInt() ) );
00393       case QVariant::UInt:
00394           return QVariant( readUnsignedNumEntry( pKey, aDefault.toUInt() ) );
00395       case QVariant::LongLong:
00396           return QVariant( readNum64Entry( pKey, aDefault.toLongLong() ) );
00397       case QVariant::ULongLong:
00398           return QVariant( readUnsignedNum64Entry( pKey, aDefault.toULongLong() ) );
00399       case QVariant::Bool:
00400           return QVariant( readBoolEntry( pKey, aDefault.toBool() ), 0 );
00401       case QVariant::Double:
00402           return QVariant( readDoubleNumEntry( pKey, aDefault.toDouble() ) );
00403       case QVariant::DateTime:
00404           return QVariant( readDateTimeEntry( pKey, &tmp.asDateTime() ) );
00405       case QVariant::Date:
00406           return QVariant(readDateTimeEntry( pKey, &tmp.asDateTime() ).date());
00407 
00408       case QVariant::Pixmap:
00409       case QVariant::Image:
00410       case QVariant::Brush:
00411       case QVariant::Palette:
00412       case QVariant::ColorGroup:
00413       case QVariant::Map:
00414       case QVariant::IconSet:
00415       case QVariant::CString:
00416       case QVariant::PointArray:
00417       case QVariant::Region:
00418       case QVariant::Bitmap:
00419       case QVariant::Cursor:
00420       case QVariant::SizePolicy:
00421       case QVariant::Time:
00422       case QVariant::ByteArray:
00423       case QVariant::BitArray:
00424       case QVariant::KeySequence:
00425       case QVariant::Pen:
00426           break;
00427   }
00428 
00429   Q_ASSERT( 0 );
00430   return QVariant();
00431 }
00432 
00433 int KConfigBase::readListEntry( const QString& pKey,
00434                                 QStrList &list, char sep ) const
00435 {
00436   return readListEntry(pKey.utf8().data(), list, sep);
00437 }
00438 
00439 int KConfigBase::readListEntry( const char *pKey,
00440                                 QStrList &list, char sep ) const
00441 {
00442   if( !hasKey( pKey ) )
00443     return 0;
00444 
00445   QCString str_list = readEntryUtf8( pKey );
00446   if (str_list.isEmpty())
00447     return 0;
00448 
00449   list.clear();
00450   QCString value = "";
00451   int len = str_list.length();
00452 
00453   for (int i = 0; i < len; i++) {
00454     if (str_list[i] != sep && str_list[i] != '\\') {
00455       value += str_list[i];
00456       continue;
00457     }
00458     if (str_list[i] == '\\') {
00459       i++;
00460       if ( i < len )
00461         value += str_list[i];
00462       continue;
00463     }
00464     // if we fell through to here, we are at a separator.  Append
00465     // contents of value to the list
00466     // !!! Sergey A. Sukiyazov <corwin@micom.don.ru> !!!
00467     // A QStrList may contain values in 8bit locale cpecified
00468     // encoding
00469     list.append( value );
00470     value.truncate(0);
00471   }
00472 
00473   if ( str_list[len-1] != sep || ( len > 1 && str_list[len-2] == '\\' ) )
00474     list.append( value );
00475   return list.count();
00476 }
00477 
00478 QStringList KConfigBase::readListEntry( const QString& pKey, char sep ) const
00479 {
00480   return readListEntry(pKey.utf8().data(), sep);
00481 }
00482 
00483 QStringList KConfigBase::readListEntry( const char *pKey, char sep ) const
00484 {
00485   static const QString& emptyString = KGlobal::staticQString("");
00486 
00487   QStringList list;
00488   if( !hasKey( pKey ) )
00489     return list;
00490   QString str_list = readEntry( pKey );
00491   if( str_list.isEmpty() )
00492     return list;
00493   QString value(emptyString);
00494   int len = str_list.length();
00495  // obviously too big, but faster than letting each += resize the string.
00496   value.reserve( len );
00497   for( int i = 0; i < len; i++ )
00498     {
00499       if( str_list[i] != sep && str_list[i] != '\\' )
00500         {
00501           value += str_list[i];
00502           continue;
00503         }
00504       if( str_list[i] == '\\' )
00505         {
00506           i++;
00507           if ( i < len )
00508             value += str_list[i];
00509           continue;
00510         }
00511       QString finalvalue( value );
00512       finalvalue.squeeze();
00513       list.append( finalvalue );
00514       value.truncate( 0 );
00515     }
00516   if ( str_list[len-1] != sep || ( len > 1 && str_list[len-2] == '\\' ) )
00517   {
00518     value.squeeze();
00519     list.append( value );
00520   }
00521   return list;
00522 }
00523 
00524 QValueList<int> KConfigBase::readIntListEntry( const QString& pKey ) const
00525 {
00526   return readIntListEntry(pKey.utf8().data());
00527 }
00528 
00529 QValueList<int> KConfigBase::readIntListEntry( const char *pKey ) const
00530 {
00531   QStringList strlist = readListEntry(pKey);
00532   QValueList<int> list;
00533   for (QStringList::ConstIterator it = strlist.begin(); it != strlist.end(); it++)
00534     // I do not check if the toInt failed because I consider the number of items
00535     // more important than their value
00536     list << (*it).toInt();
00537 
00538   return list;
00539 }
00540 
00541 QString KConfigBase::readPathEntry( const QString& pKey, const QString& pDefault ) const
00542 {
00543   return readPathEntry(pKey.utf8().data(), pDefault);
00544 }
00545 
00546 QString KConfigBase::readPathEntry( const char *pKey, const QString& pDefault ) const
00547 {
00548   const bool bExpandSave = bExpand;
00549   bExpand = true;
00550   QString aValue = readEntry( pKey, pDefault );
00551   bExpand = bExpandSave;
00552   return aValue;
00553 }
00554 
00555 QStringList KConfigBase::readPathListEntry( const QString& pKey, char sep ) const
00556 {
00557   return readPathListEntry(pKey.utf8().data(), sep);
00558 }
00559 
00560 QStringList KConfigBase::readPathListEntry( const char *pKey, char sep ) const
00561 {
00562   const bool bExpandSave = bExpand;
00563   bExpand = true;
00564   QStringList aValue = readListEntry( pKey, sep );
00565   bExpand = bExpandSave;
00566   return aValue;
00567 }
00568 
00569 int KConfigBase::readNumEntry( const QString& pKey, int nDefault) const
00570 {
00571   return readNumEntry(pKey.utf8().data(), nDefault);
00572 }
00573 
00574 int KConfigBase::readNumEntry( const char *pKey, int nDefault) const
00575 {
00576   QCString aValue = readEntryUtf8( pKey );
00577   if( aValue.isNull() )
00578     return nDefault;
00579   else if( aValue == "true" || aValue == "on" || aValue == "yes" )
00580     return 1;
00581   else
00582     {
00583       bool ok;
00584       int rc = aValue.toInt( &ok );
00585       return( ok ? rc : nDefault );
00586     }
00587 }
00588 
00589 
00590 unsigned int KConfigBase::readUnsignedNumEntry( const QString& pKey, unsigned int nDefault) const
00591 {
00592   return readUnsignedNumEntry(pKey.utf8().data(), nDefault);
00593 }
00594 
00595 unsigned int KConfigBase::readUnsignedNumEntry( const char *pKey, unsigned int nDefault) const
00596 {
00597   QCString aValue = readEntryUtf8( pKey );
00598   if( aValue.isNull() )
00599     return nDefault;
00600   else
00601     {
00602       bool ok;
00603       unsigned int rc = aValue.toUInt( &ok );
00604       return( ok ? rc : nDefault );
00605     }
00606 }
00607 
00608 
00609 long KConfigBase::readLongNumEntry( const QString& pKey, long nDefault) const
00610 {
00611   return readLongNumEntry(pKey.utf8().data(), nDefault);
00612 }
00613 
00614 long KConfigBase::readLongNumEntry( const char *pKey, long nDefault) const
00615 {
00616   QCString aValue = readEntryUtf8( pKey );
00617   if( aValue.isNull() )
00618     return nDefault;
00619   else
00620     {
00621       bool ok;
00622       long rc = aValue.toLong( &ok );
00623       return( ok ? rc : nDefault );
00624     }
00625 }
00626 
00627 
00628 unsigned long KConfigBase::readUnsignedLongNumEntry( const QString& pKey, unsigned long nDefault) const
00629 {
00630   return readUnsignedLongNumEntry(pKey.utf8().data(), nDefault);
00631 }
00632 
00633 unsigned long KConfigBase::readUnsignedLongNumEntry( const char *pKey, unsigned long nDefault) const
00634 {
00635   QCString aValue = readEntryUtf8( pKey );
00636   if( aValue.isNull() )
00637     return nDefault;
00638   else
00639     {
00640       bool ok;
00641       unsigned long rc = aValue.toULong( &ok );
00642       return( ok ? rc : nDefault );
00643     }
00644 }
00645 
00646 Q_INT64 KConfigBase::readNum64Entry( const QString& pKey, Q_INT64 nDefault) const
00647 {
00648   return readNum64Entry(pKey.utf8().data(), nDefault);
00649 }
00650 
00651 Q_INT64 KConfigBase::readNum64Entry( const char *pKey, Q_INT64 nDefault) const
00652 {
00653   // Note that QCString::toLongLong() is missing, we muse use a QString instead.
00654   QString aValue = readEntry( pKey );
00655   if( aValue.isNull() )
00656     return nDefault;
00657   else
00658     {
00659       bool ok;
00660       Q_INT64 rc = aValue.toLongLong( &ok );
00661       return( ok ? rc : nDefault );
00662     }
00663 }
00664 
00665 
00666 Q_UINT64 KConfigBase::readUnsignedNum64Entry( const QString& pKey, Q_UINT64 nDefault) const
00667 {
00668   return readUnsignedNum64Entry(pKey.utf8().data(), nDefault);
00669 }
00670 
00671 Q_UINT64 KConfigBase::readUnsignedNum64Entry( const char *pKey, Q_UINT64 nDefault) const
00672 {
00673   // Note that QCString::toULongLong() is missing, we muse use a QString instead.
00674   QString aValue = readEntry( pKey );
00675   if( aValue.isNull() )
00676     return nDefault;
00677   else
00678     {
00679       bool ok;
00680       Q_UINT64 rc = aValue.toULongLong( &ok );
00681       return( ok ? rc : nDefault );
00682     }
00683 }
00684 
00685 double KConfigBase::readDoubleNumEntry( const QString& pKey, double nDefault) const
00686 {
00687   return readDoubleNumEntry(pKey.utf8().data(), nDefault);
00688 }
00689 
00690 double KConfigBase::readDoubleNumEntry( const char *pKey, double nDefault) const
00691 {
00692   QCString aValue = readEntryUtf8( pKey );
00693   if( aValue.isNull() )
00694     return nDefault;
00695   else
00696     {
00697       bool ok;
00698       double rc = aValue.toDouble( &ok );
00699       return( ok ? rc : nDefault );
00700     }
00701 }
00702 
00703 
00704 bool KConfigBase::readBoolEntry( const QString& pKey, const bool bDefault ) const
00705 {
00706    return readBoolEntry(pKey.utf8().data(), bDefault);
00707 }
00708 
00709 bool KConfigBase::readBoolEntry( const char *pKey, const bool bDefault ) const
00710 {
00711   QCString aValue = readEntryUtf8( pKey );
00712 
00713   if( aValue.isNull() )
00714     return bDefault;
00715   else
00716     {
00717       if( aValue == "true" || aValue == "on" || aValue == "yes" || aValue == "1" )
00718         return true;
00719       else
00720         {
00721           bool bOK;
00722           int val = aValue.toInt( &bOK );
00723           if( bOK && val != 0 )
00724             return true;
00725           else
00726             return false;
00727         }
00728     }
00729 }
00730 
00731 QFont KConfigBase::readFontEntry( const QString& pKey, const QFont* pDefault ) const
00732 {
00733   return readFontEntry(pKey.utf8().data(), pDefault);
00734 }
00735 
00736 QFont KConfigBase::readFontEntry( const char *pKey, const QFont* pDefault ) const
00737 {
00738   QFont aRetFont;
00739 
00740   QString aValue = readEntry( pKey );
00741   if( !aValue.isNull() ) {
00742     if ( aValue.contains( ',' ) > 5 ) {
00743       // KDE3 and upwards entry
00744       if ( !aRetFont.fromString( aValue ) && pDefault )
00745         aRetFont = *pDefault;
00746     }
00747     else {
00748       // backward compatibility with older font formats
00749       // ### remove KDE 3.1 ?
00750       // find first part (font family)
00751       int nIndex = aValue.find( ',' );
00752       if( nIndex == -1 ){
00753         if( pDefault )
00754           aRetFont = *pDefault;
00755         return aRetFont;
00756       }
00757       aRetFont.setFamily( aValue.left( nIndex ) );
00758 
00759       // find second part (point size)
00760       int nOldIndex = nIndex;
00761       nIndex = aValue.find( ',', nOldIndex+1 );
00762       if( nIndex == -1 ){
00763         if( pDefault )
00764           aRetFont = *pDefault;
00765         return aRetFont;
00766       }
00767 
00768       aRetFont.setPointSize( aValue.mid( nOldIndex+1,
00769                                          nIndex-nOldIndex-1 ).toInt() );
00770 
00771       // find third part (style hint)
00772       nOldIndex = nIndex;
00773       nIndex = aValue.find( ',', nOldIndex+1 );
00774 
00775       if( nIndex == -1 ){
00776         if( pDefault )
00777           aRetFont = *pDefault;
00778         return aRetFont;
00779       }
00780 
00781       aRetFont.setStyleHint( (QFont::StyleHint)aValue.mid( nOldIndex+1, nIndex-nOldIndex-1 ).toUInt() );
00782 
00783       // find fourth part (char set)
00784       nOldIndex = nIndex;
00785       nIndex = aValue.find( ',', nOldIndex+1 );
00786 
00787       if( nIndex == -1 ){
00788         if( pDefault )
00789           aRetFont = *pDefault;
00790         return aRetFont;
00791       }
00792 
00793       QString chStr=aValue.mid( nOldIndex+1,
00794                                 nIndex-nOldIndex-1 );
00795       // find fifth part (weight)
00796       nOldIndex = nIndex;
00797       nIndex = aValue.find( ',', nOldIndex+1 );
00798 
00799       if( nIndex == -1 ){
00800         if( pDefault )
00801           aRetFont = *pDefault;
00802         return aRetFont;
00803       }
00804 
00805       aRetFont.setWeight( aValue.mid( nOldIndex+1,
00806                                       nIndex-nOldIndex-1 ).toUInt() );
00807 
00808       // find sixth part (font bits)
00809       uint nFontBits = aValue.right( aValue.length()-nIndex-1 ).toUInt();
00810 
00811       aRetFont.setItalic( nFontBits & 0x01 );
00812       aRetFont.setUnderline( nFontBits & 0x02 );
00813       aRetFont.setStrikeOut( nFontBits & 0x04 );
00814       aRetFont.setFixedPitch( nFontBits & 0x08 );
00815       aRetFont.setRawMode( nFontBits & 0x20 );
00816     }
00817   }
00818   else
00819     {
00820       if( pDefault )
00821         aRetFont = *pDefault;
00822     }
00823 
00824   return aRetFont;
00825 }
00826 
00827 
00828 QRect KConfigBase::readRectEntry( const QString& pKey, const QRect* pDefault ) const
00829 {
00830   return readRectEntry(pKey.utf8().data(), pDefault);
00831 }
00832 
00833 QRect KConfigBase::readRectEntry( const char *pKey, const QRect* pDefault ) const
00834 {
00835   QCString aValue = readEntryUtf8(pKey);
00836 
00837   if (!aValue.isEmpty())
00838   {
00839     int left, top, width, height;
00840 
00841     if (sscanf(aValue.data(), "%d,%d,%d,%d", &left, &top, &width, &height) == 4)
00842     {
00843        return QRect(left, top, width, height);
00844     }
00845   }
00846   if (pDefault)
00847     return *pDefault;
00848   return QRect();
00849 }
00850 
00851 
00852 QPoint KConfigBase::readPointEntry( const QString& pKey,
00853                                     const QPoint* pDefault ) const
00854 {
00855   return readPointEntry(pKey.utf8().data(), pDefault);
00856 }
00857 
00858 QPoint KConfigBase::readPointEntry( const char *pKey,
00859                                     const QPoint* pDefault ) const
00860 {
00861   QCString aValue = readEntryUtf8(pKey);
00862 
00863   if (!aValue.isEmpty())
00864   {
00865     int x,y;
00866 
00867     if (sscanf(aValue.data(), "%d,%d", &x, &y) == 2)
00868     {
00869        return QPoint(x,y);
00870     }
00871   }
00872   if (pDefault)
00873     return *pDefault;
00874   return QPoint();
00875 }
00876 
00877 QSize KConfigBase::readSizeEntry( const QString& pKey,
00878                                   const QSize* pDefault ) const
00879 {
00880   return readSizeEntry(pKey.utf8().data(), pDefault);
00881 }
00882 
00883 QSize KConfigBase::readSizeEntry( const char *pKey,
00884                                   const QSize* pDefault ) const
00885 {
00886   QCString aValue = readEntryUtf8(pKey);
00887 
00888   if (!aValue.isEmpty())
00889   {
00890     int width,height;
00891 
00892     if (sscanf(aValue.data(), "%d,%d", &width, &height) == 2)
00893     {
00894        return QSize(width, height);
00895     }
00896   }
00897   if (pDefault)
00898     return *pDefault;
00899   return QSize();
00900 }
00901 
00902 
00903 QColor KConfigBase::readColorEntry( const QString& pKey,
00904                                     const QColor* pDefault ) const
00905 {
00906   return readColorEntry(pKey.utf8().data(), pDefault);
00907 }
00908 
00909 QColor KConfigBase::readColorEntry( const char *pKey,
00910                                     const QColor* pDefault ) const
00911 {
00912   QColor aRetColor;
00913   int nRed = 0, nGreen = 0, nBlue = 0;
00914 
00915   QString aValue = readEntry( pKey );
00916   if( !aValue.isEmpty() )
00917     {
00918       if ( aValue.at(0) == '#' )
00919         {
00920           aRetColor.setNamedColor(aValue);
00921         }
00922       else
00923         {
00924 
00925           bool bOK;
00926 
00927           // find first part (red)
00928           int nIndex = aValue.find( ',' );
00929 
00930           if( nIndex == -1 ){
00931             // return a sensible default -- Bernd
00932             if( pDefault )
00933               aRetColor = *pDefault;
00934             return aRetColor;
00935           }
00936 
00937           nRed = aValue.left( nIndex ).toInt( &bOK );
00938 
00939           // find second part (green)
00940           int nOldIndex = nIndex;
00941           nIndex = aValue.find( ',', nOldIndex+1 );
00942 
00943           if( nIndex == -1 ){
00944             // return a sensible default -- Bernd
00945             if( pDefault )
00946               aRetColor = *pDefault;
00947             return aRetColor;
00948           }
00949           nGreen = aValue.mid( nOldIndex+1,
00950                                nIndex-nOldIndex-1 ).toInt( &bOK );
00951 
00952           // find third part (blue)
00953           nBlue = aValue.right( aValue.length()-nIndex-1 ).toInt( &bOK );
00954 
00955           aRetColor.setRgb( nRed, nGreen, nBlue );
00956         }
00957     }
00958   else {
00959 
00960     if( pDefault )
00961       aRetColor = *pDefault;
00962   }
00963 
00964   return aRetColor;
00965 }
00966 
00967 
00968 QDateTime KConfigBase::readDateTimeEntry( const QString& pKey,
00969                                           const QDateTime* pDefault ) const
00970 {
00971   return readDateTimeEntry(pKey.utf8().data(), pDefault);
00972 }
00973 
00974 // ### currentDateTime() as fallback ? (Harri)
00975 QDateTime KConfigBase::readDateTimeEntry( const char *pKey,
00976                                           const QDateTime* pDefault ) const
00977 {
00978   if( !hasKey( pKey ) )
00979     {
00980       if( pDefault )
00981         return *pDefault;
00982       else
00983         return QDateTime::currentDateTime();
00984     }
00985 
00986   QStrList list;
00987   int count = readListEntry( pKey, list, ',' );
00988   if( count == 6 ) {
00989     QDate date( atoi( list.at( 0 ) ), atoi( list.at( 1 ) ),
00990                 atoi( list.at( 2 ) ) );
00991     QTime time( atoi( list.at( 3 ) ), atoi( list.at( 4 ) ),
00992                 atoi( list.at( 5 ) ) );
00993 
00994     return QDateTime( date, time );
00995   }
00996 
00997   return QDateTime::currentDateTime();
00998 }
00999 
01000 void KConfigBase::writeEntry( const QString& pKey, const QString& value,
01001                                  bool bPersistent,
01002                                  bool bGlobal,
01003                                  bool bNLS )
01004 {
01005    writeEntry(pKey.utf8().data(), value, bPersistent,  bGlobal, bNLS);
01006 }
01007 
01008 void KConfigBase::writeEntry( const char *pKey, const QString& value,
01009                                  bool bPersistent,
01010                                  bool bGlobal,
01011                                  bool bNLS )
01012 {
01013   // the KConfig object is dirty now
01014   // set this before any IO takes place so that if any derivative
01015   // classes do caching, they won't try and flush the cache out
01016   // from under us before we read. A race condition is still
01017   // possible but minimized.
01018   if( bPersistent )
01019     setDirty(true);
01020 
01021   if (!bLocaleInitialized && KGlobal::locale())
01022     setLocale();
01023 
01024   KEntryKey entryKey(mGroup, pKey);
01025   entryKey.bLocal = bNLS;
01026 
01027   KEntry aEntryData;
01028   aEntryData.mValue = value.utf8();  // set new value
01029   aEntryData.bGlobal = bGlobal;
01030   aEntryData.bNLS = bNLS;
01031 
01032   if (bPersistent)
01033     aEntryData.bDirty = true;
01034 
01035   // rewrite the new value
01036   putData(entryKey, aEntryData, true);
01037 }
01038 
01039 void KConfigBase::writePathEntry( const QString& pKey, const QString & path,
01040                                   bool bPersistent, bool bGlobal,
01041                                   bool bNLS)
01042 {
01043    writePathEntry(pKey.utf8().data(), path, bPersistent, bGlobal, bNLS);
01044 }
01045 
01046 
01047 static bool cleanHomeDirPath( QString &path, const QString &homeDir )
01048 {
01049    if (!path.startsWith(homeDir))
01050         return false;
01051 
01052    unsigned int len = homeDir.length();
01053    // replace by "$HOME" if possible
01054    if (path.length() == len || path[len] == '/') {
01055         path = path.replace(0, len, QString::fromLatin1("$HOME"));
01056         return true;
01057    } else 
01058         return false;
01059 }
01060 
01061 static QString translatePath( QString path )
01062 {
01063    if (path.isEmpty())
01064        return path;
01065 
01066    bool startsWithFile = path.startsWith("file:", false);
01067 
01068    // return original path, if it refers to another type of URL (e.g. http:/), or
01069    // if the path is already relative to another directory
01070    if (!startsWithFile && path[0] != '/' ||
01071         startsWithFile && path[5] != '/')
01072     return path;
01073 
01074    if (startsWithFile)
01075         path.remove(0,5); // strip leading "file:/" off the string
01076 
01077    // we can not use KGlobal::dirs()->relativeLocation("home", path) here,
01078    // since it would not recognize paths without a trailing '/'.
01079    // All of the 3 following functions to return the user's home directory
01080    // can return different paths. We have to test all them.
01081    QString homeDir0 = QFile::decodeName(getenv("HOME"));
01082    QString homeDir1 = QDir::homeDirPath();
01083    QString homeDir2 = QDir(homeDir1).canonicalPath();
01084    if (cleanHomeDirPath(path, homeDir0) || 
01085        cleanHomeDirPath(path, homeDir1) ||
01086        cleanHomeDirPath(path, homeDir2) ) {
01087      // kdDebug() << "Path was replaced\n";
01088    }
01089 
01090    if (startsWithFile)
01091       path.prepend( "file:" );
01092 
01093    return path;
01094 }
01095 
01096 void KConfigBase::writePathEntry( const char *pKey, const QString & path,
01097                                   bool bPersistent, bool bGlobal,
01098                                   bool bNLS)
01099 {
01100    writeEntry(pKey, translatePath(path), bPersistent, bGlobal, bNLS);
01101 }
01102 
01103 void KConfigBase::writePathEntry ( const QString& pKey, const QStringList &list,
01104                                char sep , bool bPersistent,
01105                                bool bGlobal, bool bNLS )
01106 {
01107   writePathEntry(pKey.utf8().data(), list, sep, bPersistent, bGlobal, bNLS);
01108 }
01109 
01110 void KConfigBase::writePathEntry ( const char *pKey, const QStringList &list,
01111                                char sep , bool bPersistent,
01112                                bool bGlobal, bool bNLS )
01113 {
01114   if( list.isEmpty() )
01115     {
01116       writeEntry( pKey, QString::fromLatin1(""), bPersistent );
01117       return;
01118     }
01119   QStringList new_list;
01120   QStringList::ConstIterator it = list.begin();
01121   for( ; it != list.end(); ++it )
01122     {
01123       QString value = *it;
01124       new_list.append( translatePath(value) );
01125     }
01126   writeEntry( pKey, new_list, sep, bPersistent, bGlobal, bNLS );
01127 }
01128 
01129 void KConfigBase::deleteEntry( const QString& pKey,
01130                                  bool bNLS,
01131                                  bool bGlobal)
01132 {
01133    deleteEntry(pKey.utf8().data(), bNLS, bGlobal);
01134 }
01135 
01136 void KConfigBase::deleteEntry( const char *pKey,
01137                                  bool bNLS,
01138                                  bool bGlobal)
01139 {
01140   // the KConfig object is dirty now
01141   // set this before any IO takes place so that if any derivative
01142   // classes do caching, they won't try and flush the cache out
01143   // from under us before we read. A race condition is still
01144   // possible but minimized.
01145   setDirty(true);
01146 
01147   if (!bLocaleInitialized && KGlobal::locale())
01148     setLocale();
01149 
01150   KEntryKey entryKey(mGroup, pKey);
01151   KEntry aEntryData;
01152 
01153   aEntryData.bGlobal = bGlobal;
01154   aEntryData.bNLS = bNLS;
01155   aEntryData.bDirty = true;
01156   aEntryData.bDeleted = true;
01157 
01158   // rewrite the new value
01159   putData(entryKey, aEntryData, true);
01160 }
01161 
01162 bool KConfigBase::deleteGroup( const QString& group, bool bDeep, bool bGlobal )
01163 {
01164   KEntryMap aEntryMap = internalEntryMap(group);
01165 
01166   if (!bDeep) {
01167     // Check if it empty
01168     return aEntryMap.isEmpty();
01169   }
01170 
01171   bool dirty = false;
01172   bool checkGroup = true;
01173   // we want to remove all entries in the group
01174   KEntryMapIterator aIt;
01175   for (aIt = aEntryMap.begin(); aIt != aEntryMap.end(); ++aIt)
01176   {
01177     if (!aIt.key().mKey.isEmpty() && !aIt.key().bDefault && !(*aIt).bDeleted)
01178     {
01179       (*aIt).bDeleted = true;
01180       (*aIt).bDirty = true;
01181       (*aIt).bGlobal = bGlobal;
01182       (*aIt).mValue = 0;
01183       putData(aIt.key(), *aIt, checkGroup);
01184       checkGroup = false;
01185       dirty = true;
01186     }
01187   }
01188   if (dirty)
01189      setDirty(true);
01190   return true;
01191 }
01192 
01193 void KConfigBase::writeEntry ( const QString& pKey, const QVariant &prop,
01194                                bool bPersistent,
01195                                bool bGlobal, bool bNLS )
01196 {
01197   writeEntry(pKey.utf8().data(), prop, bPersistent, bGlobal, bNLS);
01198 }
01199 
01200 void KConfigBase::writeEntry ( const char *pKey, const QVariant &prop,
01201                                bool bPersistent,
01202                                bool bGlobal, bool bNLS )
01203 {
01204   switch( prop.type() )
01205     {
01206     case QVariant::Invalid:
01207       writeEntry( pKey, "", bPersistent, bGlobal, bNLS );
01208       return;
01209     case QVariant::String:
01210       writeEntry( pKey, prop.toString(), bPersistent, bGlobal, bNLS );
01211       return;
01212     case QVariant::StringList:
01213       writeEntry( pKey, prop.toStringList(), ',', bPersistent, bGlobal, bNLS );
01214       return;
01215     case QVariant::List: {
01216         QValueList<QVariant> list = prop.toList();
01217         QValueList<QVariant>::ConstIterator it = list.begin();
01218         QValueList<QVariant>::ConstIterator end = list.end();
01219         QStringList strList;
01220 
01221         for (; it != end; ++it )
01222             strList.append( (*it).toString() );
01223 
01224         writeEntry( pKey, strList, ',', bPersistent, bGlobal, bNLS );
01225 
01226         return;
01227     }
01228     case QVariant::Font:
01229       writeEntry( pKey, prop.toFont(), bPersistent, bGlobal, bNLS );
01230       return;
01231     case QVariant::Point:
01232       writeEntry( pKey, prop.toPoint(), bPersistent, bGlobal, bNLS );
01233       return;
01234     case QVariant::Rect:
01235       writeEntry( pKey, prop.toRect(), bPersistent, bGlobal, bNLS );
01236       return;
01237     case QVariant::Size:
01238       writeEntry( pKey, prop.toSize(), bPersistent, bGlobal, bNLS );
01239       return;
01240     case QVariant::Color:
01241       writeEntry( pKey, prop.toColor(), bPersistent, bGlobal, bNLS );
01242       return;
01243     case QVariant::Int:
01244       writeEntry( pKey, prop.toInt(), bPersistent, bGlobal, bNLS );
01245       return;
01246     case QVariant::UInt:
01247       writeEntry( pKey, prop.toUInt(), bPersistent, bGlobal, bNLS );
01248       return;
01249     case QVariant::LongLong:
01250       writeEntry( pKey, prop.toLongLong(), bPersistent, bGlobal, bNLS );
01251       return;
01252     case QVariant::ULongLong:
01253       writeEntry( pKey, prop.toULongLong(), bPersistent, bGlobal, bNLS );
01254       return;
01255     case QVariant::Bool:
01256       writeEntry( pKey, prop.toBool(), bPersistent, bGlobal, bNLS );
01257       return;
01258     case QVariant::Double:
01259       writeEntry( pKey, prop.toDouble(), bPersistent, bGlobal, 'g', 6, bNLS );
01260       return;
01261     case QVariant::DateTime:
01262       writeEntry( pKey, prop.toDateTime(), bPersistent, bGlobal, bNLS);
01263       return;
01264     case QVariant::Date:
01265       writeEntry( pKey, QDateTime(prop.toDate()), bPersistent, bGlobal, bNLS);
01266       return;
01267 
01268     case QVariant::Pixmap:
01269     case QVariant::Image:
01270     case QVariant::Brush:
01271     case QVariant::Palette:
01272     case QVariant::ColorGroup:
01273     case QVariant::Map:
01274     case QVariant::IconSet:
01275     case QVariant::CString:
01276     case QVariant::PointArray:
01277     case QVariant::Region:
01278     case QVariant::Bitmap:
01279     case QVariant::Cursor:
01280     case QVariant::SizePolicy:
01281     case QVariant::Time:
01282     case QVariant::ByteArray:
01283     case QVariant::BitArray:
01284     case QVariant::KeySequence:
01285     case QVariant::Pen:
01286         break;
01287     }
01288 
01289   Q_ASSERT( 0 );
01290 }
01291 
01292 void KConfigBase::writeEntry ( const QString& pKey, const QStrList &list,
01293                                char sep , bool bPersistent,
01294                                bool bGlobal, bool bNLS )
01295 {
01296   writeEntry(pKey.utf8().data(), list, sep, bPersistent, bGlobal, bNLS);
01297 }
01298 
01299 void KConfigBase::writeEntry ( const char *pKey, const QStrList &list,
01300                                char sep , bool bPersistent,
01301                                bool bGlobal, bool bNLS )
01302 {
01303   if( list.isEmpty() )
01304     {
01305       writeEntry( pKey, QString::fromLatin1(""), bPersistent );
01306       return;
01307     }
01308   QString str_list;
01309   QStrListIterator it( list );
01310   for( ; it.current(); ++it )
01311     {
01312       uint i;
01313       QString value;
01314       // !!! Sergey A. Sukiyazov <corwin@micom.don.ru> !!!
01315       // A QStrList may contain values in 8bit locale cpecified
01316       // encoding or in UTF8 encoding.
01317       value = KStringHandler::from8Bit(it.current());
01318       for( i = 0; i < value.length(); i++ )
01319         {
01320           if( value[i] == sep || value[i] == '\\' )
01321             str_list += '\\';
01322           str_list += value[i];
01323         }
01324       str_list += sep;
01325     }
01326   if( str_list.at(str_list.length() - 1) == sep )
01327     str_list.truncate( str_list.length() -1 );
01328   writeEntry( pKey, str_list, bPersistent, bGlobal, bNLS );
01329 }
01330 
01331 void KConfigBase::writeEntry ( const QString& pKey, const QStringList &list,
01332                                char sep , bool bPersistent,
01333                                bool bGlobal, bool bNLS )
01334 {
01335   writeEntry(pKey.utf8().data(), list, sep, bPersistent, bGlobal, bNLS);
01336 }
01337 
01338 void KConfigBase::writeEntry ( const char *pKey, const QStringList &list,
01339                                char sep , bool bPersistent,
01340                                bool bGlobal, bool bNLS )
01341 {
01342   if( list.isEmpty() )
01343     {
01344       writeEntry( pKey, QString::fromLatin1(""), bPersistent );
01345       return;
01346     }
01347   QString str_list;
01348   QStringList::ConstIterator it = list.begin();
01349   for( ; it != list.end(); ++it )
01350     {
01351       QString value = *it;
01352       uint i;
01353       for( i = 0; i < value.length(); i++ )
01354         {
01355           if( value[i] == sep || value[i] == '\\' )
01356             str_list += '\\';
01357           str_list += value[i];
01358         }
01359       str_list += sep;
01360     }
01361   if( str_list.at(str_list.length() - 1) == sep )
01362     str_list.truncate( str_list.length() -1 );
01363   writeEntry( pKey, str_list, bPersistent, bGlobal, bNLS );
01364 }
01365 
01366 void KConfigBase::writeEntry ( const QString& pKey, const QValueList<int> &list,
01367                                bool bPersistent, bool bGlobal, bool bNLS )
01368 {
01369   writeEntry(pKey.utf8().data(), list, bPersistent, bGlobal, bNLS);
01370 }
01371 
01372 void KConfigBase::writeEntry ( const char *pKey, const QValueList<int> &list,
01373                                bool bPersistent, bool bGlobal, bool bNLS )
01374 {
01375     QStringList strlist;
01376     QValueList<int>::ConstIterator end = list.end();
01377     for (QValueList<int>::ConstIterator it = list.begin(); it != end; it++)
01378         strlist << QString::number(*it);
01379     writeEntry(pKey, strlist, ',', bPersistent, bGlobal, bNLS );
01380 }
01381 
01382 void KConfigBase::writeEntry( const QString& pKey, int nValue,
01383                                  bool bPersistent, bool bGlobal,
01384                                  bool bNLS )
01385 {
01386   writeEntry( pKey, QString::number(nValue), bPersistent, bGlobal, bNLS );
01387 }
01388 
01389 void KConfigBase::writeEntry( const char *pKey, int nValue,
01390                                  bool bPersistent, bool bGlobal,
01391                                  bool bNLS )
01392 {
01393   writeEntry( pKey, QString::number(nValue), bPersistent, bGlobal, bNLS );
01394 }
01395 
01396 
01397 void KConfigBase::writeEntry( const QString& pKey, unsigned int nValue,
01398                                  bool bPersistent, bool bGlobal,
01399                                  bool bNLS )
01400 {
01401   writeEntry( pKey, QString::number(nValue), bPersistent, bGlobal, bNLS );
01402 }
01403 
01404 void KConfigBase::writeEntry( const char *pKey, unsigned int nValue,
01405                                  bool bPersistent, bool bGlobal,
01406                                  bool bNLS )
01407 {
01408   writeEntry( pKey, QString::number(nValue), bPersistent, bGlobal, bNLS );
01409 }
01410 
01411 
01412 void KConfigBase::writeEntry( const QString& pKey, long nValue,
01413                                  bool bPersistent, bool bGlobal,
01414                                  bool bNLS )
01415 {
01416   writeEntry( pKey, QString::number(nValue), bPersistent, bGlobal, bNLS );
01417 }
01418 
01419 void KConfigBase::writeEntry( const char *pKey, long nValue,
01420                                  bool bPersistent, bool bGlobal,
01421                                  bool bNLS )
01422 {
01423   writeEntry( pKey, QString::number(nValue), bPersistent, bGlobal, bNLS );
01424 }
01425 
01426 
01427 void KConfigBase::writeEntry( const QString& pKey, unsigned long nValue,
01428                                  bool bPersistent, bool bGlobal,
01429                                  bool bNLS )
01430 {
01431   writeEntry( pKey, QString::number(nValue), bPersistent, bGlobal, bNLS );
01432 }
01433 
01434 void KConfigBase::writeEntry( const char *pKey, unsigned long nValue,
01435                                  bool bPersistent, bool bGlobal,
01436                                  bool bNLS )
01437 {
01438   writeEntry( pKey, QString::number(nValue), bPersistent, bGlobal, bNLS );
01439 }
01440 
01441 void KConfigBase::writeEntry( const QString& pKey, Q_INT64 nValue,
01442                                  bool bPersistent, bool bGlobal,
01443                                  bool bNLS )
01444 {
01445   writeEntry( pKey, QString::number(nValue), bPersistent, bGlobal, bNLS );
01446 }
01447 
01448 void KConfigBase::writeEntry( const char *pKey, Q_INT64 nValue,
01449                                  bool bPersistent, bool bGlobal,
01450                                  bool bNLS )
01451 {
01452   writeEntry( pKey, QString::number(nValue), bPersistent, bGlobal, bNLS );
01453 }
01454 
01455 
01456 void KConfigBase::writeEntry( const QString& pKey, Q_UINT64 nValue,
01457                                  bool bPersistent, bool bGlobal,
01458                                  bool bNLS )
01459 {
01460   writeEntry( pKey, QString::number(nValue), bPersistent, bGlobal, bNLS );
01461 }
01462 
01463 void KConfigBase::writeEntry( const char *pKey, Q_UINT64 nValue,
01464                                  bool bPersistent, bool bGlobal,
01465                                  bool bNLS )
01466 {
01467   writeEntry( pKey, QString::number(nValue), bPersistent, bGlobal, bNLS );
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 
01674 void KConfigBase::setReadDefaults(bool b)
01675 {
01676   if (!d)
01677   {
01678      if (!b) return;
01679      d = new KConfigBasePrivate();
01680   }   
01681      
01682   d->readDefaults = b;
01683 }
01684   
01685 bool KConfigBase::readDefaults() const
01686 {
01687   return (d && d->readDefaults);
01688 }
01689 
01690 void KConfigBase::revertToDefault(const QString &key)
01691 {
01692   setDirty(true);
01693 
01694   KEntryKey aEntryKey(mGroup, key.utf8());
01695   aEntryKey.bDefault = true;
01696 
01697   if (!locale().isNull()) {
01698     // try the localized key first
01699     aEntryKey.bLocal = true;
01700     KEntry entry = lookupData(aEntryKey);
01701     if (entry.mValue.isNull())
01702         entry.bDeleted = true;
01703 
01704     entry.bDirty = true;
01705     putData(aEntryKey, entry, true); // Revert
01706     aEntryKey.bLocal = false;
01707   }
01708 
01709   // try the non-localized version
01710   KEntry entry = lookupData(aEntryKey);
01711   if (entry.mValue.isNull())
01712      entry.bDeleted = true;
01713   entry.bDirty = true;
01714   putData(aEntryKey, entry, true); // Revert
01715 }
01716 
01717 bool KConfigBase::hasDefault(const QString &key) const
01718 {
01719   KEntryKey aEntryKey(mGroup, key.utf8());
01720   aEntryKey.bDefault = true;
01721 
01722   if (!locale().isNull()) {
01723     // try the localized key first
01724     aEntryKey.bLocal = true;
01725     KEntry entry = lookupData(aEntryKey);
01726     if (!entry.mValue.isNull())
01727         return true;
01728 
01729     aEntryKey.bLocal = false;
01730   }
01731 
01732   // try the non-localized version
01733   KEntry entry = lookupData(aEntryKey);
01734   if (!entry.mValue.isNull())
01735      return true;
01736 
01737   return false;  
01738 }
01739 
01740 
01741 
01742 KConfigGroup::KConfigGroup(KConfigBase *master, const QString &group)
01743 {
01744   mMaster = master;
01745   backEnd = mMaster->backEnd; // Needed for getConfigState()
01746   bLocaleInitialized = true;
01747   bReadOnly = mMaster->bReadOnly;
01748   bExpand = false;
01749   bDirty = false; // Not used
01750   mGroup = group.utf8();
01751   aLocaleString = mMaster->aLocaleString;
01752   setReadDefaults(mMaster->readDefaults());
01753 }
01754 
01755 KConfigGroup::KConfigGroup(KConfigBase *master, const QCString &group)
01756 {
01757   mMaster = master;
01758   backEnd = mMaster->backEnd; // Needed for getConfigState()
01759   bLocaleInitialized = true;
01760   bReadOnly = mMaster->bReadOnly;
01761   bExpand = false;
01762   bDirty = false; // Not used
01763   mGroup = group;
01764   aLocaleString = mMaster->aLocaleString;
01765   setReadDefaults(mMaster->readDefaults());
01766 }
01767 
01768 KConfigGroup::KConfigGroup(KConfigBase *master, const char * group)
01769 {
01770   mMaster = master;
01771   backEnd = mMaster->backEnd; // Needed for getConfigState()
01772   bLocaleInitialized = true;
01773   bReadOnly = mMaster->bReadOnly;
01774   bExpand = false;
01775   bDirty = false; // Not used
01776   mGroup = group;
01777   aLocaleString = mMaster->aLocaleString;
01778   setReadDefaults(mMaster->readDefaults());
01779 }
01780 
01781 void KConfigGroup::deleteGroup(bool bGlobal)
01782 {
01783   mMaster->deleteGroup(KConfigBase::group(), false, bGlobal);
01784 }
01785 
01786 void KConfigGroup::setDirty(bool _bDirty)
01787 {
01788   mMaster->setDirty(_bDirty);
01789 }
01790 
01791 void KConfigGroup::putData(const KEntryKey &_key, const KEntry &_data, bool _checkGroup)
01792 {
01793   mMaster->putData(_key, _data, _checkGroup);
01794 }
01795 
01796 KEntry KConfigGroup::lookupData(const KEntryKey &_key) const
01797 {
01798   return mMaster->lookupData(_key);
01799 }
01800 
01801 void KConfigGroup::sync()
01802 {
01803   mMaster->sync();
01804 }
01805 
01806 void KConfigBase::virtual_hook( int, void* )
01807 { /*BASE::virtual_hook( id, data );*/ }
01808 
01809 void KConfigGroup::virtual_hook( int id, void* data )
01810 { KConfigBase::virtual_hook( id, data ); }
01811 
01812 bool KConfigBase::checkConfigFilesWritable(bool warnUser)
01813 {
01814   if (backEnd)
01815     return backEnd->checkConfigFilesWritable(warnUser);
01816   else
01817     return false;
01818 }
01819 
01820 #include "kconfigbase.moc"
KDE Logo
This file is part of the documentation for kdecore Library Version 3.2.2.
Documentation copyright © 1996-2004 the KDE developers.
Generated on Thu Apr 22 14:23:00 2004 by doxygen 1.2.18 written by Dimitri van Heesch, © 1997-2003