File indexing completed on 2024-05-19 15:08:24
0001 /* 0002 This file is part of KOrganizer. 0003 SPDX-FileCopyrightText: 2000, 2001 Cornelius Schumacher <schumacher@kde.org> 0004 SPDX-FileCopyrightText: 2003 Waldo Bastian <bastian@kde.org> 0005 0006 SPDX-License-Identifier: LGPL-2.0-or-later 0007 */ 0008 0009 #include "kcoreconfigskeleton.h" 0010 #include "kcoreconfigskeleton_p.h" 0011 0012 #include <QUrl> 0013 0014 #include <algorithm> 0015 0016 static QString obscuredString(const QString &str) 0017 { 0018 QString result; 0019 const QChar *unicode = str.unicode(); 0020 for (int i = 0; i < str.length(); ++i) { 0021 // yes, no typo. can't encode ' ' or '!' because 0022 // they're the unicode BOM. stupid scrambling. stupid. 0023 result += (unicode[i].unicode() <= 0x21) ? unicode[i] : QChar(0x1001F - unicode[i].unicode()); 0024 } 0025 0026 return result; 0027 } 0028 0029 KConfigSkeletonItemPrivate::~KConfigSkeletonItemPrivate() = default; 0030 0031 KConfigSkeletonItem::KConfigSkeletonItem(const QString &_group, const QString &_key) 0032 : mGroup(_group) 0033 , mKey(_key) 0034 , d_ptr(new KConfigSkeletonItemPrivate) 0035 { 0036 } 0037 0038 KConfigSkeletonItem::KConfigSkeletonItem(KConfigSkeletonItemPrivate &dd, const QString &_group, const QString &_key) 0039 : mGroup(_group) 0040 , mKey(_key) 0041 , d_ptr(&dd) 0042 { 0043 } 0044 0045 KConfigSkeletonItem::~KConfigSkeletonItem() 0046 { 0047 delete d_ptr; 0048 } 0049 0050 void KConfigSkeletonItem::setGroup(const QString &_group) 0051 { 0052 mGroup = _group; 0053 } 0054 0055 void KConfigSkeletonItem::setGroup(const KConfigGroup &cg) 0056 { 0057 Q_D(KConfigSkeletonItem); 0058 d->mConfigGroup = cg; 0059 } 0060 0061 KConfigGroup KConfigSkeletonItem::configGroup(KConfig *config) const 0062 { 0063 Q_D(const KConfigSkeletonItem); 0064 if (d->mConfigGroup.isValid()) { 0065 return d->mConfigGroup; 0066 } 0067 return KConfigGroup(config, mGroup); 0068 } 0069 0070 QString KConfigSkeletonItem::group() const 0071 { 0072 return mGroup; 0073 } 0074 0075 void KConfigSkeletonItem::setKey(const QString &_key) 0076 { 0077 mKey = _key; 0078 } 0079 0080 QString KConfigSkeletonItem::key() const 0081 { 0082 return mKey; 0083 } 0084 0085 void KConfigSkeletonItem::setName(const QString &_name) 0086 { 0087 mName = _name; 0088 } 0089 0090 QString KConfigSkeletonItem::name() const 0091 { 0092 return mName; 0093 } 0094 0095 void KConfigSkeletonItem::setLabel(const QString &l) 0096 { 0097 Q_D(KConfigSkeletonItem); 0098 d->mLabel = l; 0099 } 0100 0101 QString KConfigSkeletonItem::label() const 0102 { 0103 Q_D(const KConfigSkeletonItem); 0104 return d->mLabel; 0105 } 0106 0107 void KConfigSkeletonItem::setToolTip(const QString &t) 0108 { 0109 Q_D(KConfigSkeletonItem); 0110 d->mToolTip = t; 0111 } 0112 0113 QString KConfigSkeletonItem::toolTip() const 0114 { 0115 Q_D(const KConfigSkeletonItem); 0116 return d->mToolTip; 0117 } 0118 0119 void KConfigSkeletonItem::setWhatsThis(const QString &w) 0120 { 0121 Q_D(KConfigSkeletonItem); 0122 d->mWhatsThis = w; 0123 } 0124 0125 QString KConfigSkeletonItem::whatsThis() const 0126 { 0127 Q_D(const KConfigSkeletonItem); 0128 return d->mWhatsThis; 0129 } 0130 0131 void KConfigSkeletonItem::setWriteFlags(KConfigBase::WriteConfigFlags flags) 0132 { 0133 Q_D(KConfigSkeletonItem); 0134 d->mWriteFlags = flags; 0135 } 0136 0137 KConfigBase::WriteConfigFlags KConfigSkeletonItem::writeFlags() const 0138 { 0139 Q_D(const KConfigSkeletonItem); 0140 return d->mWriteFlags; 0141 } 0142 0143 QVariant KConfigSkeletonItem::minValue() const 0144 { 0145 return QVariant(); 0146 } 0147 0148 QVariant KConfigSkeletonItem::maxValue() const 0149 { 0150 return QVariant(); 0151 } 0152 0153 bool KConfigSkeletonItem::isImmutable() const 0154 { 0155 Q_D(const KConfigSkeletonItem); 0156 return d->mIsImmutable; 0157 } 0158 0159 bool KConfigSkeletonItem::isDefault() const 0160 { 0161 Q_D(const KConfigSkeletonItem); 0162 return d->mIsDefaultImpl(); 0163 } 0164 0165 bool KConfigSkeletonItem::isSaveNeeded() const 0166 { 0167 Q_D(const KConfigSkeletonItem); 0168 return d->mIsSaveNeededImpl(); 0169 } 0170 0171 QVariant KConfigSkeletonItem::getDefault() const 0172 { 0173 Q_D(const KConfigSkeletonItem); 0174 return d->mGetDefaultImpl(); 0175 } 0176 0177 void KConfigSkeletonItem::readImmutability(const KConfigGroup &group) 0178 { 0179 Q_D(KConfigSkeletonItem); 0180 d->mIsImmutable = group.isEntryImmutable(mKey); 0181 } 0182 0183 void KConfigSkeletonItem::setIsDefaultImpl(const std::function<bool()> &impl) 0184 { 0185 Q_D(KConfigSkeletonItem); 0186 d->mIsDefaultImpl = impl; 0187 } 0188 0189 void KConfigSkeletonItem::setIsSaveNeededImpl(const std::function<bool()> &impl) 0190 { 0191 Q_D(KConfigSkeletonItem); 0192 d->mIsSaveNeededImpl = impl; 0193 } 0194 0195 void KConfigSkeletonItem::setGetDefaultImpl(const std::function<QVariant()> &impl) 0196 { 0197 Q_D(KConfigSkeletonItem); 0198 d->mGetDefaultImpl = impl; 0199 } 0200 0201 KPropertySkeletonItem::KPropertySkeletonItem(QObject *object, const QByteArray &propertyName, const QVariant &defaultValue) 0202 : KConfigSkeletonItem(*new KPropertySkeletonItemPrivate(object, propertyName, defaultValue), {}, {}) 0203 { 0204 setIsDefaultImpl([this] { 0205 Q_D(const KPropertySkeletonItem); 0206 return d->mReference == d->mDefaultValue; 0207 }); 0208 setIsSaveNeededImpl([this] { 0209 Q_D(const KPropertySkeletonItem); 0210 return d->mReference != d->mLoadedValue; 0211 }); 0212 setGetDefaultImpl([this] { 0213 Q_D(const KPropertySkeletonItem); 0214 return d->mDefaultValue; 0215 }); 0216 } 0217 0218 QVariant KPropertySkeletonItem::property() const 0219 { 0220 Q_D(const KPropertySkeletonItem); 0221 return d->mReference; 0222 } 0223 0224 void KPropertySkeletonItem::setProperty(const QVariant &p) 0225 { 0226 Q_D(KPropertySkeletonItem); 0227 if (d->mReference == p) { 0228 return; 0229 } 0230 d->mReference = p; 0231 if (d->mNotifyFunction) { 0232 d->mNotifyFunction(); 0233 } 0234 } 0235 0236 bool KPropertySkeletonItem::isEqual(const QVariant &p) const 0237 { 0238 Q_D(const KPropertySkeletonItem); 0239 return d->mReference == p; 0240 } 0241 0242 void KPropertySkeletonItem::readConfig(KConfig *) 0243 { 0244 Q_D(KPropertySkeletonItem); 0245 setProperty(d->mObject->property(d->mPropertyName.constData())); 0246 d->mLoadedValue = d->mReference; 0247 } 0248 0249 void KPropertySkeletonItem::writeConfig(KConfig *) 0250 { 0251 Q_D(KPropertySkeletonItem); 0252 d->mObject->setProperty(d->mPropertyName.constData(), d->mReference); 0253 d->mLoadedValue = d->mReference; 0254 } 0255 0256 void KPropertySkeletonItem::readDefault(KConfig *) 0257 { 0258 Q_D(KPropertySkeletonItem); 0259 setProperty(d->mConstDefaultValue); 0260 } 0261 0262 void KPropertySkeletonItem::setDefault() 0263 { 0264 Q_D(KPropertySkeletonItem); 0265 setProperty(d->mDefaultValue); 0266 } 0267 0268 void KPropertySkeletonItem::swapDefault() 0269 { 0270 Q_D(KPropertySkeletonItem); 0271 if (d->mReference == d->mDefaultValue) { 0272 return; 0273 } 0274 std::swap(d->mReference, d->mDefaultValue); 0275 if (d->mNotifyFunction) { 0276 d->mNotifyFunction(); 0277 } 0278 } 0279 0280 void KPropertySkeletonItem::setNotifyFunction(const std::function<void()> &impl) 0281 { 0282 Q_D(KPropertySkeletonItem); 0283 d->mNotifyFunction = impl; 0284 } 0285 0286 KCoreConfigSkeleton::ItemString::ItemString(const QString &_group, const QString &_key, QString &reference, const QString &defaultValue, Type type) 0287 : KConfigSkeletonGenericItem<QString>(_group, _key, reference, defaultValue) 0288 , mType(type) 0289 { 0290 } 0291 0292 void KCoreConfigSkeleton::ItemString::writeConfig(KConfig *config) 0293 { 0294 if (mReference != mLoadedValue) { // WABA: Is this test needed? 0295 KConfigGroup cg = configGroup(config); 0296 if ((mDefault == mReference) && !cg.hasDefault(mKey)) { 0297 cg.revertToDefault(mKey, writeFlags()); 0298 } else if (mType == Path) { 0299 cg.writePathEntry(mKey, mReference, writeFlags()); 0300 } else if (mType == Password) { 0301 cg.writeEntry(mKey, obscuredString(mReference), writeFlags()); 0302 } else { 0303 cg.writeEntry(mKey, mReference, writeFlags()); 0304 } 0305 mLoadedValue = mReference; 0306 } 0307 } 0308 0309 void KCoreConfigSkeleton::ItemString::readConfig(KConfig *config) 0310 { 0311 KConfigGroup cg = configGroup(config); 0312 0313 if (mType == Path) { 0314 mReference = cg.readPathEntry(mKey, mDefault); 0315 } else if (mType == Password) { 0316 QString val = cg.readEntry(mKey, obscuredString(mDefault)); 0317 mReference = obscuredString(val); 0318 } else { 0319 mReference = cg.readEntry(mKey, mDefault); 0320 } 0321 0322 mLoadedValue = mReference; 0323 0324 readImmutability(cg); 0325 } 0326 0327 void KCoreConfigSkeleton::ItemString::setProperty(const QVariant &p) 0328 { 0329 mReference = p.toString(); 0330 } 0331 0332 bool KCoreConfigSkeleton::ItemString::isEqual(const QVariant &v) const 0333 { 0334 return mReference == v.toString(); 0335 } 0336 0337 QVariant KCoreConfigSkeleton::ItemString::property() const 0338 { 0339 return QVariant(mReference); 0340 } 0341 0342 KCoreConfigSkeleton::ItemPassword::ItemPassword(const QString &_group, const QString &_key, QString &reference, const QString &defaultValue) 0343 : ItemString(_group, _key, reference, defaultValue, Password) 0344 { 0345 } 0346 0347 KCoreConfigSkeleton::ItemPath::ItemPath(const QString &_group, const QString &_key, QString &reference, const QString &defaultValue) 0348 : ItemString(_group, _key, reference, defaultValue, Path) 0349 { 0350 } 0351 0352 KCoreConfigSkeleton::ItemUrl::ItemUrl(const QString &_group, const QString &_key, QUrl &reference, const QUrl &defaultValue) 0353 : KConfigSkeletonGenericItem<QUrl>(_group, _key, reference, defaultValue) 0354 { 0355 } 0356 0357 void KCoreConfigSkeleton::ItemUrl::writeConfig(KConfig *config) 0358 { 0359 if (mReference != mLoadedValue) { // WABA: Is this test needed? 0360 KConfigGroup cg = configGroup(config); 0361 if ((mDefault == mReference) && !cg.hasDefault(mKey)) { 0362 cg.revertToDefault(mKey, writeFlags()); 0363 } else { 0364 cg.writeEntry<QString>(mKey, mReference.toString(), writeFlags()); 0365 } 0366 mLoadedValue = mReference; 0367 } 0368 } 0369 0370 void KCoreConfigSkeleton::ItemUrl::readConfig(KConfig *config) 0371 { 0372 KConfigGroup cg = configGroup(config); 0373 0374 mReference = QUrl(cg.readEntry<QString>(mKey, mDefault.toString())); 0375 mLoadedValue = mReference; 0376 0377 readImmutability(cg); 0378 } 0379 0380 void KCoreConfigSkeleton::ItemUrl::setProperty(const QVariant &p) 0381 { 0382 mReference = qvariant_cast<QUrl>(p); 0383 } 0384 0385 bool KCoreConfigSkeleton::ItemUrl::isEqual(const QVariant &v) const 0386 { 0387 return mReference == qvariant_cast<QUrl>(v); 0388 } 0389 0390 QVariant KCoreConfigSkeleton::ItemUrl::property() const 0391 { 0392 return QVariant::fromValue<QUrl>(mReference); 0393 } 0394 0395 KCoreConfigSkeleton::ItemProperty::ItemProperty(const QString &_group, const QString &_key, QVariant &reference, const QVariant &defaultValue) 0396 : KConfigSkeletonGenericItem<QVariant>(_group, _key, reference, defaultValue) 0397 { 0398 } 0399 0400 void KCoreConfigSkeleton::ItemProperty::readConfig(KConfig *config) 0401 { 0402 KConfigGroup cg = configGroup(config); 0403 mReference = cg.readEntry(mKey, mDefault); 0404 mLoadedValue = mReference; 0405 0406 readImmutability(cg); 0407 } 0408 0409 void KCoreConfigSkeleton::ItemProperty::setProperty(const QVariant &p) 0410 { 0411 mReference = p; 0412 } 0413 0414 bool KCoreConfigSkeleton::ItemProperty::isEqual(const QVariant &v) const 0415 { 0416 // this might cause problems if the QVariants are not of default types 0417 return mReference == v; 0418 } 0419 0420 QVariant KCoreConfigSkeleton::ItemProperty::property() const 0421 { 0422 return mReference; 0423 } 0424 0425 KCoreConfigSkeleton::ItemBool::ItemBool(const QString &_group, const QString &_key, bool &reference, bool defaultValue) 0426 : KConfigSkeletonGenericItem<bool>(_group, _key, reference, defaultValue) 0427 { 0428 } 0429 0430 void KCoreConfigSkeleton::ItemBool::readConfig(KConfig *config) 0431 { 0432 KConfigGroup cg = configGroup(config); 0433 mReference = cg.readEntry(mKey, mDefault); 0434 mLoadedValue = mReference; 0435 0436 readImmutability(cg); 0437 } 0438 0439 void KCoreConfigSkeleton::ItemBool::setProperty(const QVariant &p) 0440 { 0441 mReference = p.toBool(); 0442 } 0443 0444 bool KCoreConfigSkeleton::ItemBool::isEqual(const QVariant &v) const 0445 { 0446 return mReference == v.toBool(); 0447 } 0448 0449 QVariant KCoreConfigSkeleton::ItemBool::property() const 0450 { 0451 return QVariant(mReference); 0452 } 0453 0454 KCoreConfigSkeleton::ItemInt::ItemInt(const QString &_group, const QString &_key, qint32 &reference, qint32 defaultValue) 0455 : KConfigSkeletonGenericItem<qint32>(_group, _key, reference, defaultValue) 0456 , mHasMin(false) 0457 , mHasMax(false) 0458 { 0459 } 0460 0461 void KCoreConfigSkeleton::ItemInt::readConfig(KConfig *config) 0462 { 0463 KConfigGroup cg = configGroup(config); 0464 mReference = cg.readEntry(mKey, mDefault); 0465 if (mHasMin) { 0466 mReference = qMax(mReference, mMin); 0467 } 0468 if (mHasMax) { 0469 mReference = qMin(mReference, mMax); 0470 } 0471 mLoadedValue = mReference; 0472 0473 readImmutability(cg); 0474 } 0475 0476 void KCoreConfigSkeleton::ItemInt::setProperty(const QVariant &p) 0477 { 0478 mReference = p.toInt(); 0479 } 0480 0481 bool KCoreConfigSkeleton::ItemInt::isEqual(const QVariant &v) const 0482 { 0483 return mReference == v.toInt(); 0484 } 0485 0486 QVariant KCoreConfigSkeleton::ItemInt::property() const 0487 { 0488 return QVariant(mReference); 0489 } 0490 0491 QVariant KCoreConfigSkeleton::ItemInt::minValue() const 0492 { 0493 if (mHasMin) { 0494 return QVariant(mMin); 0495 } 0496 return QVariant(); 0497 } 0498 0499 QVariant KCoreConfigSkeleton::ItemInt::maxValue() const 0500 { 0501 if (mHasMax) { 0502 return QVariant(mMax); 0503 } 0504 return QVariant(); 0505 } 0506 0507 void KCoreConfigSkeleton::ItemInt::setMinValue(qint32 v) 0508 { 0509 mHasMin = true; 0510 mMin = v; 0511 } 0512 0513 void KCoreConfigSkeleton::ItemInt::setMaxValue(qint32 v) 0514 { 0515 mHasMax = true; 0516 mMax = v; 0517 } 0518 0519 KCoreConfigSkeleton::ItemLongLong::ItemLongLong(const QString &_group, const QString &_key, qint64 &reference, qint64 defaultValue) 0520 : KConfigSkeletonGenericItem<qint64>(_group, _key, reference, defaultValue) 0521 , mHasMin(false) 0522 , mHasMax(false) 0523 { 0524 } 0525 0526 void KCoreConfigSkeleton::ItemLongLong::readConfig(KConfig *config) 0527 { 0528 KConfigGroup cg = configGroup(config); 0529 mReference = cg.readEntry(mKey, mDefault); 0530 if (mHasMin) { 0531 mReference = qMax(mReference, mMin); 0532 } 0533 if (mHasMax) { 0534 mReference = qMin(mReference, mMax); 0535 } 0536 mLoadedValue = mReference; 0537 0538 readImmutability(cg); 0539 } 0540 0541 void KCoreConfigSkeleton::ItemLongLong::setProperty(const QVariant &p) 0542 { 0543 mReference = p.toLongLong(); 0544 } 0545 0546 bool KCoreConfigSkeleton::ItemLongLong::isEqual(const QVariant &v) const 0547 { 0548 return mReference == v.toLongLong(); 0549 } 0550 0551 QVariant KCoreConfigSkeleton::ItemLongLong::property() const 0552 { 0553 return QVariant(mReference); 0554 } 0555 0556 QVariant KCoreConfigSkeleton::ItemLongLong::minValue() const 0557 { 0558 if (mHasMin) { 0559 return QVariant(mMin); 0560 } 0561 return QVariant(); 0562 } 0563 0564 QVariant KCoreConfigSkeleton::ItemLongLong::maxValue() const 0565 { 0566 if (mHasMax) { 0567 return QVariant(mMax); 0568 } 0569 return QVariant(); 0570 } 0571 0572 void KCoreConfigSkeleton::ItemLongLong::setMinValue(qint64 v) 0573 { 0574 mHasMin = true; 0575 mMin = v; 0576 } 0577 0578 void KCoreConfigSkeleton::ItemLongLong::setMaxValue(qint64 v) 0579 { 0580 mHasMax = true; 0581 mMax = v; 0582 } 0583 0584 QString KCoreConfigSkeleton::ItemEnum::valueForChoice(const QString &name) const 0585 { 0586 // HACK for BC concerns 0587 // TODO KF6: remove KConfigSkeletonItemPrivate::mValues and add a value field to KCoreConfigSkeleton::ItemEnum::Choice 0588 const auto inHash = d_ptr->mValues.value(name); 0589 return !inHash.isEmpty() ? inHash : name; 0590 } 0591 0592 void KCoreConfigSkeleton::ItemEnum::setValueForChoice(const QString &name, const QString &value) 0593 { 0594 d_ptr->mValues.insert(name, value); 0595 } 0596 0597 KCoreConfigSkeleton::ItemEnum::ItemEnum(const QString &_group, const QString &_key, qint32 &reference, const QList<Choice> &choices, qint32 defaultValue) 0598 : ItemInt(_group, _key, reference, defaultValue) 0599 , mChoices(choices) 0600 { 0601 } 0602 0603 void KCoreConfigSkeleton::ItemEnum::readConfig(KConfig *config) 0604 { 0605 KConfigGroup cg = configGroup(config); 0606 if (!cg.hasKey(mKey)) { 0607 mReference = mDefault; 0608 } else { 0609 int i = 0; 0610 mReference = -1; 0611 const QString entryString = cg.readEntry(mKey, QString()); 0612 for (auto it = mChoices.cbegin(); it != mChoices.cend(); ++it, ++i) { 0613 QString choiceName = (*it).name; 0614 if (valueForChoice(choiceName).compare(entryString, Qt::CaseInsensitive) == 0) { 0615 mReference = i; 0616 break; 0617 } 0618 } 0619 if (mReference == -1) { 0620 mReference = cg.readEntry(mKey, mDefault); 0621 } 0622 } 0623 mLoadedValue = mReference; 0624 0625 readImmutability(cg); 0626 } 0627 0628 void KCoreConfigSkeleton::ItemEnum::writeConfig(KConfig *config) 0629 { 0630 if (mReference != mLoadedValue) { // WABA: Is this test needed? 0631 KConfigGroup cg = configGroup(config); 0632 if ((mDefault == mReference) && !cg.hasDefault(mKey)) { 0633 cg.revertToDefault(mKey, writeFlags()); 0634 } else if ((mReference >= 0) && (mReference < mChoices.count())) { 0635 cg.writeEntry(mKey, valueForChoice(mChoices.at(mReference).name), writeFlags()); 0636 } else { 0637 cg.writeEntry(mKey, mReference, writeFlags()); 0638 } 0639 mLoadedValue = mReference; 0640 } 0641 } 0642 0643 QList<KCoreConfigSkeleton::ItemEnum::Choice> KCoreConfigSkeleton::ItemEnum::choices() const 0644 { 0645 return mChoices; 0646 } 0647 0648 #if KCONFIGCORE_BUILD_DEPRECATED_SINCE(5, 103) 0649 QList<KCoreConfigSkeleton::ItemEnum::Choice> KCoreConfigSkeleton::ItemEnum::choices2() const 0650 { 0651 return mChoices; 0652 } 0653 #endif 0654 0655 KCoreConfigSkeleton::ItemUInt::ItemUInt(const QString &_group, const QString &_key, quint32 &reference, quint32 defaultValue) 0656 : KConfigSkeletonGenericItem<quint32>(_group, _key, reference, defaultValue) 0657 , mHasMin(false) 0658 , mHasMax(false) 0659 { 0660 } 0661 0662 void KCoreConfigSkeleton::ItemUInt::readConfig(KConfig *config) 0663 { 0664 KConfigGroup cg = configGroup(config); 0665 mReference = cg.readEntry(mKey, mDefault); 0666 if (mHasMin) { 0667 mReference = qMax(mReference, mMin); 0668 } 0669 if (mHasMax) { 0670 mReference = qMin(mReference, mMax); 0671 } 0672 mLoadedValue = mReference; 0673 0674 readImmutability(cg); 0675 } 0676 0677 void KCoreConfigSkeleton::ItemUInt::setProperty(const QVariant &p) 0678 { 0679 mReference = p.toUInt(); 0680 } 0681 0682 bool KCoreConfigSkeleton::ItemUInt::isEqual(const QVariant &v) const 0683 { 0684 return mReference == v.toUInt(); 0685 } 0686 0687 QVariant KCoreConfigSkeleton::ItemUInt::property() const 0688 { 0689 return QVariant(mReference); 0690 } 0691 0692 QVariant KCoreConfigSkeleton::ItemUInt::minValue() const 0693 { 0694 if (mHasMin) { 0695 return QVariant(mMin); 0696 } 0697 return QVariant(); 0698 } 0699 0700 QVariant KCoreConfigSkeleton::ItemUInt::maxValue() const 0701 { 0702 if (mHasMax) { 0703 return QVariant(mMax); 0704 } 0705 return QVariant(); 0706 } 0707 0708 void KCoreConfigSkeleton::ItemUInt::setMinValue(quint32 v) 0709 { 0710 mHasMin = true; 0711 mMin = v; 0712 } 0713 0714 void KCoreConfigSkeleton::ItemUInt::setMaxValue(quint32 v) 0715 { 0716 mHasMax = true; 0717 mMax = v; 0718 } 0719 0720 KCoreConfigSkeleton::ItemULongLong::ItemULongLong(const QString &_group, const QString &_key, quint64 &reference, quint64 defaultValue) 0721 : KConfigSkeletonGenericItem<quint64>(_group, _key, reference, defaultValue) 0722 , mHasMin(false) 0723 , mHasMax(false) 0724 { 0725 } 0726 0727 void KCoreConfigSkeleton::ItemULongLong::readConfig(KConfig *config) 0728 { 0729 KConfigGroup cg = configGroup(config); 0730 mReference = cg.readEntry(mKey, mDefault); 0731 if (mHasMin) { 0732 mReference = qMax(mReference, mMin); 0733 } 0734 if (mHasMax) { 0735 mReference = qMin(mReference, mMax); 0736 } 0737 mLoadedValue = mReference; 0738 0739 readImmutability(cg); 0740 } 0741 0742 void KCoreConfigSkeleton::ItemULongLong::setProperty(const QVariant &p) 0743 { 0744 mReference = p.toULongLong(); 0745 } 0746 0747 bool KCoreConfigSkeleton::ItemULongLong::isEqual(const QVariant &v) const 0748 { 0749 return mReference == v.toULongLong(); 0750 } 0751 0752 QVariant KCoreConfigSkeleton::ItemULongLong::property() const 0753 { 0754 return QVariant(mReference); 0755 } 0756 0757 QVariant KCoreConfigSkeleton::ItemULongLong::minValue() const 0758 { 0759 if (mHasMin) { 0760 return QVariant(mMin); 0761 } 0762 return QVariant(); 0763 } 0764 0765 QVariant KCoreConfigSkeleton::ItemULongLong::maxValue() const 0766 { 0767 if (mHasMax) { 0768 return QVariant(mMax); 0769 } 0770 return QVariant(); 0771 } 0772 0773 void KCoreConfigSkeleton::ItemULongLong::setMinValue(quint64 v) 0774 { 0775 mHasMin = true; 0776 mMin = v; 0777 } 0778 0779 void KCoreConfigSkeleton::ItemULongLong::setMaxValue(quint64 v) 0780 { 0781 mHasMax = true; 0782 mMax = v; 0783 } 0784 0785 KCoreConfigSkeleton::ItemDouble::ItemDouble(const QString &_group, const QString &_key, double &reference, double defaultValue) 0786 : KConfigSkeletonGenericItem<double>(_group, _key, reference, defaultValue) 0787 , mHasMin(false) 0788 , mHasMax(false) 0789 { 0790 } 0791 0792 void KCoreConfigSkeleton::ItemDouble::readConfig(KConfig *config) 0793 { 0794 KConfigGroup cg = configGroup(config); 0795 mReference = cg.readEntry(mKey, mDefault); 0796 if (mHasMin) { 0797 mReference = qMax(mReference, mMin); 0798 } 0799 if (mHasMax) { 0800 mReference = qMin(mReference, mMax); 0801 } 0802 mLoadedValue = mReference; 0803 0804 readImmutability(cg); 0805 } 0806 0807 void KCoreConfigSkeleton::ItemDouble::setProperty(const QVariant &p) 0808 { 0809 mReference = p.toDouble(); 0810 } 0811 0812 bool KCoreConfigSkeleton::ItemDouble::isEqual(const QVariant &v) const 0813 { 0814 return mReference == v.toDouble(); 0815 } 0816 0817 QVariant KCoreConfigSkeleton::ItemDouble::property() const 0818 { 0819 return QVariant(mReference); 0820 } 0821 0822 QVariant KCoreConfigSkeleton::ItemDouble::minValue() const 0823 { 0824 if (mHasMin) { 0825 return QVariant(mMin); 0826 } 0827 return QVariant(); 0828 } 0829 0830 QVariant KCoreConfigSkeleton::ItemDouble::maxValue() const 0831 { 0832 if (mHasMax) { 0833 return QVariant(mMax); 0834 } 0835 return QVariant(); 0836 } 0837 0838 void KCoreConfigSkeleton::ItemDouble::setMinValue(double v) 0839 { 0840 mHasMin = true; 0841 mMin = v; 0842 } 0843 0844 void KCoreConfigSkeleton::ItemDouble::setMaxValue(double v) 0845 { 0846 mHasMax = true; 0847 mMax = v; 0848 } 0849 0850 KCoreConfigSkeleton::ItemRect::ItemRect(const QString &_group, const QString &_key, QRect &reference, const QRect &defaultValue) 0851 : KConfigSkeletonGenericItem<QRect>(_group, _key, reference, defaultValue) 0852 { 0853 } 0854 0855 void KCoreConfigSkeleton::ItemRect::readConfig(KConfig *config) 0856 { 0857 KConfigGroup cg = configGroup(config); 0858 mReference = cg.readEntry(mKey, mDefault); 0859 mLoadedValue = mReference; 0860 0861 readImmutability(cg); 0862 } 0863 0864 void KCoreConfigSkeleton::ItemRect::setProperty(const QVariant &p) 0865 { 0866 mReference = p.toRect(); 0867 } 0868 0869 bool KCoreConfigSkeleton::ItemRect::isEqual(const QVariant &v) const 0870 { 0871 return mReference == v.toRect(); 0872 } 0873 0874 QVariant KCoreConfigSkeleton::ItemRect::property() const 0875 { 0876 return QVariant(mReference); 0877 } 0878 0879 KCoreConfigSkeleton::ItemPoint::ItemPoint(const QString &_group, const QString &_key, QPoint &reference, const QPoint &defaultValue) 0880 : KConfigSkeletonGenericItem<QPoint>(_group, _key, reference, defaultValue) 0881 { 0882 } 0883 0884 void KCoreConfigSkeleton::ItemPoint::readConfig(KConfig *config) 0885 { 0886 KConfigGroup cg = configGroup(config); 0887 mReference = cg.readEntry(mKey, mDefault); 0888 mLoadedValue = mReference; 0889 0890 readImmutability(cg); 0891 } 0892 0893 void KCoreConfigSkeleton::ItemPoint::setProperty(const QVariant &p) 0894 { 0895 mReference = p.toPoint(); 0896 } 0897 0898 bool KCoreConfigSkeleton::ItemPoint::isEqual(const QVariant &v) const 0899 { 0900 return mReference == v.toPoint(); 0901 } 0902 0903 QVariant KCoreConfigSkeleton::ItemPoint::property() const 0904 { 0905 return QVariant(mReference); 0906 } 0907 0908 KCoreConfigSkeleton::ItemSize::ItemSize(const QString &_group, const QString &_key, QSize &reference, const QSize &defaultValue) 0909 : KConfigSkeletonGenericItem<QSize>(_group, _key, reference, defaultValue) 0910 { 0911 } 0912 0913 void KCoreConfigSkeleton::ItemSize::readConfig(KConfig *config) 0914 { 0915 KConfigGroup cg = configGroup(config); 0916 mReference = cg.readEntry(mKey, mDefault); 0917 mLoadedValue = mReference; 0918 0919 readImmutability(cg); 0920 } 0921 0922 void KCoreConfigSkeleton::ItemSize::setProperty(const QVariant &p) 0923 { 0924 mReference = p.toSize(); 0925 } 0926 0927 bool KCoreConfigSkeleton::ItemSize::isEqual(const QVariant &v) const 0928 { 0929 return mReference == v.toSize(); 0930 } 0931 0932 QVariant KCoreConfigSkeleton::ItemSize::property() const 0933 { 0934 return QVariant(mReference); 0935 } 0936 0937 KCoreConfigSkeleton::ItemDateTime::ItemDateTime(const QString &_group, const QString &_key, QDateTime &reference, const QDateTime &defaultValue) 0938 : KConfigSkeletonGenericItem<QDateTime>(_group, _key, reference, defaultValue) 0939 { 0940 } 0941 0942 void KCoreConfigSkeleton::ItemDateTime::readConfig(KConfig *config) 0943 { 0944 KConfigGroup cg = configGroup(config); 0945 mReference = cg.readEntry(mKey, mDefault); 0946 mLoadedValue = mReference; 0947 0948 readImmutability(cg); 0949 } 0950 0951 void KCoreConfigSkeleton::ItemDateTime::setProperty(const QVariant &p) 0952 { 0953 mReference = p.toDateTime(); 0954 } 0955 0956 bool KCoreConfigSkeleton::ItemDateTime::isEqual(const QVariant &v) const 0957 { 0958 return mReference == v.toDateTime(); 0959 } 0960 0961 QVariant KCoreConfigSkeleton::ItemDateTime::property() const 0962 { 0963 return QVariant(mReference); 0964 } 0965 0966 KCoreConfigSkeleton::ItemStringList::ItemStringList(const QString &_group, const QString &_key, QStringList &reference, const QStringList &defaultValue) 0967 : KConfigSkeletonGenericItem<QStringList>(_group, _key, reference, defaultValue) 0968 { 0969 } 0970 0971 void KCoreConfigSkeleton::ItemStringList::readConfig(KConfig *config) 0972 { 0973 KConfigGroup cg = configGroup(config); 0974 if (!cg.hasKey(mKey)) { 0975 mReference = mDefault; 0976 } else { 0977 mReference = cg.readEntry(mKey, mDefault); 0978 } 0979 mLoadedValue = mReference; 0980 0981 readImmutability(cg); 0982 } 0983 0984 void KCoreConfigSkeleton::ItemStringList::setProperty(const QVariant &p) 0985 { 0986 mReference = p.toStringList(); 0987 } 0988 0989 bool KCoreConfigSkeleton::ItemStringList::isEqual(const QVariant &v) const 0990 { 0991 return mReference == v.toStringList(); 0992 } 0993 0994 QVariant KCoreConfigSkeleton::ItemStringList::property() const 0995 { 0996 return QVariant(mReference); 0997 } 0998 0999 KCoreConfigSkeleton::ItemPathList::ItemPathList(const QString &_group, const QString &_key, QStringList &reference, const QStringList &defaultValue) 1000 : ItemStringList(_group, _key, reference, defaultValue) 1001 { 1002 } 1003 1004 void KCoreConfigSkeleton::ItemPathList::readConfig(KConfig *config) 1005 { 1006 KConfigGroup cg = configGroup(config); 1007 if (!cg.hasKey(mKey)) { 1008 mReference = mDefault; 1009 } else { 1010 mReference = cg.readPathEntry(mKey, QStringList()); 1011 } 1012 mLoadedValue = mReference; 1013 1014 readImmutability(cg); 1015 } 1016 1017 void KCoreConfigSkeleton::ItemPathList::writeConfig(KConfig *config) 1018 { 1019 if (mReference != mLoadedValue) { // WABA: Is this test needed? 1020 KConfigGroup cg = configGroup(config); 1021 if ((mDefault == mReference) && !cg.hasDefault(mKey)) { 1022 cg.revertToDefault(mKey, writeFlags()); 1023 } else { 1024 QStringList sl = mReference; 1025 cg.writePathEntry(mKey, sl, writeFlags()); 1026 } 1027 mLoadedValue = mReference; 1028 } 1029 } 1030 1031 KCoreConfigSkeleton::ItemUrlList::ItemUrlList(const QString &_group, const QString &_key, QList<QUrl> &reference, const QList<QUrl> &defaultValue) 1032 : KConfigSkeletonGenericItem<QList<QUrl>>(_group, _key, reference, defaultValue) 1033 { 1034 } 1035 1036 void KCoreConfigSkeleton::ItemUrlList::readConfig(KConfig *config) 1037 { 1038 KConfigGroup cg = configGroup(config); 1039 if (!cg.hasKey(mKey)) { 1040 mReference = mDefault; 1041 } else { 1042 QStringList strList; 1043 for (const QUrl &url : std::as_const(mDefault)) { 1044 strList.append(url.toString()); 1045 } 1046 mReference.clear(); 1047 const QStringList readList = cg.readEntry<QStringList>(mKey, strList); 1048 for (const QString &str : readList) { 1049 mReference.append(QUrl(str)); 1050 } 1051 } 1052 mLoadedValue = mReference; 1053 1054 readImmutability(cg); 1055 } 1056 1057 void KCoreConfigSkeleton::ItemUrlList::writeConfig(KConfig *config) 1058 { 1059 if (mReference != mLoadedValue) { // WABA: Is this test needed? 1060 KConfigGroup cg = configGroup(config); 1061 if ((mDefault == mReference) && !cg.hasDefault(mKey)) { 1062 cg.revertToDefault(mKey, writeFlags()); 1063 } else { 1064 QStringList strList; 1065 for (const QUrl &url : std::as_const(mReference)) { 1066 strList.append(url.toString()); 1067 } 1068 cg.writeEntry<QStringList>(mKey, strList, writeFlags()); 1069 } 1070 mLoadedValue = mReference; 1071 } 1072 } 1073 1074 void KCoreConfigSkeleton::ItemUrlList::setProperty(const QVariant &p) 1075 { 1076 mReference = qvariant_cast<QList<QUrl>>(p); 1077 } 1078 1079 bool KCoreConfigSkeleton::ItemUrlList::isEqual(const QVariant &v) const 1080 { 1081 return mReference == qvariant_cast<QList<QUrl>>(v); 1082 } 1083 1084 QVariant KCoreConfigSkeleton::ItemUrlList::property() const 1085 { 1086 return QVariant::fromValue<QList<QUrl>>(mReference); 1087 } 1088 1089 KCoreConfigSkeleton::ItemIntList::ItemIntList(const QString &_group, const QString &_key, QList<int> &reference, const QList<int> &defaultValue) 1090 : KConfigSkeletonGenericItem<QList<int>>(_group, _key, reference, defaultValue) 1091 { 1092 } 1093 1094 void KCoreConfigSkeleton::ItemIntList::readConfig(KConfig *config) 1095 { 1096 KConfigGroup cg = configGroup(config); 1097 if (!cg.hasKey(mKey)) { 1098 mReference = mDefault; 1099 } else { 1100 mReference = cg.readEntry(mKey, mDefault); 1101 } 1102 mLoadedValue = mReference; 1103 1104 readImmutability(cg); 1105 } 1106 1107 void KCoreConfigSkeleton::ItemIntList::setProperty(const QVariant &p) 1108 { 1109 mReference = qvariant_cast<QList<int>>(p); 1110 } 1111 1112 bool KCoreConfigSkeleton::ItemIntList::isEqual(const QVariant &v) const 1113 { 1114 return mReference == qvariant_cast<QList<int>>(v); 1115 } 1116 1117 QVariant KCoreConfigSkeleton::ItemIntList::property() const 1118 { 1119 return QVariant::fromValue<QList<int>>(mReference); 1120 } 1121 1122 // static int kCoreConfigSkeletionDebugArea() { static int s_area = KDebug::registerArea("kdecore (KConfigSkeleton)"); return s_area; } 1123 1124 KCoreConfigSkeleton::KCoreConfigSkeleton(const QString &configname, QObject *parent) 1125 : QObject(parent) 1126 , d(new KCoreConfigSkeletonPrivate) 1127 { 1128 // qDebug() << "Creating KCoreConfigSkeleton (" << (void *)this << ")"; 1129 1130 d->mConfig = KSharedConfig::openConfig(configname, KConfig::FullConfig); 1131 } 1132 1133 KCoreConfigSkeleton::KCoreConfigSkeleton(KSharedConfig::Ptr pConfig, QObject *parent) 1134 : QObject(parent) 1135 , d(new KCoreConfigSkeletonPrivate) 1136 { 1137 // qDebug() << "Creating KCoreConfigSkeleton (" << (void *)this << ")"; 1138 d->mConfig = std::move(pConfig); 1139 } 1140 1141 KCoreConfigSkeleton::~KCoreConfigSkeleton() 1142 { 1143 delete d; 1144 } 1145 1146 void KCoreConfigSkeleton::setCurrentGroup(const QString &group) 1147 { 1148 d->mCurrentGroup = group; 1149 } 1150 1151 QString KCoreConfigSkeleton::currentGroup() const 1152 { 1153 return d->mCurrentGroup; 1154 } 1155 1156 KConfig *KCoreConfigSkeleton::config() 1157 { 1158 return d->mConfig.data(); 1159 } 1160 1161 const KConfig *KCoreConfigSkeleton::config() const 1162 { 1163 return d->mConfig.data(); 1164 } 1165 1166 KSharedConfig::Ptr KCoreConfigSkeleton::sharedConfig() const 1167 { 1168 return d->mConfig; 1169 } 1170 1171 void KCoreConfigSkeleton::setSharedConfig(KSharedConfig::Ptr pConfig) 1172 { 1173 d->mConfig = std::move(pConfig); 1174 } 1175 1176 KConfigSkeletonItem::List KCoreConfigSkeleton::items() const 1177 { 1178 return d->mItems; 1179 } 1180 1181 bool KCoreConfigSkeleton::useDefaults(bool b) 1182 { 1183 if (b == d->mUseDefaults) { 1184 return d->mUseDefaults; 1185 } 1186 1187 d->mUseDefaults = b; 1188 for (auto *skelItem : std::as_const(d->mItems)) { 1189 skelItem->swapDefault(); 1190 } 1191 1192 usrUseDefaults(b); 1193 return !d->mUseDefaults; 1194 } 1195 1196 void KCoreConfigSkeleton::setDefaults() 1197 { 1198 for (auto *skelItem : std::as_const(d->mItems)) { 1199 skelItem->setDefault(); 1200 } 1201 usrSetDefaults(); 1202 } 1203 1204 void KCoreConfigSkeleton::load() 1205 { 1206 d->mConfig->reparseConfiguration(); 1207 read(); 1208 } 1209 1210 void KCoreConfigSkeleton::read() 1211 { 1212 for (auto *skelItem : std::as_const(d->mItems)) { 1213 skelItem->readConfig(d->mConfig.data()); 1214 } 1215 usrRead(); 1216 } 1217 1218 bool KCoreConfigSkeleton::isDefaults() const 1219 { 1220 return std::all_of(d->mItems.cbegin(), d->mItems.cend(), [](KConfigSkeletonItem *skelItem) { 1221 return skelItem->isDefault(); 1222 }); 1223 } 1224 1225 bool KCoreConfigSkeleton::isSaveNeeded() const 1226 { 1227 return std::any_of(d->mItems.cbegin(), d->mItems.cend(), [](KConfigSkeletonItem *skelItem) { 1228 return skelItem->isSaveNeeded(); 1229 }); 1230 } 1231 1232 bool KCoreConfigSkeleton::save() 1233 { 1234 // qDebug(); 1235 for (auto *skelItem : std::as_const(d->mItems)) { 1236 skelItem->writeConfig(d->mConfig.data()); 1237 } 1238 1239 if (!usrSave()) { 1240 return false; 1241 } 1242 1243 if (d->mConfig->isDirty()) { 1244 if (!d->mConfig->sync()) { 1245 return false; 1246 } 1247 Q_EMIT configChanged(); 1248 } 1249 return true; 1250 } 1251 1252 bool KCoreConfigSkeleton::usrUseDefaults(bool) 1253 { 1254 return false; 1255 } 1256 1257 void KCoreConfigSkeleton::usrSetDefaults() 1258 { 1259 } 1260 1261 void KCoreConfigSkeleton::usrRead() 1262 { 1263 #if KCONFIGCORE_BUILD_DEPRECATED_SINCE(5, 0) 1264 usrReadConfig(); 1265 #endif 1266 } 1267 1268 #if KCONFIGCORE_BUILD_DEPRECATED_SINCE(5, 0) 1269 void KCoreConfigSkeleton::usrReadConfig() 1270 { 1271 } 1272 #endif 1273 1274 bool KCoreConfigSkeleton::usrSave() 1275 { 1276 #if KCONFIGCORE_BUILD_DEPRECATED_SINCE(5, 0) 1277 return usrWriteConfig(); 1278 #else 1279 return true; 1280 #endif 1281 } 1282 1283 #if KCONFIGCORE_BUILD_DEPRECATED_SINCE(5, 0) 1284 bool KCoreConfigSkeleton::usrWriteConfig() 1285 { 1286 return true; 1287 } 1288 #endif 1289 1290 void KCoreConfigSkeleton::addItem(KConfigSkeletonItem *item, const QString &name) 1291 { 1292 if (d->mItems.contains(item)) { 1293 if (item->name() == name || (name.isEmpty() && item->name() == item->key())) { 1294 // nothing to do -> it is already in our collection 1295 // and the name isn't changing 1296 return; 1297 } 1298 1299 d->mItemDict.remove(item->name()); 1300 } else { 1301 d->mItems.append(item); 1302 } 1303 1304 item->setName(name.isEmpty() ? item->key() : name); 1305 d->mItemDict.insert(item->name(), item); 1306 item->readDefault(d->mConfig.data()); 1307 item->readConfig(d->mConfig.data()); 1308 } 1309 1310 void KCoreConfigSkeleton::removeItem(const QString &name) 1311 { 1312 KConfigSkeletonItem *item = d->mItemDict.value(name); 1313 if (item) { 1314 d->mItems.removeAll(item); 1315 d->mItemDict.remove(item->name()); 1316 delete item; 1317 } 1318 } 1319 1320 void KCoreConfigSkeleton::clearItems() 1321 { 1322 KConfigSkeletonItem::List items = d->mItems; 1323 d->mItems.clear(); 1324 d->mItemDict.clear(); 1325 qDeleteAll(items); 1326 } 1327 1328 KCoreConfigSkeleton::ItemString *KCoreConfigSkeleton::addItemString(const QString &name, QString &reference, const QString &defaultValue, const QString &key) 1329 { 1330 KCoreConfigSkeleton::ItemString *item; 1331 item = new KCoreConfigSkeleton::ItemString(d->mCurrentGroup, key.isEmpty() ? name : key, reference, defaultValue, KCoreConfigSkeleton::ItemString::Normal); 1332 addItem(item, name); 1333 return item; 1334 } 1335 1336 KCoreConfigSkeleton::ItemPassword * 1337 KCoreConfigSkeleton::addItemPassword(const QString &name, QString &reference, const QString &defaultValue, const QString &key) 1338 { 1339 KCoreConfigSkeleton::ItemPassword *item; 1340 item = new KCoreConfigSkeleton::ItemPassword(d->mCurrentGroup, key.isNull() ? name : key, reference, defaultValue); 1341 addItem(item, name); 1342 return item; 1343 } 1344 1345 KCoreConfigSkeleton::ItemPath *KCoreConfigSkeleton::addItemPath(const QString &name, QString &reference, const QString &defaultValue, const QString &key) 1346 { 1347 KCoreConfigSkeleton::ItemPath *item; 1348 item = new KCoreConfigSkeleton::ItemPath(d->mCurrentGroup, key.isNull() ? name : key, reference, defaultValue); 1349 addItem(item, name); 1350 return item; 1351 } 1352 1353 KCoreConfigSkeleton::ItemProperty * 1354 KCoreConfigSkeleton::addItemProperty(const QString &name, QVariant &reference, const QVariant &defaultValue, const QString &key) 1355 { 1356 KCoreConfigSkeleton::ItemProperty *item; 1357 item = new KCoreConfigSkeleton::ItemProperty(d->mCurrentGroup, key.isNull() ? name : key, reference, defaultValue); 1358 addItem(item, name); 1359 return item; 1360 } 1361 1362 KCoreConfigSkeleton::ItemBool *KCoreConfigSkeleton::addItemBool(const QString &name, bool &reference, bool defaultValue, const QString &key) 1363 { 1364 KCoreConfigSkeleton::ItemBool *item; 1365 item = new KCoreConfigSkeleton::ItemBool(d->mCurrentGroup, key.isNull() ? name : key, reference, defaultValue); 1366 addItem(item, name); 1367 return item; 1368 } 1369 1370 KCoreConfigSkeleton::ItemInt *KCoreConfigSkeleton::addItemInt(const QString &name, qint32 &reference, qint32 defaultValue, const QString &key) 1371 { 1372 KCoreConfigSkeleton::ItemInt *item; 1373 item = new KCoreConfigSkeleton::ItemInt(d->mCurrentGroup, key.isNull() ? name : key, reference, defaultValue); 1374 addItem(item, name); 1375 return item; 1376 } 1377 1378 KCoreConfigSkeleton::ItemUInt *KCoreConfigSkeleton::addItemUInt(const QString &name, quint32 &reference, quint32 defaultValue, const QString &key) 1379 { 1380 KCoreConfigSkeleton::ItemUInt *item; 1381 item = new KCoreConfigSkeleton::ItemUInt(d->mCurrentGroup, key.isNull() ? name : key, reference, defaultValue); 1382 addItem(item, name); 1383 return item; 1384 } 1385 1386 KCoreConfigSkeleton::ItemLongLong *KCoreConfigSkeleton::addItemLongLong(const QString &name, qint64 &reference, qint64 defaultValue, const QString &key) 1387 { 1388 KCoreConfigSkeleton::ItemLongLong *item; 1389 item = new KCoreConfigSkeleton::ItemLongLong(d->mCurrentGroup, key.isNull() ? name : key, reference, defaultValue); 1390 addItem(item, name); 1391 return item; 1392 } 1393 1394 #if KCONFIGCORE_BUILD_DEPRECATED_SINCE(5, 0) 1395 KCoreConfigSkeleton::ItemLongLong *KCoreConfigSkeleton::addItemInt64(const QString &name, qint64 &reference, qint64 defaultValue, const QString &key) 1396 { 1397 return addItemLongLong(name, reference, defaultValue, key); 1398 } 1399 #endif 1400 1401 KCoreConfigSkeleton::ItemULongLong *KCoreConfigSkeleton::addItemULongLong(const QString &name, quint64 &reference, quint64 defaultValue, const QString &key) 1402 { 1403 KCoreConfigSkeleton::ItemULongLong *item; 1404 item = new KCoreConfigSkeleton::ItemULongLong(d->mCurrentGroup, key.isNull() ? name : key, reference, defaultValue); 1405 addItem(item, name); 1406 return item; 1407 } 1408 1409 #if KCONFIGCORE_BUILD_DEPRECATED_SINCE(5, 0) 1410 KCoreConfigSkeleton::ItemULongLong *KCoreConfigSkeleton::addItemUInt64(const QString &name, quint64 &reference, quint64 defaultValue, const QString &key) 1411 { 1412 return addItemULongLong(name, reference, defaultValue, key); 1413 } 1414 #endif 1415 1416 KCoreConfigSkeleton::ItemDouble *KCoreConfigSkeleton::addItemDouble(const QString &name, double &reference, double defaultValue, const QString &key) 1417 { 1418 KCoreConfigSkeleton::ItemDouble *item; 1419 item = new KCoreConfigSkeleton::ItemDouble(d->mCurrentGroup, key.isNull() ? name : key, reference, defaultValue); 1420 addItem(item, name); 1421 return item; 1422 } 1423 1424 KCoreConfigSkeleton::ItemRect *KCoreConfigSkeleton::addItemRect(const QString &name, QRect &reference, const QRect &defaultValue, const QString &key) 1425 { 1426 KCoreConfigSkeleton::ItemRect *item; 1427 item = new KCoreConfigSkeleton::ItemRect(d->mCurrentGroup, key.isNull() ? name : key, reference, defaultValue); 1428 addItem(item, name); 1429 return item; 1430 } 1431 1432 KCoreConfigSkeleton::ItemPoint *KCoreConfigSkeleton::addItemPoint(const QString &name, QPoint &reference, const QPoint &defaultValue, const QString &key) 1433 { 1434 KCoreConfigSkeleton::ItemPoint *item; 1435 item = new KCoreConfigSkeleton::ItemPoint(d->mCurrentGroup, key.isNull() ? name : key, reference, defaultValue); 1436 addItem(item, name); 1437 return item; 1438 } 1439 1440 KCoreConfigSkeleton::ItemSize *KCoreConfigSkeleton::addItemSize(const QString &name, QSize &reference, const QSize &defaultValue, const QString &key) 1441 { 1442 KCoreConfigSkeleton::ItemSize *item; 1443 item = new KCoreConfigSkeleton::ItemSize(d->mCurrentGroup, key.isNull() ? name : key, reference, defaultValue); 1444 addItem(item, name); 1445 return item; 1446 } 1447 1448 KCoreConfigSkeleton::ItemDateTime * 1449 KCoreConfigSkeleton::addItemDateTime(const QString &name, QDateTime &reference, const QDateTime &defaultValue, const QString &key) 1450 { 1451 KCoreConfigSkeleton::ItemDateTime *item; 1452 item = new KCoreConfigSkeleton::ItemDateTime(d->mCurrentGroup, key.isNull() ? name : key, reference, defaultValue); 1453 addItem(item, name); 1454 return item; 1455 } 1456 1457 KCoreConfigSkeleton::ItemStringList * 1458 KCoreConfigSkeleton::addItemStringList(const QString &name, QStringList &reference, const QStringList &defaultValue, const QString &key) 1459 { 1460 KCoreConfigSkeleton::ItemStringList *item; 1461 item = new KCoreConfigSkeleton::ItemStringList(d->mCurrentGroup, key.isNull() ? name : key, reference, defaultValue); 1462 addItem(item, name); 1463 return item; 1464 } 1465 1466 KCoreConfigSkeleton::ItemIntList * 1467 KCoreConfigSkeleton::addItemIntList(const QString &name, QList<int> &reference, const QList<int> &defaultValue, const QString &key) 1468 { 1469 KCoreConfigSkeleton::ItemIntList *item; 1470 item = new KCoreConfigSkeleton::ItemIntList(d->mCurrentGroup, key.isNull() ? name : key, reference, defaultValue); 1471 addItem(item, name); 1472 return item; 1473 } 1474 1475 bool KCoreConfigSkeleton::isImmutable(const QString &name) const 1476 { 1477 KConfigSkeletonItem *item = findItem(name); 1478 return !item || item->isImmutable(); 1479 } 1480 1481 KConfigSkeletonItem *KCoreConfigSkeleton::findItem(const QString &name) const 1482 { 1483 return d->mItemDict.value(name); 1484 } 1485 1486 KConfigCompilerSignallingItem::KConfigCompilerSignallingItem(KConfigSkeletonItem *item, 1487 QObject *object, 1488 KConfigCompilerSignallingItem::NotifyFunction targetFunction, 1489 quint64 userData) 1490 : KConfigSkeletonItem(item->group(), item->key()) 1491 , mItem(item) 1492 , mTargetFunction(targetFunction) 1493 , mObject(object) 1494 , mUserData(userData) 1495 { 1496 Q_ASSERT(mTargetFunction); 1497 Q_ASSERT(mItem); 1498 Q_ASSERT(mObject); 1499 1500 setIsDefaultImpl([this] { 1501 return mItem->isDefault(); 1502 }); 1503 setIsSaveNeededImpl([this] { 1504 return mItem->isSaveNeeded(); 1505 }); 1506 setGetDefaultImpl([this] { 1507 return mItem->getDefault(); 1508 }); 1509 } 1510 1511 KConfigCompilerSignallingItem::~KConfigCompilerSignallingItem() 1512 { 1513 } 1514 1515 bool KConfigCompilerSignallingItem::isEqual(const QVariant &p) const 1516 { 1517 return mItem->isEqual(p); 1518 } 1519 1520 QVariant KConfigCompilerSignallingItem::property() const 1521 { 1522 return mItem->property(); 1523 } 1524 1525 QVariant KConfigCompilerSignallingItem::minValue() const 1526 { 1527 return mItem->minValue(); 1528 } 1529 1530 QVariant KConfigCompilerSignallingItem::maxValue() const 1531 { 1532 return mItem->maxValue(); 1533 } 1534 1535 void KConfigCompilerSignallingItem::readConfig(KConfig *c) 1536 { 1537 QVariant oldValue = mItem->property(); 1538 mItem->readConfig(c); 1539 // readConfig() changes mIsImmutable, update it here as well 1540 KConfigGroup cg = configGroup(c); 1541 readImmutability(cg); 1542 if (!mItem->isEqual(oldValue)) { 1543 invokeNotifyFunction(); 1544 } 1545 } 1546 1547 void KConfigCompilerSignallingItem::readDefault(KConfig *c) 1548 { 1549 mItem->readDefault(c); 1550 // readDefault() changes mIsImmutable, update it here as well 1551 KConfigGroup cg = configGroup(c); 1552 readImmutability(cg); 1553 } 1554 1555 void KConfigCompilerSignallingItem::writeConfig(KConfig *c) 1556 { 1557 mItem->writeConfig(c); 1558 } 1559 1560 void KConfigCompilerSignallingItem::setDefault() 1561 { 1562 QVariant oldValue = mItem->property(); 1563 mItem->setDefault(); 1564 if (!mItem->isEqual(oldValue)) { 1565 invokeNotifyFunction(); 1566 } 1567 } 1568 1569 void KConfigCompilerSignallingItem::setProperty(const QVariant &p) 1570 { 1571 if (!mItem->isEqual(p)) { 1572 mItem->setProperty(p); 1573 invokeNotifyFunction(); 1574 } 1575 } 1576 1577 void KConfigCompilerSignallingItem::swapDefault() 1578 { 1579 QVariant oldValue = mItem->property(); 1580 mItem->swapDefault(); 1581 if (!mItem->isEqual(oldValue)) { 1582 invokeNotifyFunction(); 1583 } 1584 } 1585 1586 void KConfigCompilerSignallingItem::setWriteFlags(KConfigBase::WriteConfigFlags flags) 1587 { 1588 mItem->setWriteFlags(flags); 1589 } 1590 1591 KConfigBase::WriteConfigFlags KConfigCompilerSignallingItem::writeFlags() const 1592 { 1593 return mItem->writeFlags(); 1594 } 1595 1596 void KConfigCompilerSignallingItem::setGroup(const KConfigGroup &cg) 1597 { 1598 mItem->setGroup(cg); 1599 } 1600 1601 KConfigGroup KConfigCompilerSignallingItem::configGroup(KConfig *config) const 1602 { 1603 return mItem->configGroup(config); 1604 } 1605 1606 #include "moc_kcoreconfigskeleton.cpp"