• Skip to content
  • Skip to link menu
KDE 4.3 API Reference
  • KDE API Reference
  • kdelibs
  • Sitemap
  • Contact Us
 

KDECore

kcoreconfigskeleton.cpp

Go to the documentation of this file.
00001 /*
00002     This file is part of KOrganizer.
00003     Copyright (c) 2000,2001 Cornelius Schumacher <schumacher@kde.org>
00004     Copyright (c) 2003 Waldo Bastian <bastian@kde.org>
00005 
00006     This library is free software; you can redistribute it and/or
00007     modify it under the terms of the GNU Library General Public
00008     License as published by the Free Software Foundation; either
00009     version 2 of the License, or (at your option) any later version.
00010 
00011     This library is distributed in the hope that it will be useful,
00012     but WITHOUT ANY WARRANTY; without even the implied warranty of
00013     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00014     Library General Public License for more details.
00015 
00016     You should have received a copy of the GNU Library General Public License
00017     along with this library; see the file COPYING.LIB.  If not, write to
00018     the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
00019     Boston, MA 02110-1301, USA.
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 ) // WABA: Is this test needed?
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 ) // WABA: Is this test needed?
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     //this might cause problems if the QVariants are not of default types
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 ) // WABA: Is this test needed?
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 ) // WABA: Is this test needed?
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 ) // WABA: Is this test needed?
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     //kDebug(177) << "Creating KCoreConfigSkeleton (" << (void *)this << ")";
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     //kDebug(177) << "Creating KCoreConfigSkeleton (" << (void *)this << ")";
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     // kDebug(177);
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 

KDECore

Skip menu "KDECore"
  • Main Page
  • Modules
  • Namespace List
  • Class Hierarchy
  • Alphabetical List
  • Class List
  • File List
  • Namespace Members
  • Class Members
  • Related Pages

kdelibs

Skip menu "kdelibs"
  • DNSSD
  • Interfaces
  •   KHexEdit
  •   KMediaPlayer
  •   KSpeech
  •   KTextEditor
  • Kate
  • kconf_update
  • KDE3Support
  •   KUnitTest
  • KDECore
  • KDED
  • KDEsu
  • KDEUI
  • KDocTools
  • KFile
  • KHTML
  • KImgIO
  • KInit
  • kio
  • KIOSlave
  • KJS
  •   KJS-API
  •   WTF
  • kjsembed
  • KNewStuff
  • KParts
  • KPty
  • Kross
  • KUtils
  • Nepomuk
  • Plasma
  • Solid
  • Sonnet
  • ThreadWeaver
Generated for kdelibs by doxygen 1.6.1
This website is maintained by Adriaan de Groot and Allen Winter.
KDE® and the K Desktop Environment® logo are registered trademarks of KDE e.V. | Legal