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