00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
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
00122 aEntryKey.
bLocal =
true;
00123
KEntry entry = lookupData(aEntryKey);
00124
if (!entry.
mValue.
isNull())
00125
return true;
00126 aEntryKey.
bLocal =
false;
00127 }
00128
00129
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);
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);
00177
if (aEntryData.
bImmutable)
00178
return true;
00179
00180 entryKey.
bLocal =
true;
00181 aEntryData = lookupData(entryKey);
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
00213
00214
00215
00216
if (!bLocaleInitialized && KGlobal::_locale) {
00217
00218
KConfigBase *that = const_cast<KConfigBase *>(
this);
00219 that->
setLocale();
00220 }
00221
00222
QString aValue;
00223
00224
bool expand =
false;
00225
00226
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
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
00254
if( expand || bExpand )
00255 {
00256
00257
int nDollarPos = aValue.
find(
'$' );
00258
00259
while( nDollarPos != -1 && nDollarPos+1 < static_cast<int>(aValue.
length())) {
00260
00261
if( (aValue)[nDollarPos+1] ==
'(' ) {
00262 uint nEndPos = nDollarPos+1;
00263
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
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
00301
00302
00303 aValue.
replace( nDollarPos, nEndPos-nDollarPos, KStringHandler::from8Bit( pEnv ) );
00304 }
else
00305 aValue.
remove( nDollarPos, nEndPos-nDollarPos );
00306 }
else {
00307
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
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
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
00465
00466
00467
00468
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
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
00544
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
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
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
00753
if ( !aRetFont.
fromString( aValue ) && pDefault )
00754 aRetFont = *pDefault;
00755 }
00756
else {
00757
00758
00759
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
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
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
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
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
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
00937
int nIndex = aValue.
find(
',' );
00938
00939
if( nIndex == -1 ){
00940
00941
if( pDefault )
00942 aRetColor = *pDefault;
00943
return aRetColor;
00944 }
00945
00946 nRed = aValue.
left( nIndex ).toInt( &bOK );
00947
00948
00949
int nOldIndex = nIndex;
00950 nIndex = aValue.
find(
',', nOldIndex+1 );
00951
00952
if( nIndex == -1 ){
00953
00954
if( pDefault )
00955 aRetColor = *pDefault;
00956
return aRetColor;
00957 }
00958 nGreen = aValue.
mid( nOldIndex+1,
00959 nIndex-nOldIndex-1 ).toInt( &bOK );
00960
00961
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
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
01023
01024
01025
01026
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();
01038 aEntryData.
bGlobal = bGlobal;
01039 aEntryData.
bNLS = bNLS;
01040
01041
if (bPersistent)
01042 aEntryData.
bDirty =
true;
01043
01044
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
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
01081 path.
replace(
'$',
"$$");
01082
01083
bool startsWithFile = path.
startsWith(
"file:",
false);
01084
01085
01086
01087
if (!startsWithFile && path[0] !=
'/' ||
01088 startsWithFile && path[5] !=
'/')
01089
return path;
01090
01091
if (startsWithFile)
01092 path.remove(0,5);
01093
01094
01095
while (path[0] ==
'/' && path[1] ==
'/')
01096 path.remove(0,1);
01097
01098
01099
01100
01101
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
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
01162
01163
01164
01165
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
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
01189
return aEntryMap.
isEmpty();
01190 }
01191
01192
bool dirty =
false;
01193
bool checkGroup =
true;
01194
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
01336
01337
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 )
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
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);
01728 aEntryKey.
bLocal =
false;
01729 }
01730
01731
01732
KEntry entry =
lookupData(aEntryKey);
01733
if (entry.
mValue.
isNull())
01734 entry.
bDeleted =
true;
01735 entry.
bDirty =
true;
01736
putData(aEntryKey, entry,
true);
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
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
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;
01768 bLocaleInitialized =
true;
01769 bReadOnly = mMaster->
bReadOnly;
01770 bExpand =
false;
01771 bDirty =
false;
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;
01781 bLocaleInitialized =
true;
01782 bReadOnly = mMaster->
bReadOnly;
01783 bExpand =
false;
01784 bDirty =
false;
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;
01794 bLocaleInitialized =
true;
01795 bReadOnly = mMaster->
bReadOnly;
01796 bExpand =
false;
01797 bDirty =
false;
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 { }
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"