• Skip to content
  • Skip to link menu
Trinity API Reference
  • Trinity API Reference
  • tdecore
 

tdecore

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

tdecore

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

tdecore

Skip menu "tdecore"
  • arts
  • dcop
  • dnssd
  • interfaces
  •   kspeech
  •     interface
  •     library
  •   tdetexteditor
  • kate
  • kded
  • kdoctools
  • kimgio
  • kjs
  • libtdemid
  • libtdescreensaver
  • tdeabc
  • tdecmshell
  • tdecore
  • tdefx
  • tdehtml
  • tdeinit
  • tdeio
  •   bookmarks
  •   httpfilter
  •   kpasswdserver
  •   kssl
  •   tdefile
  •   tdeio
  •   tdeioexec
  • tdeioslave
  •   http
  • tdemdi
  •   tdemdi
  • tdenewstuff
  • tdeparts
  • tdeprint
  • tderandr
  • tderesources
  • tdespell2
  • tdesu
  • tdeui
  • tdeunittest
  • tdeutils
  • tdewallet
Generated for tdecore by doxygen 1.7.6.1
This website is maintained by Timothy Pearson.