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 QStringList KConfigBase::readListEntry( const char* pKey, const QStringList& aDefault, 00525 char sep ) const 00526 { 00527 if ( !hasKey( pKey ) ) 00528 return aDefault; 00529 else 00530 return readListEntry( pKey, sep ); 00531 } 00532 00533 QValueList<int> KConfigBase::readIntListEntry( const QString& pKey ) const 00534 { 00535 return readIntListEntry(pKey.utf8().data()); 00536 } 00537 00538 QValueList<int> KConfigBase::readIntListEntry( const char *pKey ) const 00539 { 00540 QStringList strlist = readListEntry(pKey); 00541 QValueList<int> list; 00542 for (QStringList::ConstIterator it = strlist.begin(); it != strlist.end(); it++) 00543 // I do not check if the toInt failed because I consider the number of items 00544 // more important than their value 00545 list << (*it).toInt(); 00546 00547 return list; 00548 } 00549 00550 QString KConfigBase::readPathEntry( const QString& pKey, const QString& pDefault ) const 00551 { 00552 return readPathEntry(pKey.utf8().data(), pDefault); 00553 } 00554 00555 QString KConfigBase::readPathEntry( const char *pKey, const QString& pDefault ) const 00556 { 00557 const bool bExpandSave = bExpand; 00558 bExpand = true; 00559 QString aValue = readEntry( pKey, pDefault ); 00560 bExpand = bExpandSave; 00561 return aValue; 00562 } 00563 00564 QStringList KConfigBase::readPathListEntry( const QString& pKey, char sep ) const 00565 { 00566 return readPathListEntry(pKey.utf8().data(), sep); 00567 } 00568 00569 QStringList KConfigBase::readPathListEntry( const char *pKey, char sep ) const 00570 { 00571 const bool bExpandSave = bExpand; 00572 bExpand = true; 00573 QStringList aValue = readListEntry( pKey, sep ); 00574 bExpand = bExpandSave; 00575 return aValue; 00576 } 00577 00578 int KConfigBase::readNumEntry( const QString& pKey, int nDefault) const 00579 { 00580 return readNumEntry(pKey.utf8().data(), nDefault); 00581 } 00582 00583 int KConfigBase::readNumEntry( const char *pKey, int nDefault) const 00584 { 00585 QCString aValue = readEntryUtf8( pKey ); 00586 if( aValue.isNull() ) 00587 return nDefault; 00588 else if( aValue == "true" || aValue == "on" || aValue == "yes" ) 00589 return 1; 00590 else 00591 { 00592 bool ok; 00593 int rc = aValue.toInt( &ok ); 00594 return( ok ? rc : nDefault ); 00595 } 00596 } 00597 00598 00599 unsigned int KConfigBase::readUnsignedNumEntry( const QString& pKey, unsigned int nDefault) const 00600 { 00601 return readUnsignedNumEntry(pKey.utf8().data(), nDefault); 00602 } 00603 00604 unsigned int KConfigBase::readUnsignedNumEntry( const char *pKey, unsigned int nDefault) const 00605 { 00606 QCString aValue = readEntryUtf8( pKey ); 00607 if( aValue.isNull() ) 00608 return nDefault; 00609 else 00610 { 00611 bool ok; 00612 unsigned int rc = aValue.toUInt( &ok ); 00613 return( ok ? rc : nDefault ); 00614 } 00615 } 00616 00617 00618 long KConfigBase::readLongNumEntry( const QString& pKey, long nDefault) const 00619 { 00620 return readLongNumEntry(pKey.utf8().data(), nDefault); 00621 } 00622 00623 long KConfigBase::readLongNumEntry( const char *pKey, long nDefault) const 00624 { 00625 QCString aValue = readEntryUtf8( pKey ); 00626 if( aValue.isNull() ) 00627 return nDefault; 00628 else 00629 { 00630 bool ok; 00631 long rc = aValue.toLong( &ok ); 00632 return( ok ? rc : nDefault ); 00633 } 00634 } 00635 00636 00637 unsigned long KConfigBase::readUnsignedLongNumEntry( const QString& pKey, unsigned long nDefault) const 00638 { 00639 return readUnsignedLongNumEntry(pKey.utf8().data(), nDefault); 00640 } 00641 00642 unsigned long KConfigBase::readUnsignedLongNumEntry( const char *pKey, unsigned long nDefault) const 00643 { 00644 QCString aValue = readEntryUtf8( pKey ); 00645 if( aValue.isNull() ) 00646 return nDefault; 00647 else 00648 { 00649 bool ok; 00650 unsigned long rc = aValue.toULong( &ok ); 00651 return( ok ? rc : nDefault ); 00652 } 00653 } 00654 00655 Q_INT64 KConfigBase::readNum64Entry( const QString& pKey, Q_INT64 nDefault) const 00656 { 00657 return readNum64Entry(pKey.utf8().data(), nDefault); 00658 } 00659 00660 Q_INT64 KConfigBase::readNum64Entry( const char *pKey, Q_INT64 nDefault) const 00661 { 00662 // Note that QCString::toLongLong() is missing, we muse use a QString instead. 00663 QString aValue = readEntry( pKey ); 00664 if( aValue.isNull() ) 00665 return nDefault; 00666 else 00667 { 00668 bool ok; 00669 Q_INT64 rc = aValue.toLongLong( &ok ); 00670 return( ok ? rc : nDefault ); 00671 } 00672 } 00673 00674 00675 Q_UINT64 KConfigBase::readUnsignedNum64Entry( const QString& pKey, Q_UINT64 nDefault) const 00676 { 00677 return readUnsignedNum64Entry(pKey.utf8().data(), nDefault); 00678 } 00679 00680 Q_UINT64 KConfigBase::readUnsignedNum64Entry( const char *pKey, Q_UINT64 nDefault) const 00681 { 00682 // Note that QCString::toULongLong() is missing, we muse use a QString instead. 00683 QString aValue = readEntry( pKey ); 00684 if( aValue.isNull() ) 00685 return nDefault; 00686 else 00687 { 00688 bool ok; 00689 Q_UINT64 rc = aValue.toULongLong( &ok ); 00690 return( ok ? rc : nDefault ); 00691 } 00692 } 00693 00694 double KConfigBase::readDoubleNumEntry( const QString& pKey, double nDefault) const 00695 { 00696 return readDoubleNumEntry(pKey.utf8().data(), nDefault); 00697 } 00698 00699 double KConfigBase::readDoubleNumEntry( const char *pKey, double nDefault) const 00700 { 00701 QCString aValue = readEntryUtf8( pKey ); 00702 if( aValue.isNull() ) 00703 return nDefault; 00704 else 00705 { 00706 bool ok; 00707 double rc = aValue.toDouble( &ok ); 00708 return( ok ? rc : nDefault ); 00709 } 00710 } 00711 00712 00713 bool KConfigBase::readBoolEntry( const QString& pKey, bool bDefault ) const 00714 { 00715 return readBoolEntry(pKey.utf8().data(), bDefault); 00716 } 00717 00718 bool KConfigBase::readBoolEntry( const char *pKey, bool bDefault ) const 00719 { 00720 QCString aValue = readEntryUtf8( pKey ); 00721 00722 if( aValue.isNull() ) 00723 return bDefault; 00724 else 00725 { 00726 if( aValue == "true" || aValue == "on" || aValue == "yes" || aValue == "1" ) 00727 return true; 00728 else 00729 { 00730 bool bOK; 00731 int val = aValue.toInt( &bOK ); 00732 if( bOK && val != 0 ) 00733 return true; 00734 else 00735 return false; 00736 } 00737 } 00738 } 00739 00740 QFont KConfigBase::readFontEntry( const QString& pKey, const QFont* pDefault ) const 00741 { 00742 return readFontEntry(pKey.utf8().data(), pDefault); 00743 } 00744 00745 QFont KConfigBase::readFontEntry( const char *pKey, const QFont* pDefault ) const 00746 { 00747 QFont aRetFont; 00748 00749 QString aValue = readEntry( pKey ); 00750 if( !aValue.isNull() ) { 00751 if ( aValue.contains( ',' ) > 5 ) { 00752 // KDE3 and upwards entry 00753 if ( !aRetFont.fromString( aValue ) && pDefault ) 00754 aRetFont = *pDefault; 00755 } 00756 else { 00757 // backward compatibility with older font formats 00758 // ### remove KDE 3.1 ? 00759 // find first part (font family) 00760 int nIndex = aValue.find( ',' ); 00761 if( nIndex == -1 ){ 00762 if( pDefault ) 00763 aRetFont = *pDefault; 00764 return aRetFont; 00765 } 00766 aRetFont.setFamily( aValue.left( nIndex ) ); 00767 00768 // find second part (point size) 00769 int nOldIndex = nIndex; 00770 nIndex = aValue.find( ',', nOldIndex+1 ); 00771 if( nIndex == -1 ){ 00772 if( pDefault ) 00773 aRetFont = *pDefault; 00774 return aRetFont; 00775 } 00776 00777 aRetFont.setPointSize( aValue.mid( nOldIndex+1, 00778 nIndex-nOldIndex-1 ).toInt() ); 00779 00780 // find third part (style hint) 00781 nOldIndex = nIndex; 00782 nIndex = aValue.find( ',', nOldIndex+1 ); 00783 00784 if( nIndex == -1 ){ 00785 if( pDefault ) 00786 aRetFont = *pDefault; 00787 return aRetFont; 00788 } 00789 00790 aRetFont.setStyleHint( (QFont::StyleHint)aValue.mid( nOldIndex+1, nIndex-nOldIndex-1 ).toUInt() ); 00791 00792 // find fourth part (char set) 00793 nOldIndex = nIndex; 00794 nIndex = aValue.find( ',', nOldIndex+1 ); 00795 00796 if( nIndex == -1 ){ 00797 if( pDefault ) 00798 aRetFont = *pDefault; 00799 return aRetFont; 00800 } 00801 00802 QString chStr=aValue.mid( nOldIndex+1, 00803 nIndex-nOldIndex-1 ); 00804 // find fifth part (weight) 00805 nOldIndex = nIndex; 00806 nIndex = aValue.find( ',', nOldIndex+1 ); 00807 00808 if( nIndex == -1 ){ 00809 if( pDefault ) 00810 aRetFont = *pDefault; 00811 return aRetFont; 00812 } 00813 00814 aRetFont.setWeight( aValue.mid( nOldIndex+1, 00815 nIndex-nOldIndex-1 ).toUInt() ); 00816 00817 // find sixth part (font bits) 00818 uint nFontBits = aValue.right( aValue.length()-nIndex-1 ).toUInt(); 00819 00820 aRetFont.setItalic( nFontBits & 0x01 ); 00821 aRetFont.setUnderline( nFontBits & 0x02 ); 00822 aRetFont.setStrikeOut( nFontBits & 0x04 ); 00823 aRetFont.setFixedPitch( nFontBits & 0x08 ); 00824 aRetFont.setRawMode( nFontBits & 0x20 ); 00825 } 00826 } 00827 else 00828 { 00829 if( pDefault ) 00830 aRetFont = *pDefault; 00831 } 00832 00833 return aRetFont; 00834 } 00835 00836 00837 QRect KConfigBase::readRectEntry( const QString& pKey, const QRect* pDefault ) const 00838 { 00839 return readRectEntry(pKey.utf8().data(), pDefault); 00840 } 00841 00842 QRect KConfigBase::readRectEntry( const char *pKey, const QRect* pDefault ) const 00843 { 00844 QCString aValue = readEntryUtf8(pKey); 00845 00846 if (!aValue.isEmpty()) 00847 { 00848 int left, top, width, height; 00849 00850 if (sscanf(aValue.data(), "%d,%d,%d,%d", &left, &top, &width, &height) == 4) 00851 { 00852 return QRect(left, top, width, height); 00853 } 00854 } 00855 if (pDefault) 00856 return *pDefault; 00857 return QRect(); 00858 } 00859 00860 00861 QPoint KConfigBase::readPointEntry( const QString& pKey, 00862 const QPoint* pDefault ) const 00863 { 00864 return readPointEntry(pKey.utf8().data(), pDefault); 00865 } 00866 00867 QPoint KConfigBase::readPointEntry( const char *pKey, 00868 const QPoint* pDefault ) const 00869 { 00870 QCString aValue = readEntryUtf8(pKey); 00871 00872 if (!aValue.isEmpty()) 00873 { 00874 int x,y; 00875 00876 if (sscanf(aValue.data(), "%d,%d", &x, &y) == 2) 00877 { 00878 return QPoint(x,y); 00879 } 00880 } 00881 if (pDefault) 00882 return *pDefault; 00883 return QPoint(); 00884 } 00885 00886 QSize KConfigBase::readSizeEntry( const QString& pKey, 00887 const QSize* pDefault ) const 00888 { 00889 return readSizeEntry(pKey.utf8().data(), pDefault); 00890 } 00891 00892 QSize KConfigBase::readSizeEntry( const char *pKey, 00893 const QSize* pDefault ) const 00894 { 00895 QCString aValue = readEntryUtf8(pKey); 00896 00897 if (!aValue.isEmpty()) 00898 { 00899 int width,height; 00900 00901 if (sscanf(aValue.data(), "%d,%d", &width, &height) == 2) 00902 { 00903 return QSize(width, height); 00904 } 00905 } 00906 if (pDefault) 00907 return *pDefault; 00908 return QSize(); 00909 } 00910 00911 00912 QColor KConfigBase::readColorEntry( const QString& pKey, 00913 const QColor* pDefault ) const 00914 { 00915 return readColorEntry(pKey.utf8().data(), pDefault); 00916 } 00917 00918 QColor KConfigBase::readColorEntry( const char *pKey, 00919 const QColor* pDefault ) const 00920 { 00921 QColor aRetColor; 00922 int nRed = 0, nGreen = 0, nBlue = 0; 00923 00924 QString aValue = readEntry( pKey ); 00925 if( !aValue.isEmpty() ) 00926 { 00927 if ( aValue.at(0) == '#' ) 00928 { 00929 aRetColor.setNamedColor(aValue); 00930 } 00931 else 00932 { 00933 00934 bool bOK; 00935 00936 // find first part (red) 00937 int nIndex = aValue.find( ',' ); 00938 00939 if( nIndex == -1 ){ 00940 // return a sensible default -- Bernd 00941 if( pDefault ) 00942 aRetColor = *pDefault; 00943 return aRetColor; 00944 } 00945 00946 nRed = aValue.left( nIndex ).toInt( &bOK ); 00947 00948 // find second part (green) 00949 int nOldIndex = nIndex; 00950 nIndex = aValue.find( ',', nOldIndex+1 ); 00951 00952 if( nIndex == -1 ){ 00953 // return a sensible default -- Bernd 00954 if( pDefault ) 00955 aRetColor = *pDefault; 00956 return aRetColor; 00957 } 00958 nGreen = aValue.mid( nOldIndex+1, 00959 nIndex-nOldIndex-1 ).toInt( &bOK ); 00960 00961 // find third part (blue) 00962 nBlue = aValue.right( aValue.length()-nIndex-1 ).toInt( &bOK ); 00963 00964 aRetColor.setRgb( nRed, nGreen, nBlue ); 00965 } 00966 } 00967 else { 00968 00969 if( pDefault ) 00970 aRetColor = *pDefault; 00971 } 00972 00973 return aRetColor; 00974 } 00975 00976 00977 QDateTime KConfigBase::readDateTimeEntry( const QString& pKey, 00978 const QDateTime* pDefault ) const 00979 { 00980 return readDateTimeEntry(pKey.utf8().data(), pDefault); 00981 } 00982 00983 // ### currentDateTime() as fallback ? (Harri) 00984 QDateTime KConfigBase::readDateTimeEntry( const char *pKey, 00985 const QDateTime* pDefault ) const 00986 { 00987 if( !hasKey( pKey ) ) 00988 { 00989 if( pDefault ) 00990 return *pDefault; 00991 else 00992 return QDateTime::currentDateTime(); 00993 } 00994 00995 QStrList list; 00996 int count = readListEntry( pKey, list, ',' ); 00997 if( count == 6 ) { 00998 QDate date( atoi( list.at( 0 ) ), atoi( list.at( 1 ) ), 00999 atoi( list.at( 2 ) ) ); 01000 QTime time( atoi( list.at( 3 ) ), atoi( list.at( 4 ) ), 01001 atoi( list.at( 5 ) ) ); 01002 01003 return QDateTime( date, time ); 01004 } 01005 01006 return QDateTime::currentDateTime(); 01007 } 01008 01009 void KConfigBase::writeEntry( const QString& pKey, const QString& value, 01010 bool bPersistent, 01011 bool bGlobal, 01012 bool bNLS ) 01013 { 01014 writeEntry(pKey.utf8().data(), value, bPersistent, bGlobal, bNLS); 01015 } 01016 01017 void KConfigBase::writeEntry( const char *pKey, const QString& value, 01018 bool bPersistent, 01019 bool bGlobal, 01020 bool bNLS ) 01021 { 01022 // the KConfig object is dirty now 01023 // set this before any IO takes place so that if any derivative 01024 // classes do caching, they won't try and flush the cache out 01025 // from under us before we read. A race condition is still 01026 // possible but minimized. 01027 if( bPersistent ) 01028 setDirty(true); 01029 01030 if (!bLocaleInitialized && KGlobal::locale()) 01031 setLocale(); 01032 01033 KEntryKey entryKey(mGroup, pKey); 01034 entryKey.bLocal = bNLS; 01035 01036 KEntry aEntryData; 01037 aEntryData.mValue = value.utf8(); // set new value 01038 aEntryData.bGlobal = bGlobal; 01039 aEntryData.bNLS = bNLS; 01040 01041 if (bPersistent) 01042 aEntryData.bDirty = true; 01043 01044 // rewrite the new value 01045 putData(entryKey, aEntryData, true); 01046 } 01047 01048 void KConfigBase::writePathEntry( const QString& pKey, const QString & path, 01049 bool bPersistent, bool bGlobal, 01050 bool bNLS) 01051 { 01052 writePathEntry(pKey.utf8().data(), path, bPersistent, bGlobal, bNLS); 01053 } 01054 01055 01056 static bool cleanHomeDirPath( QString &path, const QString &homeDir ) 01057 { 01058 #ifdef Q_WS_WIN //safer 01059 if (!QDir::convertSeparators(path).startsWith(QDir::convertSeparators(homeDir))) 01060 return false; 01061 #else 01062 if (!path.startsWith(homeDir)) 01063 return false; 01064 #endif 01065 01066 unsigned int len = homeDir.length(); 01067 // replace by "$HOME" if possible 01068 if (path.length() == len || path[len] == '/') { 01069 path.replace(0, len, QString::fromLatin1("$HOME")); 01070 return true; 01071 } else 01072 return false; 01073 } 01074 01075 static QString translatePath( QString path ) 01076 { 01077 if (path.isEmpty()) 01078 return path; 01079 01080 // only "our" $HOME should be interpreted 01081 path.replace('$', "$$"); 01082 01083 bool startsWithFile = path.startsWith("file:", false); 01084 01085 // return original path, if it refers to another type of URL (e.g. http:/), or 01086 // if the path is already relative to another directory 01087 if (!startsWithFile && path[0] != '/' || 01088 startsWithFile && path[5] != '/') 01089 return path; 01090 01091 if (startsWithFile) 01092 path.remove(0,5); // strip leading "file:/" off the string 01093 01094 // keep only one single '/' at the beginning - needed for cleanHomeDirPath() 01095 while (path[0] == '/' && path[1] == '/') 01096 path.remove(0,1); 01097 01098 // we can not use KGlobal::dirs()->relativeLocation("home", path) here, 01099 // since it would not recognize paths without a trailing '/'. 01100 // All of the 3 following functions to return the user's home directory 01101 // can return different paths. We have to test all them. 01102 QString homeDir0 = QFile::decodeName(getenv("HOME")); 01103 QString homeDir1 = QDir::homeDirPath(); 01104 QString homeDir2 = QDir(homeDir1).canonicalPath(); 01105 if (cleanHomeDirPath(path, homeDir0) || 01106 cleanHomeDirPath(path, homeDir1) || 01107 cleanHomeDirPath(path, homeDir2) ) { 01108 // kdDebug() << "Path was replaced\n"; 01109 } 01110 01111 if (startsWithFile) 01112 path.prepend( "file://" ); 01113 01114 return path; 01115 } 01116 01117 void KConfigBase::writePathEntry( const char *pKey, const QString & path, 01118 bool bPersistent, bool bGlobal, 01119 bool bNLS) 01120 { 01121 writeEntry(pKey, translatePath(path), bPersistent, bGlobal, bNLS); 01122 } 01123 01124 void KConfigBase::writePathEntry ( const QString& pKey, const QStringList &list, 01125 char sep , bool bPersistent, 01126 bool bGlobal, bool bNLS ) 01127 { 01128 writePathEntry(pKey.utf8().data(), list, sep, bPersistent, bGlobal, bNLS); 01129 } 01130 01131 void KConfigBase::writePathEntry ( const char *pKey, const QStringList &list, 01132 char sep , bool bPersistent, 01133 bool bGlobal, bool bNLS ) 01134 { 01135 if( list.isEmpty() ) 01136 { 01137 writeEntry( pKey, QString::fromLatin1(""), bPersistent ); 01138 return; 01139 } 01140 QStringList new_list; 01141 QStringList::ConstIterator it = list.begin(); 01142 for( ; it != list.end(); ++it ) 01143 { 01144 QString value = *it; 01145 new_list.append( translatePath(value) ); 01146 } 01147 writeEntry( pKey, new_list, sep, bPersistent, bGlobal, bNLS ); 01148 } 01149 01150 void KConfigBase::deleteEntry( const QString& pKey, 01151 bool bNLS, 01152 bool bGlobal) 01153 { 01154 deleteEntry(pKey.utf8().data(), bNLS, bGlobal); 01155 } 01156 01157 void KConfigBase::deleteEntry( const char *pKey, 01158 bool bNLS, 01159 bool bGlobal) 01160 { 01161 // the KConfig object is dirty now 01162 // set this before any IO takes place so that if any derivative 01163 // classes do caching, they won't try and flush the cache out 01164 // from under us before we read. A race condition is still 01165 // possible but minimized. 01166 setDirty(true); 01167 01168 if (!bLocaleInitialized && KGlobal::locale()) 01169 setLocale(); 01170 01171 KEntryKey entryKey(mGroup, pKey); 01172 KEntry aEntryData; 01173 01174 aEntryData.bGlobal = bGlobal; 01175 aEntryData.bNLS = bNLS; 01176 aEntryData.bDirty = true; 01177 aEntryData.bDeleted = true; 01178 01179 // rewrite the new value 01180 putData(entryKey, aEntryData, true); 01181 } 01182 01183 bool KConfigBase::deleteGroup( const QString& group, bool bDeep, bool bGlobal ) 01184 { 01185 KEntryMap aEntryMap = internalEntryMap(group); 01186 01187 if (!bDeep) { 01188 // Check if it empty 01189 return aEntryMap.isEmpty(); 01190 } 01191 01192 bool dirty = false; 01193 bool checkGroup = true; 01194 // we want to remove all entries in the group 01195 KEntryMapIterator aIt; 01196 for (aIt = aEntryMap.begin(); aIt != aEntryMap.end(); ++aIt) 01197 { 01198 if (!aIt.key().mKey.isEmpty() && !aIt.key().bDefault && !(*aIt).bDeleted) 01199 { 01200 (*aIt).bDeleted = true; 01201 (*aIt).bDirty = true; 01202 (*aIt).bGlobal = bGlobal; 01203 (*aIt).mValue = 0; 01204 putData(aIt.key(), *aIt, checkGroup); 01205 checkGroup = false; 01206 dirty = true; 01207 } 01208 } 01209 if (dirty) 01210 setDirty(true); 01211 return true; 01212 } 01213 01214 void KConfigBase::writeEntry ( const QString& pKey, const QVariant &prop, 01215 bool bPersistent, 01216 bool bGlobal, bool bNLS ) 01217 { 01218 writeEntry(pKey.utf8().data(), prop, bPersistent, bGlobal, bNLS); 01219 } 01220 01221 void KConfigBase::writeEntry ( const char *pKey, const QVariant &prop, 01222 bool bPersistent, 01223 bool bGlobal, bool bNLS ) 01224 { 01225 switch( prop.type() ) 01226 { 01227 case QVariant::Invalid: 01228 writeEntry( pKey, "", bPersistent, bGlobal, bNLS ); 01229 return; 01230 case QVariant::String: 01231 writeEntry( pKey, prop.toString(), bPersistent, bGlobal, bNLS ); 01232 return; 01233 case QVariant::StringList: 01234 writeEntry( pKey, prop.toStringList(), ',', bPersistent, bGlobal, bNLS ); 01235 return; 01236 case QVariant::List: { 01237 QValueList<QVariant> list = prop.toList(); 01238 QValueList<QVariant>::ConstIterator it = list.begin(); 01239 QValueList<QVariant>::ConstIterator end = list.end(); 01240 QStringList strList; 01241 01242 for (; it != end; ++it ) 01243 strList.append( (*it).toString() ); 01244 01245 writeEntry( pKey, strList, ',', bPersistent, bGlobal, bNLS ); 01246 01247 return; 01248 } 01249 case QVariant::Font: 01250 writeEntry( pKey, prop.toFont(), bPersistent, bGlobal, bNLS ); 01251 return; 01252 case QVariant::Point: 01253 writeEntry( pKey, prop.toPoint(), bPersistent, bGlobal, bNLS ); 01254 return; 01255 case QVariant::Rect: 01256 writeEntry( pKey, prop.toRect(), bPersistent, bGlobal, bNLS ); 01257 return; 01258 case QVariant::Size: 01259 writeEntry( pKey, prop.toSize(), bPersistent, bGlobal, bNLS ); 01260 return; 01261 case QVariant::Color: 01262 writeEntry( pKey, prop.toColor(), bPersistent, bGlobal, bNLS ); 01263 return; 01264 case QVariant::Int: 01265 writeEntry( pKey, prop.toInt(), bPersistent, bGlobal, bNLS ); 01266 return; 01267 case QVariant::UInt: 01268 writeEntry( pKey, prop.toUInt(), bPersistent, bGlobal, bNLS ); 01269 return; 01270 case QVariant::LongLong: 01271 writeEntry( pKey, prop.toLongLong(), bPersistent, bGlobal, bNLS ); 01272 return; 01273 case QVariant::ULongLong: 01274 writeEntry( pKey, prop.toULongLong(), bPersistent, bGlobal, bNLS ); 01275 return; 01276 case QVariant::Bool: 01277 writeEntry( pKey, prop.toBool(), bPersistent, bGlobal, bNLS ); 01278 return; 01279 case QVariant::Double: 01280 writeEntry( pKey, prop.toDouble(), bPersistent, bGlobal, 'g', 6, bNLS ); 01281 return; 01282 case QVariant::DateTime: 01283 writeEntry( pKey, prop.toDateTime(), bPersistent, bGlobal, bNLS); 01284 return; 01285 case QVariant::Date: 01286 writeEntry( pKey, QDateTime(prop.toDate()), bPersistent, bGlobal, bNLS); 01287 return; 01288 01289 case QVariant::Pixmap: 01290 case QVariant::Image: 01291 case QVariant::Brush: 01292 case QVariant::Palette: 01293 case QVariant::ColorGroup: 01294 case QVariant::Map: 01295 case QVariant::IconSet: 01296 case QVariant::CString: 01297 case QVariant::PointArray: 01298 case QVariant::Region: 01299 case QVariant::Bitmap: 01300 case QVariant::Cursor: 01301 case QVariant::SizePolicy: 01302 case QVariant::Time: 01303 case QVariant::ByteArray: 01304 case QVariant::BitArray: 01305 case QVariant::KeySequence: 01306 case QVariant::Pen: 01307 break; 01308 } 01309 01310 Q_ASSERT( 0 ); 01311 } 01312 01313 void KConfigBase::writeEntry ( const QString& pKey, const QStrList &list, 01314 char sep , bool bPersistent, 01315 bool bGlobal, bool bNLS ) 01316 { 01317 writeEntry(pKey.utf8().data(), list, sep, bPersistent, bGlobal, bNLS); 01318 } 01319 01320 void KConfigBase::writeEntry ( const char *pKey, const QStrList &list, 01321 char sep , bool bPersistent, 01322 bool bGlobal, bool bNLS ) 01323 { 01324 if( list.isEmpty() ) 01325 { 01326 writeEntry( pKey, QString::fromLatin1(""), bPersistent ); 01327 return; 01328 } 01329 QString str_list; 01330 QStrListIterator it( list ); 01331 for( ; it.current(); ++it ) 01332 { 01333 uint i; 01334 QString value; 01335 // !!! Sergey A. Sukiyazov <corwin@micom.don.ru> !!! 01336 // A QStrList may contain values in 8bit locale cpecified 01337 // encoding or in UTF8 encoding. 01338 value = KStringHandler::from8Bit(it.current()); 01339 for( i = 0; i < value.length(); i++ ) 01340 { 01341 if( value[i] == sep || value[i] == '\\' ) 01342 str_list += '\\'; 01343 str_list += value[i]; 01344 } 01345 str_list += sep; 01346 } 01347 if( str_list.at(str_list.length() - 1) == sep ) 01348 str_list.truncate( str_list.length() -1 ); 01349 writeEntry( pKey, str_list, bPersistent, bGlobal, bNLS ); 01350 } 01351 01352 void KConfigBase::writeEntry ( const QString& pKey, const QStringList &list, 01353 char sep , bool bPersistent, 01354 bool bGlobal, bool bNLS ) 01355 { 01356 writeEntry(pKey.utf8().data(), list, sep, bPersistent, bGlobal, bNLS); 01357 } 01358 01359 void KConfigBase::writeEntry ( const char *pKey, const QStringList &list, 01360 char sep , bool bPersistent, 01361 bool bGlobal, bool bNLS ) 01362 { 01363 if( list.isEmpty() ) 01364 { 01365 writeEntry( pKey, QString::fromLatin1(""), bPersistent ); 01366 return; 01367 } 01368 QString str_list; 01369 str_list.reserve( 4096 ); 01370 QStringList::ConstIterator it = list.begin(); 01371 for( ; it != list.end(); ++it ) 01372 { 01373 QString value = *it; 01374 uint i; 01375 for( i = 0; i < value.length(); i++ ) 01376 { 01377 if( value[i] == sep || value[i] == '\\' ) 01378 str_list += '\\'; 01379 str_list += value[i]; 01380 } 01381 str_list += sep; 01382 } 01383 if( str_list.at(str_list.length() - 1) == sep ) 01384 str_list.truncate( str_list.length() -1 ); 01385 writeEntry( pKey, str_list, bPersistent, bGlobal, bNLS ); 01386 } 01387 01388 void KConfigBase::writeEntry ( const QString& pKey, const QValueList<int> &list, 01389 bool bPersistent, bool bGlobal, bool bNLS ) 01390 { 01391 writeEntry(pKey.utf8().data(), list, bPersistent, bGlobal, bNLS); 01392 } 01393 01394 void KConfigBase::writeEntry ( const char *pKey, const QValueList<int> &list, 01395 bool bPersistent, bool bGlobal, bool bNLS ) 01396 { 01397 QStringList strlist; 01398 QValueList<int>::ConstIterator end = list.end(); 01399 for (QValueList<int>::ConstIterator it = list.begin(); it != end; it++) 01400 strlist << QString::number(*it); 01401 writeEntry(pKey, strlist, ',', bPersistent, bGlobal, bNLS ); 01402 } 01403 01404 void KConfigBase::writeEntry( const QString& pKey, int nValue, 01405 bool bPersistent, bool bGlobal, 01406 bool bNLS ) 01407 { 01408 writeEntry( pKey, QString::number(nValue), bPersistent, bGlobal, bNLS ); 01409 } 01410 01411 void KConfigBase::writeEntry( const char *pKey, int nValue, 01412 bool bPersistent, bool bGlobal, 01413 bool bNLS ) 01414 { 01415 writeEntry( pKey, QString::number(nValue), bPersistent, bGlobal, bNLS ); 01416 } 01417 01418 01419 void KConfigBase::writeEntry( const QString& pKey, unsigned int nValue, 01420 bool bPersistent, bool bGlobal, 01421 bool bNLS ) 01422 { 01423 writeEntry( pKey, QString::number(nValue), bPersistent, bGlobal, bNLS ); 01424 } 01425 01426 void KConfigBase::writeEntry( const char *pKey, unsigned int nValue, 01427 bool bPersistent, bool bGlobal, 01428 bool bNLS ) 01429 { 01430 writeEntry( pKey, QString::number(nValue), bPersistent, bGlobal, bNLS ); 01431 } 01432 01433 01434 void KConfigBase::writeEntry( const QString& pKey, 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 char *pKey, long nValue, 01442 bool bPersistent, bool bGlobal, 01443 bool bNLS ) 01444 { 01445 writeEntry( pKey, QString::number(nValue), bPersistent, bGlobal, bNLS ); 01446 } 01447 01448 01449 void KConfigBase::writeEntry( const QString& pKey, unsigned long nValue, 01450 bool bPersistent, bool bGlobal, 01451 bool bNLS ) 01452 { 01453 writeEntry( pKey, QString::number(nValue), bPersistent, bGlobal, bNLS ); 01454 } 01455 01456 void KConfigBase::writeEntry( const char *pKey, unsigned long 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 QString& pKey, Q_INT64 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 char *pKey, Q_INT64 nValue, 01471 bool bPersistent, bool bGlobal, 01472 bool bNLS ) 01473 { 01474 writeEntry( pKey, QString::number(nValue), bPersistent, bGlobal, bNLS ); 01475 } 01476 01477 01478 void KConfigBase::writeEntry( const QString& pKey, Q_UINT64 nValue, 01479 bool bPersistent, bool bGlobal, 01480 bool bNLS ) 01481 { 01482 writeEntry( pKey, QString::number(nValue), bPersistent, bGlobal, bNLS ); 01483 } 01484 01485 void KConfigBase::writeEntry( const char *pKey, Q_UINT64 nValue, 01486 bool bPersistent, bool bGlobal, 01487 bool bNLS ) 01488 { 01489 writeEntry( pKey, QString::number(nValue), bPersistent, bGlobal, bNLS ); 01490 } 01491 01492 void KConfigBase::writeEntry( const QString& pKey, double nValue, 01493 bool bPersistent, bool bGlobal, 01494 char format, int precision, 01495 bool bNLS ) 01496 { 01497 writeEntry( pKey, QString::number(nValue, format, precision), 01498 bPersistent, bGlobal, bNLS ); 01499 } 01500 01501 void KConfigBase::writeEntry( const char *pKey, double nValue, 01502 bool bPersistent, bool bGlobal, 01503 char format, int precision, 01504 bool bNLS ) 01505 { 01506 writeEntry( pKey, QString::number(nValue, format, precision), 01507 bPersistent, bGlobal, bNLS ); 01508 } 01509 01510 01511 void KConfigBase::writeEntry( const QString& pKey, bool bValue, 01512 bool bPersistent, 01513 bool bGlobal, 01514 bool bNLS ) 01515 { 01516 writeEntry(pKey.utf8().data(), bValue, bPersistent, bGlobal, bNLS); 01517 } 01518 01519 void KConfigBase::writeEntry( const char *pKey, bool bValue, 01520 bool bPersistent, 01521 bool bGlobal, 01522 bool bNLS ) 01523 { 01524 QString aValue; 01525 01526 if( bValue ) 01527 aValue = "true"; 01528 else 01529 aValue = "false"; 01530 01531 writeEntry( pKey, aValue, bPersistent, bGlobal, bNLS ); 01532 } 01533 01534 01535 void KConfigBase::writeEntry( const QString& pKey, const QFont& rFont, 01536 bool bPersistent, bool bGlobal, 01537 bool bNLS ) 01538 { 01539 writeEntry(pKey.utf8().data(), rFont, bPersistent, bGlobal, bNLS); 01540 } 01541 01542 void KConfigBase::writeEntry( const char *pKey, const QFont& rFont, 01543 bool bPersistent, bool bGlobal, 01544 bool bNLS ) 01545 { 01546 writeEntry( pKey, rFont.toString(), bPersistent, bGlobal, bNLS ); 01547 } 01548 01549 01550 void KConfigBase::writeEntry( const QString& pKey, const QRect& rRect, 01551 bool bPersistent, bool bGlobal, 01552 bool bNLS ) 01553 { 01554 writeEntry(pKey.utf8().data(), rRect, bPersistent, bGlobal, bNLS); 01555 } 01556 01557 void KConfigBase::writeEntry( const char *pKey, const QRect& rRect, 01558 bool bPersistent, bool bGlobal, 01559 bool bNLS ) 01560 { 01561 QStrList list; 01562 QCString tempstr; 01563 list.insert( 0, tempstr.setNum( rRect.left() ) ); 01564 list.insert( 1, tempstr.setNum( rRect.top() ) ); 01565 list.insert( 2, tempstr.setNum( rRect.width() ) ); 01566 list.insert( 3, tempstr.setNum( rRect.height() ) ); 01567 01568 writeEntry( pKey, list, ',', bPersistent, bGlobal, bNLS ); 01569 } 01570 01571 01572 void KConfigBase::writeEntry( const QString& pKey, const QPoint& rPoint, 01573 bool bPersistent, bool bGlobal, 01574 bool bNLS ) 01575 { 01576 writeEntry(pKey.utf8().data(), rPoint, bPersistent, bGlobal, bNLS); 01577 } 01578 01579 void KConfigBase::writeEntry( const char *pKey, const QPoint& rPoint, 01580 bool bPersistent, bool bGlobal, 01581 bool bNLS ) 01582 { 01583 QStrList list; 01584 QCString tempstr; 01585 list.insert( 0, tempstr.setNum( rPoint.x() ) ); 01586 list.insert( 1, tempstr.setNum( rPoint.y() ) ); 01587 01588 writeEntry( pKey, list, ',', bPersistent, bGlobal, bNLS ); 01589 } 01590 01591 01592 void KConfigBase::writeEntry( const QString& pKey, const QSize& rSize, 01593 bool bPersistent, bool bGlobal, 01594 bool bNLS ) 01595 { 01596 writeEntry(pKey.utf8().data(), rSize, bPersistent, bGlobal, bNLS); 01597 } 01598 01599 void KConfigBase::writeEntry( const char *pKey, const QSize& rSize, 01600 bool bPersistent, bool bGlobal, 01601 bool bNLS ) 01602 { 01603 QStrList list; 01604 QCString tempstr; 01605 list.insert( 0, tempstr.setNum( rSize.width() ) ); 01606 list.insert( 1, tempstr.setNum( rSize.height() ) ); 01607 01608 writeEntry( pKey, list, ',', bPersistent, bGlobal, bNLS ); 01609 } 01610 01611 void KConfigBase::writeEntry( const QString& pKey, const QColor& rColor, 01612 bool bPersistent, 01613 bool bGlobal, 01614 bool bNLS ) 01615 { 01616 writeEntry( pKey.utf8().data(), rColor, bPersistent, bGlobal, bNLS); 01617 } 01618 01619 void KConfigBase::writeEntry( const char *pKey, const QColor& rColor, 01620 bool bPersistent, 01621 bool bGlobal, 01622 bool bNLS ) 01623 { 01624 QString aValue; 01625 if (rColor.isValid()) 01626 aValue.sprintf( "%d,%d,%d", rColor.red(), rColor.green(), rColor.blue() ); 01627 else 01628 aValue = "invalid"; 01629 01630 writeEntry( pKey, aValue, bPersistent, bGlobal, bNLS ); 01631 } 01632 01633 void KConfigBase::writeEntry( const QString& pKey, const QDateTime& rDateTime, 01634 bool bPersistent, bool bGlobal, 01635 bool bNLS ) 01636 { 01637 writeEntry(pKey.utf8().data(), rDateTime, bPersistent, bGlobal, bNLS); 01638 } 01639 01640 void KConfigBase::writeEntry( const char *pKey, const QDateTime& rDateTime, 01641 bool bPersistent, bool bGlobal, 01642 bool bNLS ) 01643 { 01644 QStrList list; 01645 QCString tempstr; 01646 01647 QTime time = rDateTime.time(); 01648 QDate date = rDateTime.date(); 01649 01650 list.insert( 0, tempstr.setNum( date.year() ) ); 01651 list.insert( 1, tempstr.setNum( date.month() ) ); 01652 list.insert( 2, tempstr.setNum( date.day() ) ); 01653 01654 list.insert( 3, tempstr.setNum( time.hour() ) ); 01655 list.insert( 4, tempstr.setNum( time.minute() ) ); 01656 list.insert( 5, tempstr.setNum( time.second() ) ); 01657 01658 writeEntry( pKey, list, ',', bPersistent, bGlobal, bNLS ); 01659 } 01660 01661 void KConfigBase::parseConfigFiles() 01662 { 01663 if (!bLocaleInitialized && KGlobal::_locale) { 01664 setLocale(); 01665 } 01666 if (backEnd) 01667 { 01668 backEnd->parseConfigFiles(); 01669 bReadOnly = (backEnd->getConfigState() == ReadOnly); 01670 } 01671 } 01672 01673 void KConfigBase::sync() 01674 { 01675 if (isReadOnly()) 01676 return; 01677 01678 if (backEnd) 01679 backEnd->sync(); 01680 if (bDirty) 01681 rollback(); 01682 } 01683 01684 KConfigBase::ConfigState KConfigBase::getConfigState() const { 01685 if (backEnd) 01686 return backEnd->getConfigState(); 01687 return ReadOnly; 01688 } 01689 01690 void KConfigBase::rollback( bool /*bDeep = true*/ ) 01691 { 01692 bDirty = false; 01693 } 01694 01695 01696 void KConfigBase::setReadDefaults(bool b) 01697 { 01698 if (!d) 01699 { 01700 if (!b) return; 01701 d = new KConfigBasePrivate(); 01702 } 01703 01704 d->readDefaults = b; 01705 } 01706 01707 bool KConfigBase::readDefaults() const 01708 { 01709 return (d && d->readDefaults); 01710 } 01711 01712 void KConfigBase::revertToDefault(const QString &key) 01713 { 01714 setDirty(true); 01715 01716 KEntryKey aEntryKey(mGroup, key.utf8()); 01717 aEntryKey.bDefault = true; 01718 01719 if (!locale().isNull()) { 01720 // try the localized key first 01721 aEntryKey.bLocal = true; 01722 KEntry entry = lookupData(aEntryKey); 01723 if (entry.mValue.isNull()) 01724 entry.bDeleted = true; 01725 01726 entry.bDirty = true; 01727 putData(aEntryKey, entry, true); // Revert 01728 aEntryKey.bLocal = false; 01729 } 01730 01731 // try the non-localized version 01732 KEntry entry = lookupData(aEntryKey); 01733 if (entry.mValue.isNull()) 01734 entry.bDeleted = true; 01735 entry.bDirty = true; 01736 putData(aEntryKey, entry, true); // Revert 01737 } 01738 01739 bool KConfigBase::hasDefault(const QString &key) const 01740 { 01741 KEntryKey aEntryKey(mGroup, key.utf8()); 01742 aEntryKey.bDefault = true; 01743 01744 if (!locale().isNull()) { 01745 // try the localized key first 01746 aEntryKey.bLocal = true; 01747 KEntry entry = lookupData(aEntryKey); 01748 if (!entry.mValue.isNull()) 01749 return true; 01750 01751 aEntryKey.bLocal = false; 01752 } 01753 01754 // try the non-localized version 01755 KEntry entry = lookupData(aEntryKey); 01756 if (!entry.mValue.isNull()) 01757 return true; 01758 01759 return false; 01760 } 01761 01762 01763 01764 KConfigGroup::KConfigGroup(KConfigBase *master, const QString &group) 01765 { 01766 mMaster = master; 01767 backEnd = mMaster->backEnd; // Needed for getConfigState() 01768 bLocaleInitialized = true; 01769 bReadOnly = mMaster->bReadOnly; 01770 bExpand = false; 01771 bDirty = false; // Not used 01772 mGroup = group.utf8(); 01773 aLocaleString = mMaster->aLocaleString; 01774 setReadDefaults(mMaster->readDefaults()); 01775 } 01776 01777 KConfigGroup::KConfigGroup(KConfigBase *master, const QCString &group) 01778 { 01779 mMaster = master; 01780 backEnd = mMaster->backEnd; // Needed for getConfigState() 01781 bLocaleInitialized = true; 01782 bReadOnly = mMaster->bReadOnly; 01783 bExpand = false; 01784 bDirty = false; // Not used 01785 mGroup = group; 01786 aLocaleString = mMaster->aLocaleString; 01787 setReadDefaults(mMaster->readDefaults()); 01788 } 01789 01790 KConfigGroup::KConfigGroup(KConfigBase *master, const char * group) 01791 { 01792 mMaster = master; 01793 backEnd = mMaster->backEnd; // Needed for getConfigState() 01794 bLocaleInitialized = true; 01795 bReadOnly = mMaster->bReadOnly; 01796 bExpand = false; 01797 bDirty = false; // Not used 01798 mGroup = group; 01799 aLocaleString = mMaster->aLocaleString; 01800 setReadDefaults(mMaster->readDefaults()); 01801 } 01802 01803 void KConfigGroup::deleteGroup(bool bGlobal) 01804 { 01805 mMaster->deleteGroup(KConfigBase::group(), true, bGlobal); 01806 } 01807 01808 bool KConfigGroup::groupIsImmutable() const 01809 { 01810 return mMaster->groupIsImmutable(KConfigBase::group()); 01811 } 01812 01813 void KConfigGroup::setDirty(bool _bDirty) 01814 { 01815 mMaster->setDirty(_bDirty); 01816 } 01817 01818 void KConfigGroup::putData(const KEntryKey &_key, const KEntry &_data, bool _checkGroup) 01819 { 01820 mMaster->putData(_key, _data, _checkGroup); 01821 } 01822 01823 KEntry KConfigGroup::lookupData(const KEntryKey &_key) const 01824 { 01825 return mMaster->lookupData(_key); 01826 } 01827 01828 void KConfigGroup::sync() 01829 { 01830 mMaster->sync(); 01831 } 01832 01833 void KConfigBase::virtual_hook( int, void* ) 01834 { /*BASE::virtual_hook( id, data );*/ } 01835 01836 void KConfigGroup::virtual_hook( int id, void* data ) 01837 { KConfigBase::virtual_hook( id, data ); } 01838 01839 bool KConfigBase::checkConfigFilesWritable(bool warnUser) 01840 { 01841 if (backEnd) 01842 return backEnd->checkConfigFilesWritable(warnUser); 01843 else 01844 return false; 01845 } 01846 01847 #include "kconfigbase.moc"
KDE Logo
This file is part of the documentation for kdecore Library Version 3.4.0.
Documentation copyright © 1996-2004 the KDE developers.
Generated on Tue Apr 12 22:47:32 2005 by doxygen 1.3.7 written by Dimitri van Heesch, © 1997-2003