00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
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 )
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 );
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 )
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 )
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
00872 }
00873
00874 TQVariant TDEConfigSkeleton::ItemIntList::property() const
00875 {
00876
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 }