00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022 #include "kcoreconfigskeleton.h"
00023 #include "kcoreconfigskeleton_p.h"
00024
00025 #include "kstandarddirs.h"
00026 #include "kglobal.h"
00027 #include "kdebug.h"
00028 #include "kstringhandler.h"
00029
00030
00031 KConfigSkeletonItem::KConfigSkeletonItem(const QString & _group,
00032 const QString & _key)
00033 : mGroup(_group)
00034 , mKey(_key)
00035 , d( new KConfigSkeletonItemPrivate )
00036 {
00037 }
00038
00039 KConfigSkeletonItem::~KConfigSkeletonItem()
00040 {
00041 delete d;
00042 }
00043
00044 void KConfigSkeletonItem::setGroup( const QString &_group )
00045 {
00046 mGroup = _group;
00047 }
00048
00049 QString KConfigSkeletonItem::group() const
00050 {
00051 return mGroup;
00052 }
00053
00054 void KConfigSkeletonItem::setKey( const QString &_key )
00055 {
00056 mKey = _key;
00057 }
00058
00059 QString KConfigSkeletonItem::key() const
00060 {
00061 return mKey;
00062 }
00063
00064 void KConfigSkeletonItem::setName(const QString &_name)
00065 {
00066 mName = _name;
00067 }
00068
00069 QString KConfigSkeletonItem::name() const
00070 {
00071 return mName;
00072 }
00073
00074 void KConfigSkeletonItem::setLabel( const QString &l )
00075 {
00076 d->mLabel = l;
00077 }
00078
00079 QString KConfigSkeletonItem::label() const
00080 {
00081 return d->mLabel;
00082 }
00083
00084 void KConfigSkeletonItem::setWhatsThis( const QString &w )
00085 {
00086 d->mWhatsThis = w;
00087 }
00088
00089 QString KConfigSkeletonItem::whatsThis() const
00090 {
00091 return d->mWhatsThis;
00092 }
00093
00094 QVariant KConfigSkeletonItem::minValue() const
00095 {
00096 return QVariant();
00097 }
00098
00099 QVariant KConfigSkeletonItem::maxValue() const
00100 {
00101 return QVariant();
00102 }
00103
00104 bool KConfigSkeletonItem::isImmutable() const
00105 {
00106 return d->mIsImmutable;
00107 }
00108
00109 void KConfigSkeletonItem::readImmutability( const KConfigGroup &group )
00110 {
00111 d->mIsImmutable = group.isEntryImmutable( mKey );
00112 }
00113
00114
00115 KCoreConfigSkeleton::ItemString::ItemString( const QString &_group, const QString &_key,
00116 QString &reference,
00117 const QString &defaultValue,
00118 Type type )
00119 : KConfigSkeletonGenericItem<QString>( _group, _key, reference, defaultValue ),
00120 mType( type )
00121 {
00122 }
00123
00124 void KCoreConfigSkeleton::ItemString::writeConfig( KConfig *config )
00125 {
00126 if ( mReference != mLoadedValue )
00127 {
00128 KConfigGroup cg(config, mGroup );
00129 if ((mDefault == mReference) && !cg.hasDefault( mKey))
00130 cg.revertToDefault( mKey );
00131 else if ( mType == Path )
00132 cg.writePathEntry( mKey, mReference );
00133 else if ( mType == Password )
00134 cg.writeEntry( mKey, KStringHandler::obscure( mReference ) );
00135 else
00136 cg.writeEntry( mKey, mReference );
00137 }
00138 }
00139
00140
00141 void KCoreConfigSkeleton::ItemString::readConfig( KConfig *config )
00142 {
00143 KConfigGroup cg(config, mGroup );
00144
00145 if ( mType == Path )
00146 {
00147 mReference = cg.readPathEntry( mKey, mDefault );
00148 }
00149 else if ( mType == Password )
00150 {
00151 QString val = cg.readEntry( mKey, KStringHandler::obscure( mDefault ) );
00152 mReference = KStringHandler::obscure( val );
00153 }
00154 else
00155 {
00156 mReference = cg.readEntry( mKey, mDefault );
00157 }
00158
00159 mLoadedValue = mReference;
00160
00161 readImmutability( cg );
00162 }
00163
00164 void KCoreConfigSkeleton::ItemString::setProperty(const QVariant & p)
00165 {
00166 mReference = p.toString();
00167 }
00168
00169 bool KCoreConfigSkeleton::ItemString::isEqual(const QVariant &v) const
00170 {
00171 return mReference == v.toString();
00172 }
00173
00174 QVariant KCoreConfigSkeleton::ItemString::property() const
00175 {
00176 return QVariant(mReference);
00177 }
00178
00179 KCoreConfigSkeleton::ItemPassword::ItemPassword( const QString &_group, const QString &_key,
00180 QString &reference,
00181 const QString &defaultValue)
00182 : ItemString( _group, _key, reference, defaultValue, Password )
00183 {
00184 }
00185
00186 KCoreConfigSkeleton::ItemPath::ItemPath( const QString &_group, const QString &_key,
00187 QString &reference,
00188 const QString &defaultValue)
00189 : ItemString( _group, _key, reference, defaultValue, Path )
00190 {
00191 }
00192
00193 KCoreConfigSkeleton::ItemUrl::ItemUrl( const QString &_group, const QString &_key,
00194 KUrl &reference,
00195 const KUrl &defaultValue )
00196 : KConfigSkeletonGenericItem<KUrl>( _group, _key, reference, defaultValue )
00197 {
00198 }
00199
00200 void KCoreConfigSkeleton::ItemUrl::writeConfig( KConfig *config )
00201 {
00202 if ( mReference != mLoadedValue )
00203 {
00204 KConfigGroup cg(config, mGroup );
00205 if ((mDefault == mReference) && !cg.hasDefault( mKey))
00206 cg.revertToDefault( mKey );
00207 else
00208 cg.writeEntry<QString>( mKey, mReference.url() );
00209 }
00210 }
00211
00212 void KCoreConfigSkeleton::ItemUrl::readConfig( KConfig *config )
00213 {
00214 KConfigGroup cg(config, mGroup );
00215
00216 mReference = KUrl( cg.readEntry<QString>( mKey, mDefault.url() ) );
00217 mLoadedValue = mReference;
00218
00219 readImmutability( cg );
00220 }
00221
00222 void KCoreConfigSkeleton::ItemUrl::setProperty(const QVariant & p)
00223 {
00224 mReference = qvariant_cast<KUrl>(p);
00225 }
00226
00227 bool KCoreConfigSkeleton::ItemUrl::isEqual(const QVariant &v) const
00228 {
00229 return mReference == qvariant_cast<KUrl>(v);
00230 }
00231
00232 QVariant KCoreConfigSkeleton::ItemUrl::property() const
00233 {
00234 return qVariantFromValue<KUrl>(mReference);
00235 }
00236
00237 KCoreConfigSkeleton::ItemProperty::ItemProperty( const QString &_group,
00238 const QString &_key,
00239 QVariant &reference,
00240 const QVariant &defaultValue )
00241 : KConfigSkeletonGenericItem<QVariant>( _group, _key, reference, defaultValue )
00242 {
00243 }
00244
00245 void KCoreConfigSkeleton::ItemProperty::readConfig( KConfig *config )
00246 {
00247 KConfigGroup cg(config, mGroup );
00248 mReference = cg.readEntry( mKey, mDefault );
00249 mLoadedValue = mReference;
00250
00251 readImmutability( cg );
00252 }
00253
00254 void KCoreConfigSkeleton::ItemProperty::setProperty(const QVariant & p)
00255 {
00256 mReference = p;
00257 }
00258
00259 bool KCoreConfigSkeleton::ItemProperty::isEqual(const QVariant &v) const
00260 {
00261
00262 return mReference == v;
00263 }
00264
00265 QVariant KCoreConfigSkeleton::ItemProperty::property() const
00266 {
00267 return mReference;
00268 }
00269
00270 KCoreConfigSkeleton::ItemBool::ItemBool( const QString &_group, const QString &_key,
00271 bool &reference, bool defaultValue )
00272 : KConfigSkeletonGenericItem<bool>( _group, _key, reference, defaultValue )
00273 {
00274 }
00275
00276 void KCoreConfigSkeleton::ItemBool::readConfig( KConfig *config )
00277 {
00278 KConfigGroup cg(config, mGroup );
00279 mReference = cg.readEntry( mKey, mDefault );
00280 mLoadedValue = mReference;
00281
00282 readImmutability( cg );
00283 }
00284
00285 void KCoreConfigSkeleton::ItemBool::setProperty(const QVariant & p)
00286 {
00287 mReference = p.toBool();
00288 }
00289
00290 bool KCoreConfigSkeleton::ItemBool::isEqual(const QVariant &v) const
00291 {
00292 return mReference == v.toBool();
00293 }
00294
00295 QVariant KCoreConfigSkeleton::ItemBool::property() const
00296 {
00297 return QVariant( mReference );
00298 }
00299
00300
00301 KCoreConfigSkeleton::ItemInt::ItemInt( const QString &_group, const QString &_key,
00302 qint32 &reference, qint32 defaultValue )
00303 : KConfigSkeletonGenericItem<qint32>( _group, _key, reference, defaultValue )
00304 ,mHasMin(false), mHasMax(false)
00305 {
00306 }
00307
00308 void KCoreConfigSkeleton::ItemInt::readConfig( KConfig *config )
00309 {
00310 KConfigGroup cg(config, mGroup );
00311 mReference = cg.readEntry( mKey, mDefault );
00312 if (mHasMin)
00313 mReference = qMax(mReference, mMin);
00314 if (mHasMax)
00315 mReference = qMin(mReference, mMax);
00316 mLoadedValue = mReference;
00317
00318 readImmutability( cg );
00319 }
00320
00321 void KCoreConfigSkeleton::ItemInt::setProperty(const QVariant & p)
00322 {
00323 mReference = p.toInt();
00324 }
00325
00326 bool KCoreConfigSkeleton::ItemInt::isEqual(const QVariant &v) const
00327 {
00328 return mReference == v.toInt();
00329 }
00330
00331 QVariant KCoreConfigSkeleton::ItemInt::property() const
00332 {
00333 return QVariant(mReference);
00334 }
00335
00336 QVariant KCoreConfigSkeleton::ItemInt::minValue() const
00337 {
00338 if (mHasMin)
00339 return QVariant(mMin);
00340 return QVariant();
00341 }
00342
00343 QVariant KCoreConfigSkeleton::ItemInt::maxValue() const
00344 {
00345 if (mHasMax)
00346 return QVariant(mMax);
00347 return QVariant();
00348 }
00349
00350 void KCoreConfigSkeleton::ItemInt::setMinValue(qint32 v)
00351 {
00352 mHasMin = true;
00353 mMin = v;
00354 }
00355
00356 void KCoreConfigSkeleton::ItemInt::setMaxValue(qint32 v)
00357 {
00358 mHasMax = true;
00359 mMax = v;
00360 }
00361
00362
00363 KCoreConfigSkeleton::ItemLongLong::ItemLongLong( const QString &_group, const QString &_key,
00364 qint64 &reference, qint64 defaultValue )
00365 : KConfigSkeletonGenericItem<qint64>( _group, _key, reference, defaultValue )
00366 ,mHasMin(false), mHasMax(false)
00367 {
00368 }
00369
00370 void KCoreConfigSkeleton::ItemLongLong::readConfig( KConfig *config )
00371 {
00372 KConfigGroup cg(config, mGroup );
00373 mReference = cg.readEntry( mKey, mDefault );
00374 if (mHasMin)
00375 mReference = qMax(mReference, mMin);
00376 if (mHasMax)
00377 mReference = qMin(mReference, mMax);
00378 mLoadedValue = mReference;
00379
00380 readImmutability( cg );
00381 }
00382
00383 void KCoreConfigSkeleton::ItemLongLong::setProperty(const QVariant & p)
00384 {
00385 mReference = p.toLongLong();
00386 }
00387
00388 bool KCoreConfigSkeleton::ItemLongLong::isEqual(const QVariant &v) const
00389 {
00390 return mReference == v.toLongLong();
00391 }
00392
00393 QVariant KCoreConfigSkeleton::ItemLongLong::property() const
00394 {
00395 return QVariant(mReference);
00396 }
00397
00398 QVariant KCoreConfigSkeleton::ItemLongLong::minValue() const
00399 {
00400 if (mHasMin)
00401 return QVariant(mMin);
00402 return QVariant();
00403 }
00404
00405 QVariant KCoreConfigSkeleton::ItemLongLong::maxValue() const
00406 {
00407 if (mHasMax)
00408 return QVariant(mMax);
00409 return QVariant();
00410 }
00411
00412 void KCoreConfigSkeleton::ItemLongLong::setMinValue(qint64 v)
00413 {
00414 mHasMin = true;
00415 mMin = v;
00416 }
00417
00418 void KCoreConfigSkeleton::ItemLongLong::setMaxValue(qint64 v)
00419 {
00420 mHasMax = true;
00421 mMax = v;
00422 }
00423
00424 KCoreConfigSkeleton::ItemEnum::ItemEnum( const QString &_group, const QString &_key,
00425 qint32 &reference,
00426 const QList<Choice> &choices,
00427 qint32 defaultValue )
00428 : ItemInt( _group, _key, reference, defaultValue ), mChoices( choices )
00429 {
00430 }
00431
00432 void KCoreConfigSkeleton::ItemEnum::readConfig( KConfig *config )
00433 {
00434 KConfigGroup cg(config, mGroup );
00435 if (!cg.hasKey(mKey))
00436 {
00437 mReference = mDefault;
00438 }
00439 else
00440 {
00441 int i = 0;
00442 mReference = -1;
00443 QString tmp = cg.readEntry( mKey, QString() ).toLower();
00444 for(QList<Choice>::ConstIterator it = mChoices.begin();
00445 it != mChoices.end(); ++it, ++i)
00446 {
00447 if ((*it).name.toLower() == tmp)
00448 {
00449 mReference = i;
00450 break;
00451 }
00452 }
00453 if (mReference == -1)
00454 mReference = cg.readEntry( mKey, mDefault );
00455 }
00456 mLoadedValue = mReference;
00457
00458 readImmutability( cg );
00459 }
00460
00461 void KCoreConfigSkeleton::ItemEnum::writeConfig( KConfig *config )
00462 {
00463 if ( mReference != mLoadedValue )
00464 {
00465 KConfigGroup cg(config, mGroup );
00466 if ((mDefault == mReference) && !cg.hasDefault( mKey))
00467 cg.revertToDefault( mKey );
00468 else if ((mReference >= 0) && (mReference < (int) mChoices.count()))
00469 cg.writeEntry( mKey, mChoices[mReference].name );
00470 else
00471 cg.writeEntry( mKey, mReference );
00472 }
00473 }
00474
00475 QList<KCoreConfigSkeleton::ItemEnum::Choice> KCoreConfigSkeleton::ItemEnum::choices() const
00476 {
00477 return mChoices;
00478 }
00479
00480
00481 KCoreConfigSkeleton::ItemUInt::ItemUInt( const QString &_group, const QString &_key,
00482 quint32 &reference,
00483 quint32 defaultValue )
00484 : KConfigSkeletonGenericItem<quint32>( _group, _key, reference, defaultValue )
00485 ,mHasMin(false), mHasMax(false)
00486 {
00487 }
00488
00489 void KCoreConfigSkeleton::ItemUInt::readConfig( KConfig *config )
00490 {
00491 KConfigGroup cg(config, mGroup );
00492 mReference = cg.readEntry( mKey, mDefault );
00493 if (mHasMin)
00494 mReference = qMax(mReference, mMin);
00495 if (mHasMax)
00496 mReference = qMin(mReference, mMax);
00497 mLoadedValue = mReference;
00498
00499 readImmutability( cg );
00500 }
00501
00502 void KCoreConfigSkeleton::ItemUInt::setProperty(const QVariant & p)
00503 {
00504 mReference = p.toUInt();
00505 }
00506
00507 bool KCoreConfigSkeleton::ItemUInt::isEqual(const QVariant &v) const
00508 {
00509 return mReference == v.toUInt();
00510 }
00511
00512 QVariant KCoreConfigSkeleton::ItemUInt::property() const
00513 {
00514 return QVariant(mReference);
00515 }
00516
00517 QVariant KCoreConfigSkeleton::ItemUInt::minValue() const
00518 {
00519 if (mHasMin)
00520 return QVariant(mMin);
00521 return QVariant();
00522 }
00523
00524 QVariant KCoreConfigSkeleton::ItemUInt::maxValue() const
00525 {
00526 if (mHasMax)
00527 return QVariant(mMax);
00528 return QVariant();
00529 }
00530
00531 void KCoreConfigSkeleton::ItemUInt::setMinValue(quint32 v)
00532 {
00533 mHasMin = true;
00534 mMin = v;
00535 }
00536
00537 void KCoreConfigSkeleton::ItemUInt::setMaxValue(quint32 v)
00538 {
00539 mHasMax = true;
00540 mMax = v;
00541 }
00542
00543
00544 KCoreConfigSkeleton::ItemULongLong::ItemULongLong( const QString &_group, const QString &_key,
00545 quint64 &reference, quint64 defaultValue )
00546 : KConfigSkeletonGenericItem<quint64>( _group, _key, reference, defaultValue )
00547 ,mHasMin(false), mHasMax(false)
00548 {
00549 }
00550
00551 void KCoreConfigSkeleton::ItemULongLong::readConfig( KConfig *config )
00552 {
00553 KConfigGroup cg(config, mGroup );
00554 mReference = cg.readEntry( mKey, mDefault );
00555 if (mHasMin)
00556 mReference = qMax(mReference, mMin);
00557 if (mHasMax)
00558 mReference = qMin(mReference, mMax);
00559 mLoadedValue = mReference;
00560
00561 readImmutability( cg );
00562 }
00563
00564 void KCoreConfigSkeleton::ItemULongLong::setProperty(const QVariant & p)
00565 {
00566 mReference = p.toULongLong();
00567 }
00568
00569 bool KCoreConfigSkeleton::ItemULongLong::isEqual(const QVariant &v) const
00570 {
00571 return mReference == v.toULongLong();
00572 }
00573
00574 QVariant KCoreConfigSkeleton::ItemULongLong::property() const
00575 {
00576 return QVariant(mReference);
00577 }
00578
00579 QVariant KCoreConfigSkeleton::ItemULongLong::minValue() const
00580 {
00581 if (mHasMin)
00582 return QVariant(mMin);
00583 return QVariant();
00584 }
00585
00586 QVariant KCoreConfigSkeleton::ItemULongLong::maxValue() const
00587 {
00588 if (mHasMax)
00589 return QVariant(mMax);
00590 return QVariant();
00591 }
00592
00593 void KCoreConfigSkeleton::ItemULongLong::setMinValue(quint64 v)
00594 {
00595 mHasMin = true;
00596 mMin = v;
00597 }
00598
00599 void KCoreConfigSkeleton::ItemULongLong::setMaxValue(quint64 v)
00600 {
00601 mHasMax = true;
00602 mMax = v;
00603 }
00604
00605 KCoreConfigSkeleton::ItemDouble::ItemDouble( const QString &_group, const QString &_key,
00606 double &reference, double defaultValue )
00607 : KConfigSkeletonGenericItem<double>( _group, _key, reference, defaultValue )
00608 ,mHasMin(false), mHasMax(false)
00609 {
00610 }
00611
00612 void KCoreConfigSkeleton::ItemDouble::readConfig( KConfig *config )
00613 {
00614 KConfigGroup cg(config, mGroup );
00615 mReference = cg.readEntry( mKey, mDefault );
00616 if (mHasMin)
00617 mReference = qMax(mReference, mMin);
00618 if (mHasMax)
00619 mReference = qMin(mReference, mMax);
00620 mLoadedValue = mReference;
00621
00622 readImmutability( cg );
00623 }
00624
00625 void KCoreConfigSkeleton::ItemDouble::setProperty(const QVariant & p)
00626 {
00627 mReference = p.toDouble();
00628 }
00629
00630 bool KCoreConfigSkeleton::ItemDouble::isEqual(const QVariant &v) const
00631 {
00632 return mReference == v.toDouble();
00633 }
00634
00635 QVariant KCoreConfigSkeleton::ItemDouble::property() const
00636 {
00637 return QVariant(mReference);
00638 }
00639
00640 QVariant KCoreConfigSkeleton::ItemDouble::minValue() const
00641 {
00642 if (mHasMin)
00643 return QVariant(mMin);
00644 return QVariant();
00645 }
00646
00647 QVariant KCoreConfigSkeleton::ItemDouble::maxValue() const
00648 {
00649 if (mHasMax)
00650 return QVariant(mMax);
00651 return QVariant();
00652 }
00653
00654 void KCoreConfigSkeleton::ItemDouble::setMinValue(double v)
00655 {
00656 mHasMin = true;
00657 mMin = v;
00658 }
00659
00660 void KCoreConfigSkeleton::ItemDouble::setMaxValue(double v)
00661 {
00662 mHasMax = true;
00663 mMax = v;
00664 }
00665
00666
00667 KCoreConfigSkeleton::ItemRect::ItemRect( const QString &_group, const QString &_key,
00668 QRect &reference,
00669 const QRect &defaultValue )
00670 : KConfigSkeletonGenericItem<QRect>( _group, _key, reference, defaultValue )
00671 {
00672 }
00673
00674 void KCoreConfigSkeleton::ItemRect::readConfig( KConfig *config )
00675 {
00676 KConfigGroup cg(config, mGroup );
00677 mReference = cg.readEntry( mKey, mDefault );
00678 mLoadedValue = mReference;
00679
00680 readImmutability( cg );
00681 }
00682
00683 void KCoreConfigSkeleton::ItemRect::setProperty(const QVariant & p)
00684 {
00685 mReference = p.toRect();
00686 }
00687
00688 bool KCoreConfigSkeleton::ItemRect::isEqual(const QVariant &v) const
00689 {
00690 return mReference == v.toRect();
00691 }
00692
00693 QVariant KCoreConfigSkeleton::ItemRect::property() const
00694 {
00695 return QVariant(mReference);
00696 }
00697
00698
00699 KCoreConfigSkeleton::ItemPoint::ItemPoint( const QString &_group, const QString &_key,
00700 QPoint &reference,
00701 const QPoint &defaultValue )
00702 : KConfigSkeletonGenericItem<QPoint>( _group, _key, reference, defaultValue )
00703 {
00704 }
00705
00706 void KCoreConfigSkeleton::ItemPoint::readConfig( KConfig *config )
00707 {
00708 KConfigGroup cg(config, mGroup );
00709 mReference = cg.readEntry( mKey, mDefault );
00710 mLoadedValue = mReference;
00711
00712 readImmutability( cg );
00713 }
00714
00715 void KCoreConfigSkeleton::ItemPoint::setProperty(const QVariant & p)
00716 {
00717 mReference = p.toPoint();
00718 }
00719
00720 bool KCoreConfigSkeleton::ItemPoint::isEqual(const QVariant &v) const
00721 {
00722 return mReference == v.toPoint();
00723 }
00724
00725 QVariant KCoreConfigSkeleton::ItemPoint::property() const
00726 {
00727 return QVariant(mReference);
00728 }
00729
00730
00731 KCoreConfigSkeleton::ItemSize::ItemSize( const QString &_group, const QString &_key,
00732 QSize &reference,
00733 const QSize &defaultValue )
00734 : KConfigSkeletonGenericItem<QSize>( _group, _key, reference, defaultValue )
00735 {
00736 }
00737
00738 void KCoreConfigSkeleton::ItemSize::readConfig( KConfig *config )
00739 {
00740 KConfigGroup cg(config, mGroup );
00741 mReference = cg.readEntry( mKey, mDefault );
00742 mLoadedValue = mReference;
00743
00744 readImmutability( cg );
00745 }
00746
00747 void KCoreConfigSkeleton::ItemSize::setProperty(const QVariant & p)
00748 {
00749 mReference = p.toSize();
00750 }
00751
00752 bool KCoreConfigSkeleton::ItemSize::isEqual(const QVariant &v) const
00753 {
00754 return mReference == v.toSize();
00755 }
00756
00757 QVariant KCoreConfigSkeleton::ItemSize::property() const
00758 {
00759 return QVariant(mReference);
00760 }
00761
00762
00763 KCoreConfigSkeleton::ItemDateTime::ItemDateTime( const QString &_group, const QString &_key,
00764 QDateTime &reference,
00765 const QDateTime &defaultValue )
00766 : KConfigSkeletonGenericItem<QDateTime>( _group, _key, reference, defaultValue )
00767 {
00768 }
00769
00770 void KCoreConfigSkeleton::ItemDateTime::readConfig( KConfig *config )
00771 {
00772 KConfigGroup cg(config, mGroup );
00773 mReference = cg.readEntry( mKey, mDefault );
00774 mLoadedValue = mReference;
00775
00776 readImmutability( cg );
00777 }
00778
00779 void KCoreConfigSkeleton::ItemDateTime::setProperty(const QVariant & p)
00780 {
00781 mReference = p.toDateTime();
00782 }
00783
00784 bool KCoreConfigSkeleton::ItemDateTime::isEqual(const QVariant &v) const
00785 {
00786 return mReference == v.toDateTime();
00787 }
00788
00789 QVariant KCoreConfigSkeleton::ItemDateTime::property() const
00790 {
00791 return QVariant(mReference);
00792 }
00793
00794
00795 KCoreConfigSkeleton::ItemStringList::ItemStringList( const QString &_group, const QString &_key,
00796 QStringList &reference,
00797 const QStringList &defaultValue )
00798 : KConfigSkeletonGenericItem<QStringList>( _group, _key, reference, defaultValue )
00799 {
00800 }
00801
00802 void KCoreConfigSkeleton::ItemStringList::readConfig( KConfig *config )
00803 {
00804 KConfigGroup cg(config, mGroup );
00805 if ( !cg.hasKey( mKey ) )
00806 mReference = mDefault;
00807 else
00808 mReference = cg.readEntry( mKey, mDefault );
00809 mLoadedValue = mReference;
00810
00811 readImmutability( cg );
00812 }
00813
00814 void KCoreConfigSkeleton::ItemStringList::setProperty(const QVariant & p)
00815 {
00816 mReference = p.toStringList();
00817 }
00818
00819 bool KCoreConfigSkeleton::ItemStringList::isEqual(const QVariant &v) const
00820 {
00821 return mReference == v.toStringList();
00822 }
00823
00824 QVariant KCoreConfigSkeleton::ItemStringList::property() const
00825 {
00826 return QVariant(mReference);
00827 }
00828
00829
00830 KCoreConfigSkeleton::ItemPathList::ItemPathList( const QString &_group, const QString &_key,
00831 QStringList &reference,
00832 const QStringList &defaultValue )
00833 : ItemStringList( _group, _key, reference, defaultValue )
00834 {
00835 }
00836
00837 void KCoreConfigSkeleton::ItemPathList::readConfig( KConfig *config )
00838 {
00839 KConfigGroup cg(config, mGroup );
00840 if ( !cg.hasKey( mKey ) )
00841 mReference = mDefault;
00842 else
00843 mReference = cg.readPathEntry( mKey, QStringList() );
00844 mLoadedValue = mReference;
00845
00846 readImmutability( cg );
00847 }
00848
00849 void KCoreConfigSkeleton::ItemPathList::writeConfig( KConfig *config )
00850 {
00851 if ( mReference != mLoadedValue )
00852 {
00853 KConfigGroup cg(config, mGroup );
00854 if ((mDefault == mReference) && !cg.hasDefault( mKey))
00855 cg.revertToDefault( mKey );
00856 else {
00857 QStringList sl = mReference;
00858 cg.writePathEntry( mKey, sl );
00859 }
00860 }
00861 }
00862
00863 KCoreConfigSkeleton::ItemUrlList::ItemUrlList( const QString &_group, const QString &_key,
00864 KUrl::List &reference,
00865 const KUrl::List &defaultValue )
00866 : KConfigSkeletonGenericItem<KUrl::List>( _group, _key, reference, defaultValue )
00867 {
00868 }
00869
00870 void KCoreConfigSkeleton::ItemUrlList::readConfig( KConfig *config )
00871 {
00872 KConfigGroup cg(config, mGroup );
00873 if ( !cg.hasKey( mKey ) )
00874 mReference = mDefault;
00875 else
00876 mReference = KUrl::List( cg.readEntry<QStringList>( mKey, mDefault.toStringList() ) );
00877 mLoadedValue = mReference;
00878
00879 readImmutability( cg );
00880 }
00881
00882 void KCoreConfigSkeleton::ItemUrlList::writeConfig( KConfig *config )
00883 {
00884 if ( mReference != mLoadedValue )
00885 {
00886 KConfigGroup cg(config, mGroup );
00887 if ((mDefault == mReference) && !cg.hasDefault( mKey))
00888 cg.revertToDefault( mKey );
00889 else
00890 cg.writeEntry<QStringList>( mKey, mReference.toStringList() );
00891 }
00892 }
00893
00894 void KCoreConfigSkeleton::ItemUrlList::setProperty(const QVariant & p)
00895 {
00896 mReference = qvariant_cast<KUrl::List>(p);
00897 }
00898
00899 bool KCoreConfigSkeleton::ItemUrlList::isEqual(const QVariant &v) const
00900 {
00901 return mReference == qvariant_cast<KUrl::List>(v);
00902 }
00903
00904 QVariant KCoreConfigSkeleton::ItemUrlList::property() const
00905 {
00906 return qVariantFromValue<KUrl::List>(mReference);
00907 }
00908
00909 Q_DECLARE_METATYPE( QList<int> )
00910
00911 KCoreConfigSkeleton::ItemIntList::ItemIntList( const QString &_group, const QString &_key,
00912 QList<int> &reference,
00913 const QList<int> &defaultValue )
00914 : KConfigSkeletonGenericItem<QList<int> >( _group, _key, reference, defaultValue )
00915 {
00916 }
00917
00918 void KCoreConfigSkeleton::ItemIntList::readConfig( KConfig *config )
00919 {
00920 KConfigGroup cg(config, mGroup );
00921 if ( !cg.hasKey( mKey ) )
00922 mReference = mDefault;
00923 else
00924 mReference = cg.readEntry( mKey , mDefault );
00925 mLoadedValue = mReference;
00926
00927 readImmutability( cg );
00928 }
00929
00930 void KCoreConfigSkeleton::ItemIntList::setProperty(const QVariant &p)
00931 {
00932 mReference = qvariant_cast< QList<int> >(p);
00933 }
00934
00935 bool KCoreConfigSkeleton::ItemIntList::isEqual(const QVariant &v) const
00936 {
00937 return mReference == qvariant_cast< QList<int> >(v);
00938 }
00939
00940 QVariant KCoreConfigSkeleton::ItemIntList::property() const
00941 {
00942 return qVariantFromValue< QList<int> >(mReference);
00943 }
00944
00945
00946
00947 KCoreConfigSkeleton::KCoreConfigSkeleton(const QString &configname, QObject* parent)
00948 : QObject(parent),
00949 d( new Private )
00950 {
00951 kDebug(177) << "Creating KCoreConfigSkeleton (" << (void *)this << ")";
00952
00953 if ( !configname.isEmpty() )
00954 {
00955 d->mConfig = KSharedConfig::openConfig( configname );
00956 }
00957 else
00958 {
00959 d->mConfig = KGlobal::config();
00960 }
00961 }
00962
00963 KCoreConfigSkeleton::KCoreConfigSkeleton(KSharedConfig::Ptr pConfig, QObject* parent)
00964 : QObject(parent),
00965 d( new Private )
00966 {
00967 kDebug(177) << "Creating KCoreConfigSkeleton (" << (void *)this << ")";
00968 d->mConfig = pConfig;
00969 }
00970
00971
00972 KCoreConfigSkeleton::~KCoreConfigSkeleton()
00973 {
00974 delete d;
00975 }
00976
00977 void KCoreConfigSkeleton::setCurrentGroup( const QString &group )
00978 {
00979 d->mCurrentGroup = group;
00980 }
00981
00982 QString KCoreConfigSkeleton::currentGroup() const
00983 {
00984 return d->mCurrentGroup;
00985 }
00986
00987 KConfig *KCoreConfigSkeleton::config()
00988 {
00989 return d->mConfig.data();
00990 }
00991
00992 const KConfig *KCoreConfigSkeleton::config() const
00993 {
00994 return d->mConfig.data();
00995 }
00996
00997 void KCoreConfigSkeleton::setSharedConfig(KSharedConfig::Ptr pConfig)
00998 {
00999 d->mConfig = pConfig;
01000 }
01001
01002 KConfigSkeletonItem::List KCoreConfigSkeleton::items() const
01003 {
01004 return d->mItems;
01005 }
01006
01007 bool KCoreConfigSkeleton::useDefaults(bool b)
01008 {
01009 if (b == d->mUseDefaults)
01010 return d->mUseDefaults;
01011
01012 d->mUseDefaults = b;
01013 KConfigSkeletonItem::List::ConstIterator it;
01014 for( it = d->mItems.begin(); it != d->mItems.end(); ++it )
01015 {
01016 (*it)->swapDefault();
01017 }
01018 usrUseDefaults(b);
01019 return !d->mUseDefaults;
01020 }
01021
01022 void KCoreConfigSkeleton::setDefaults()
01023 {
01024 KConfigSkeletonItem::List::ConstIterator it;
01025 for( it = d->mItems.begin(); it != d->mItems.end(); ++it ) {
01026 (*it)->setDefault();
01027 }
01028 usrSetDefaults();
01029 }
01030
01031 void KCoreConfigSkeleton::readConfig()
01032 {
01033 kDebug(177) << "KCoreConfigSkeleton::readConfig()";
01034 d->mConfig->reparseConfiguration();
01035 KConfigSkeletonItem::List::ConstIterator it;
01036 for( it = d->mItems.begin(); it != d->mItems.end(); ++it )
01037 {
01038 (*it)->readConfig( d->mConfig.data() );
01039 }
01040 usrReadConfig();
01041 }
01042
01043 void KCoreConfigSkeleton::writeConfig()
01044 {
01045 kDebug(177) << "KCoreConfigSkeleton::writeConfig()";
01046 KConfigSkeletonItem::List::ConstIterator it;
01047 for( it = d->mItems.begin(); it != d->mItems.end(); ++it )
01048 {
01049 (*it)->writeConfig( d->mConfig.data() );
01050 }
01051 usrWriteConfig();
01052
01053 d->mConfig->sync();
01054
01055 readConfig();
01056
01057 emit configChanged();
01058 }
01059
01060 bool KCoreConfigSkeleton::usrUseDefaults(bool)
01061 {
01062 return false;
01063 }
01064
01065 void KCoreConfigSkeleton::usrSetDefaults()
01066 {
01067 }
01068
01069 void KCoreConfigSkeleton::usrReadConfig()
01070 {
01071 }
01072
01073 void KCoreConfigSkeleton::usrWriteConfig()
01074 {
01075 }
01076
01077 void KCoreConfigSkeleton::addItem( KConfigSkeletonItem *item, const QString &name )
01078 {
01079 item->setName( name.isEmpty() ? item->key() : name );
01080 d->mItems.append( item );
01081 d->mItemDict.insert( item->name(), item );
01082 item->readDefault( d->mConfig.data() );
01083 item->readConfig( d->mConfig.data() );
01084 }
01085
01086 KCoreConfigSkeleton::ItemString *KCoreConfigSkeleton::addItemString( const QString &name, QString &reference,
01087 const QString &defaultValue, const QString &key )
01088 {
01089 KCoreConfigSkeleton::ItemString *item;
01090 item = new KCoreConfigSkeleton::ItemString( d->mCurrentGroup, key.isEmpty() ? name : key,
01091 reference, defaultValue,
01092 KCoreConfigSkeleton::ItemString::Normal );
01093 addItem( item, name );
01094 return item;
01095 }
01096
01097 KCoreConfigSkeleton::ItemPassword *KCoreConfigSkeleton::addItemPassword( const QString &name, QString &reference,
01098 const QString &defaultValue, const QString &key )
01099 {
01100 KCoreConfigSkeleton::ItemPassword *item;
01101 item = new KCoreConfigSkeleton::ItemPassword( d->mCurrentGroup, key.isNull() ? name : key,
01102 reference, defaultValue );
01103 addItem( item, name );
01104 return item;
01105 }
01106
01107 KCoreConfigSkeleton::ItemPath *KCoreConfigSkeleton::addItemPath( const QString &name, QString &reference,
01108 const QString &defaultValue, const QString &key )
01109 {
01110 KCoreConfigSkeleton::ItemPath *item;
01111 item = new KCoreConfigSkeleton::ItemPath( d->mCurrentGroup, key.isNull() ? name : key,
01112 reference, defaultValue );
01113 addItem( item, name );
01114 return item;
01115 }
01116
01117 KCoreConfigSkeleton::ItemProperty *KCoreConfigSkeleton::addItemProperty( const QString &name, QVariant &reference,
01118 const QVariant &defaultValue, const QString &key )
01119 {
01120 KCoreConfigSkeleton::ItemProperty *item;
01121 item = new KCoreConfigSkeleton::ItemProperty( d->mCurrentGroup, key.isNull() ? name : key,
01122 reference, defaultValue );
01123 addItem( item, name );
01124 return item;
01125 }
01126
01127 KCoreConfigSkeleton::ItemBool *KCoreConfigSkeleton::addItemBool( const QString &name, bool &reference,
01128 bool defaultValue, const QString &key )
01129 {
01130 KCoreConfigSkeleton::ItemBool *item;
01131 item = new KCoreConfigSkeleton::ItemBool( d->mCurrentGroup, key.isNull() ? name : key,
01132 reference, defaultValue );
01133 addItem( item, name );
01134 return item;
01135 }
01136
01137 KCoreConfigSkeleton::ItemInt *KCoreConfigSkeleton::addItemInt( const QString &name, qint32 &reference,
01138 qint32 defaultValue, const QString &key )
01139 {
01140 KCoreConfigSkeleton::ItemInt *item;
01141 item = new KCoreConfigSkeleton::ItemInt( d->mCurrentGroup, key.isNull() ? name : key,
01142 reference, defaultValue );
01143 addItem( item, name );
01144 return item;
01145 }
01146
01147 KCoreConfigSkeleton::ItemUInt *KCoreConfigSkeleton::addItemUInt( const QString &name, quint32 &reference,
01148 quint32 defaultValue, const QString &key )
01149 {
01150 KCoreConfigSkeleton::ItemUInt *item;
01151 item = new KCoreConfigSkeleton::ItemUInt( d->mCurrentGroup, key.isNull() ? name : key,
01152 reference, defaultValue );
01153 addItem( item, name );
01154 return item;
01155 }
01156
01157 KCoreConfigSkeleton::ItemLongLong *KCoreConfigSkeleton::addItemLongLong( const QString &name, qint64 &reference,
01158 qint64 defaultValue, const QString &key )
01159 {
01160 KCoreConfigSkeleton::ItemLongLong *item;
01161 item = new KCoreConfigSkeleton::ItemLongLong( d->mCurrentGroup, key.isNull() ? name : key,
01162 reference, defaultValue );
01163 addItem( item, name );
01164 return item;
01165 }
01166
01167 KCoreConfigSkeleton::ItemLongLong *KCoreConfigSkeleton::addItemInt64(
01168 const QString& name,
01169 qint64 &reference,
01170 qint64 defaultValue,
01171 const QString & key)
01172 {
01173 return addItemLongLong(name, reference, defaultValue, key);
01174 }
01175
01176 KCoreConfigSkeleton::ItemULongLong *KCoreConfigSkeleton::addItemULongLong( const QString &name, quint64 &reference,
01177 quint64 defaultValue, const QString &key )
01178 {
01179 KCoreConfigSkeleton::ItemULongLong *item;
01180 item = new KCoreConfigSkeleton::ItemULongLong( d->mCurrentGroup, key.isNull() ? name : key,
01181 reference, defaultValue );
01182 addItem( item, name );
01183 return item;
01184 }
01185
01186 KCoreConfigSkeleton::ItemULongLong *KCoreConfigSkeleton::addItemUInt64(
01187 const QString & name,
01188 quint64 &reference,
01189 quint64 defaultValue,
01190 const QString & key)
01191 {
01192 return addItemULongLong(name, reference, defaultValue, key);
01193 }
01194
01195 KCoreConfigSkeleton::ItemDouble *KCoreConfigSkeleton::addItemDouble( const QString &name, double &reference,
01196 double defaultValue, const QString &key )
01197 {
01198 KCoreConfigSkeleton::ItemDouble *item;
01199 item = new KCoreConfigSkeleton::ItemDouble( d->mCurrentGroup, key.isNull() ? name : key,
01200 reference, defaultValue );
01201 addItem( item, name );
01202 return item;
01203 }
01204
01205 KCoreConfigSkeleton::ItemRect *KCoreConfigSkeleton::addItemRect( const QString &name, QRect &reference,
01206 const QRect &defaultValue, const QString &key )
01207 {
01208 KCoreConfigSkeleton::ItemRect *item;
01209 item = new KCoreConfigSkeleton::ItemRect( d->mCurrentGroup, key.isNull() ? name : key,
01210 reference, defaultValue );
01211 addItem( item, name );
01212 return item;
01213 }
01214
01215 KCoreConfigSkeleton::ItemPoint *KCoreConfigSkeleton::addItemPoint( const QString &name, QPoint &reference,
01216 const QPoint &defaultValue, const QString &key )
01217 {
01218 KCoreConfigSkeleton::ItemPoint *item;
01219 item = new KCoreConfigSkeleton::ItemPoint( d->mCurrentGroup, key.isNull() ? name : key,
01220 reference, defaultValue );
01221 addItem( item, name );
01222 return item;
01223 }
01224
01225 KCoreConfigSkeleton::ItemSize *KCoreConfigSkeleton::addItemSize( const QString &name, QSize &reference,
01226 const QSize &defaultValue, const QString &key )
01227 {
01228 KCoreConfigSkeleton::ItemSize *item;
01229 item = new KCoreConfigSkeleton::ItemSize( d->mCurrentGroup, key.isNull() ? name : key,
01230 reference, defaultValue );
01231 addItem( item, name );
01232 return item;
01233 }
01234
01235 KCoreConfigSkeleton::ItemDateTime *KCoreConfigSkeleton::addItemDateTime( const QString &name, QDateTime &reference,
01236 const QDateTime &defaultValue, const QString &key )
01237 {
01238 KCoreConfigSkeleton::ItemDateTime *item;
01239 item = new KCoreConfigSkeleton::ItemDateTime( d->mCurrentGroup, key.isNull() ? name : key,
01240 reference, defaultValue );
01241 addItem( item, name );
01242 return item;
01243 }
01244
01245 KCoreConfigSkeleton::ItemStringList *KCoreConfigSkeleton::addItemStringList( const QString &name, QStringList &reference,
01246 const QStringList &defaultValue, const QString &key )
01247 {
01248 KCoreConfigSkeleton::ItemStringList *item;
01249 item = new KCoreConfigSkeleton::ItemStringList( d->mCurrentGroup, key.isNull() ? name : key,
01250 reference, defaultValue );
01251 addItem( item, name );
01252 return item;
01253 }
01254
01255 KCoreConfigSkeleton::ItemIntList *KCoreConfigSkeleton::addItemIntList( const QString &name, QList<int> &reference,
01256 const QList<int> &defaultValue, const QString &key )
01257 {
01258 KCoreConfigSkeleton::ItemIntList *item;
01259 item = new KCoreConfigSkeleton::ItemIntList( d->mCurrentGroup, key.isNull() ? name : key,
01260 reference, defaultValue );
01261 addItem( item, name );
01262 return item;
01263 }
01264
01265 bool KCoreConfigSkeleton::isImmutable(const QString &name)
01266 {
01267 KConfigSkeletonItem *item = findItem(name);
01268 return !item || item->isImmutable();
01269 }
01270
01271 KConfigSkeletonItem *KCoreConfigSkeleton::findItem(const QString &name)
01272 {
01273 return d->mItemDict.value(name);
01274 }
01275
01276 #include "kcoreconfigskeleton.moc"
01277