• Skip to content
  • Skip to link menu
KDE 4.1 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 
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 ) // WABA: Is this test needed?
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 ) // WABA: Is this test needed?
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     //this might cause problems if the QVariants are not of default types
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 ) // WABA: Is this test needed?
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 ) // WABA: Is this test needed?
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 ) // WABA: Is this test needed?
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 

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
  • Kross
  • KUtils
  • Nepomuk
  • Solid
  • Sonnet
  • ThreadWeaver
Generated for kdelibs by doxygen 1.5.4
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