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 }