1/*
2 This file is part of KOrganizer.
3 SPDX-FileCopyrightText: 2000, 2001 Cornelius Schumacher <schumacher@kde.org>
4 SPDX-FileCopyrightText: 2003 Waldo Bastian <bastian@kde.org>
5
6 SPDX-License-Identifier: LGPL-2.0-or-later
7*/
8
9#include "kcoreconfigskeleton.h"
10#include "kcoreconfigskeleton_p.h"
11
12#include <QUrl>
13
14#include <algorithm>
15
16static QString obscuredString(const QString &str)
17{
18 QString result;
19 const QChar *unicode = str.unicode();
20 for (int i = 0; i < str.length(); ++i) {
21 // yes, no typo. can't encode ' ' or '!' because
22 // they're the unicode BOM. stupid scrambling. stupid.
23 result += (unicode[i].unicode() <= 0x21) ? unicode[i] : QChar(0x1001F - unicode[i].unicode());
24 }
25
26 return result;
27}
28
29KConfigSkeletonItemPrivate::~KConfigSkeletonItemPrivate() = default;
30
31KConfigSkeletonItem::KConfigSkeletonItem(const QString &_group, const QString &_key)
32 : mGroup(_group)
33 , mKey(_key)
34 , d_ptr(new KConfigSkeletonItemPrivate)
35{
36}
37
38KConfigSkeletonItem::KConfigSkeletonItem(KConfigSkeletonItemPrivate &dd, const QString &_group, const QString &_key)
39 : mGroup(_group)
40 , mKey(_key)
41 , d_ptr(&dd)
42{
43}
44
45KConfigSkeletonItem::~KConfigSkeletonItem()
46{
47 delete d_ptr;
48}
49
50void KConfigSkeletonItem::setGroup(const QString &_group)
51{
52 mGroup = _group;
53}
54
55void KConfigSkeletonItem::setGroup(const KConfigGroup &cg)
56{
57 Q_D(KConfigSkeletonItem);
58 d->mConfigGroup = cg;
59}
60
61KConfigGroup KConfigSkeletonItem::configGroup(KConfig *config) const
62{
63 Q_D(const KConfigSkeletonItem);
64 if (d->mConfigGroup.isValid()) {
65 return d->mConfigGroup;
66 }
67 return KConfigGroup(config, mGroup);
68}
69
70QString KConfigSkeletonItem::group() const
71{
72 return mGroup;
73}
74
75void KConfigSkeletonItem::setKey(const QString &_key)
76{
77 mKey = _key;
78}
79
80QString KConfigSkeletonItem::key() const
81{
82 return mKey;
83}
84
85void KConfigSkeletonItem::setName(const QString &_name)
86{
87 mName = _name;
88}
89
90QString KConfigSkeletonItem::name() const
91{
92 return mName;
93}
94
95void KConfigSkeletonItem::setLabel(const QString &l)
96{
97 Q_D(KConfigSkeletonItem);
98 d->mLabel = l;
99}
100
101QString KConfigSkeletonItem::label() const
102{
103 Q_D(const KConfigSkeletonItem);
104 return d->mLabel;
105}
106
107void KConfigSkeletonItem::setToolTip(const QString &t)
108{
109 Q_D(KConfigSkeletonItem);
110 d->mToolTip = t;
111}
112
113QString KConfigSkeletonItem::toolTip() const
114{
115 Q_D(const KConfigSkeletonItem);
116 return d->mToolTip;
117}
118
119void KConfigSkeletonItem::setWhatsThis(const QString &w)
120{
121 Q_D(KConfigSkeletonItem);
122 d->mWhatsThis = w;
123}
124
125QString KConfigSkeletonItem::whatsThis() const
126{
127 Q_D(const KConfigSkeletonItem);
128 return d->mWhatsThis;
129}
130
131void KConfigSkeletonItem::setWriteFlags(KConfigBase::WriteConfigFlags flags)
132{
133 Q_D(KConfigSkeletonItem);
134 d->mWriteFlags = flags;
135}
136
137KConfigBase::WriteConfigFlags KConfigSkeletonItem::writeFlags() const
138{
139 Q_D(const KConfigSkeletonItem);
140 return d->mWriteFlags;
141}
142
143QVariant KConfigSkeletonItem::minValue() const
144{
145 return QVariant();
146}
147
148QVariant KConfigSkeletonItem::maxValue() const
149{
150 return QVariant();
151}
152
153bool KConfigSkeletonItem::isImmutable() const
154{
155 Q_D(const KConfigSkeletonItem);
156 return d->mIsImmutable;
157}
158
159bool KConfigSkeletonItem::isDefault() const
160{
161 Q_D(const KConfigSkeletonItem);
162 return d->mIsDefaultImpl();
163}
164
165bool KConfigSkeletonItem::isSaveNeeded() const
166{
167 Q_D(const KConfigSkeletonItem);
168 return d->mIsSaveNeededImpl();
169}
170
171QVariant KConfigSkeletonItem::getDefault() const
172{
173 Q_D(const KConfigSkeletonItem);
174 return d->mGetDefaultImpl();
175}
176
177void KConfigSkeletonItem::readImmutability(const KConfigGroup &group)
178{
179 Q_D(KConfigSkeletonItem);
180 d->mIsImmutable = group.isEntryImmutable(key: mKey);
181}
182
183void KConfigSkeletonItem::setIsDefaultImpl(const std::function<bool()> &impl)
184{
185 Q_D(KConfigSkeletonItem);
186 d->mIsDefaultImpl = impl;
187}
188
189void KConfigSkeletonItem::setIsSaveNeededImpl(const std::function<bool()> &impl)
190{
191 Q_D(KConfigSkeletonItem);
192 d->mIsSaveNeededImpl = impl;
193}
194
195void KConfigSkeletonItem::setGetDefaultImpl(const std::function<QVariant()> &impl)
196{
197 Q_D(KConfigSkeletonItem);
198 d->mGetDefaultImpl = impl;
199}
200
201KPropertySkeletonItem::KPropertySkeletonItem(QObject *object, const QByteArray &propertyName, const QVariant &defaultValue)
202 : KConfigSkeletonItem(*new KPropertySkeletonItemPrivate(object, propertyName, defaultValue), {}, {})
203{
204 setIsDefaultImpl([this] {
205 Q_D(const KPropertySkeletonItem);
206 return d->mReference == d->mDefaultValue;
207 });
208 setIsSaveNeededImpl([this] {
209 Q_D(const KPropertySkeletonItem);
210 return d->mReference != d->mLoadedValue;
211 });
212 setGetDefaultImpl([this] {
213 Q_D(const KPropertySkeletonItem);
214 return d->mDefaultValue;
215 });
216}
217
218QVariant KPropertySkeletonItem::property() const
219{
220 Q_D(const KPropertySkeletonItem);
221 return d->mReference;
222}
223
224void KPropertySkeletonItem::setProperty(const QVariant &p)
225{
226 Q_D(KPropertySkeletonItem);
227 if (d->mReference == p) {
228 return;
229 }
230 d->mReference = p;
231 if (d->mNotifyFunction) {
232 d->mNotifyFunction();
233 }
234}
235
236bool KPropertySkeletonItem::isEqual(const QVariant &p) const
237{
238 Q_D(const KPropertySkeletonItem);
239 return d->mReference == p;
240}
241
242void KPropertySkeletonItem::readConfig(KConfig *)
243{
244 Q_D(KPropertySkeletonItem);
245 setProperty(d->mObject->property(name: d->mPropertyName.constData()));
246 d->mLoadedValue = d->mReference;
247}
248
249void KPropertySkeletonItem::writeConfig(KConfig *)
250{
251 Q_D(KPropertySkeletonItem);
252 d->mObject->setProperty(name: d->mPropertyName.constData(), value: d->mReference);
253 d->mLoadedValue = d->mReference;
254}
255
256void KPropertySkeletonItem::readDefault(KConfig *)
257{
258 Q_D(KPropertySkeletonItem);
259 setProperty(d->mConstDefaultValue);
260}
261
262void KPropertySkeletonItem::setDefault()
263{
264 Q_D(KPropertySkeletonItem);
265 setProperty(d->mDefaultValue);
266}
267
268void KPropertySkeletonItem::swapDefault()
269{
270 Q_D(KPropertySkeletonItem);
271 if (d->mReference == d->mDefaultValue) {
272 return;
273 }
274 std::swap(a&: d->mReference, b&: d->mDefaultValue);
275 if (d->mNotifyFunction) {
276 d->mNotifyFunction();
277 }
278}
279
280void KPropertySkeletonItem::setNotifyFunction(const std::function<void()> &impl)
281{
282 Q_D(KPropertySkeletonItem);
283 d->mNotifyFunction = impl;
284}
285
286KCoreConfigSkeleton::ItemString::ItemString(const QString &_group, const QString &_key, QString &reference, const QString &defaultValue, Type type)
287 : KConfigSkeletonGenericItem<QString>(_group, _key, reference, defaultValue)
288 , mType(type)
289{
290}
291
292void KCoreConfigSkeleton::ItemString::writeConfig(KConfig *config)
293{
294 if (mReference != mLoadedValue) { // WABA: Is this test needed?
295 KConfigGroup cg = configGroup(config);
296 if ((mDefault == mReference) && !cg.hasDefault(key: mKey)) {
297 cg.revertToDefault(key: mKey, pFlag: writeFlags());
298 } else if (mType == Path) {
299 cg.writePathEntry(pKey: mKey, path: mReference, pFlags: writeFlags());
300 } else if (mType == Password) {
301 cg.writeEntry(key: mKey, value: obscuredString(str: mReference), pFlags: writeFlags());
302 } else {
303 cg.writeEntry(key: mKey, value: mReference, pFlags: writeFlags());
304 }
305 mLoadedValue = mReference;
306 }
307}
308
309void KCoreConfigSkeleton::ItemString::readConfig(KConfig *config)
310{
311 KConfigGroup cg = configGroup(config);
312
313 if (mType == Path) {
314 mReference = cg.readPathEntry(pKey: mKey, aDefault: mDefault);
315 } else if (mType == Password) {
316 QString val = cg.readEntry(key: mKey, aDefault: obscuredString(str: mDefault));
317 mReference = obscuredString(str: val);
318 } else {
319 mReference = cg.readEntry(key: mKey, aDefault: mDefault);
320 }
321
322 mLoadedValue = mReference;
323
324 readImmutability(group: cg);
325}
326
327void KCoreConfigSkeleton::ItemString::setProperty(const QVariant &p)
328{
329 mReference = p.toString();
330}
331
332bool KCoreConfigSkeleton::ItemString::isEqual(const QVariant &v) const
333{
334 return mReference == v.toString();
335}
336
337QVariant KCoreConfigSkeleton::ItemString::property() const
338{
339 return QVariant(mReference);
340}
341
342KCoreConfigSkeleton::ItemPassword::ItemPassword(const QString &_group, const QString &_key, QString &reference, const QString &defaultValue)
343 : ItemString(_group, _key, reference, defaultValue, Password)
344{
345}
346
347KCoreConfigSkeleton::ItemPath::ItemPath(const QString &_group, const QString &_key, QString &reference, const QString &defaultValue)
348 : ItemString(_group, _key, reference, defaultValue, Path)
349{
350}
351
352KCoreConfigSkeleton::ItemUrl::ItemUrl(const QString &_group, const QString &_key, QUrl &reference, const QUrl &defaultValue)
353 : KConfigSkeletonGenericItem<QUrl>(_group, _key, reference, defaultValue)
354{
355}
356
357void KCoreConfigSkeleton::ItemUrl::writeConfig(KConfig *config)
358{
359 if (mReference != mLoadedValue) { // WABA: Is this test needed?
360 KConfigGroup cg = configGroup(config);
361 if ((mDefault == mReference) && !cg.hasDefault(key: mKey)) {
362 cg.revertToDefault(key: mKey, pFlag: writeFlags());
363 } else {
364 cg.writeEntry<QString>(key: mKey, value: mReference.toString(), pFlags: writeFlags());
365 }
366 mLoadedValue = mReference;
367 }
368}
369
370void KCoreConfigSkeleton::ItemUrl::readConfig(KConfig *config)
371{
372 KConfigGroup cg = configGroup(config);
373
374 mReference = QUrl(cg.readEntry<QString>(key: mKey, aDefault: mDefault.toString()));
375 mLoadedValue = mReference;
376
377 readImmutability(group: cg);
378}
379
380void KCoreConfigSkeleton::ItemUrl::setProperty(const QVariant &p)
381{
382 mReference = qvariant_cast<QUrl>(v: p);
383}
384
385bool KCoreConfigSkeleton::ItemUrl::isEqual(const QVariant &v) const
386{
387 return mReference == qvariant_cast<QUrl>(v);
388}
389
390QVariant KCoreConfigSkeleton::ItemUrl::property() const
391{
392 return QVariant::fromValue<QUrl>(value: mReference);
393}
394
395KCoreConfigSkeleton::ItemProperty::ItemProperty(const QString &_group, const QString &_key, QVariant &reference, const QVariant &defaultValue)
396 : KConfigSkeletonGenericItem<QVariant>(_group, _key, reference, defaultValue)
397{
398}
399
400void KCoreConfigSkeleton::ItemProperty::readConfig(KConfig *config)
401{
402 KConfigGroup cg = configGroup(config);
403 mReference = cg.readEntry(key: mKey, aDefault: mDefault);
404 mLoadedValue = mReference;
405
406 readImmutability(group: cg);
407}
408
409void KCoreConfigSkeleton::ItemProperty::setProperty(const QVariant &p)
410{
411 mReference = p;
412}
413
414bool KCoreConfigSkeleton::ItemProperty::isEqual(const QVariant &v) const
415{
416 // this might cause problems if the QVariants are not of default types
417 return mReference == v;
418}
419
420QVariant KCoreConfigSkeleton::ItemProperty::property() const
421{
422 return mReference;
423}
424
425KCoreConfigSkeleton::ItemBool::ItemBool(const QString &_group, const QString &_key, bool &reference, bool defaultValue)
426 : KConfigSkeletonGenericItem<bool>(_group, _key, reference, defaultValue)
427{
428}
429
430void KCoreConfigSkeleton::ItemBool::readConfig(KConfig *config)
431{
432 KConfigGroup cg = configGroup(config);
433 mReference = cg.readEntry(key: mKey, aDefault: mDefault);
434 mLoadedValue = mReference;
435
436 readImmutability(group: cg);
437}
438
439void KCoreConfigSkeleton::ItemBool::setProperty(const QVariant &p)
440{
441 mReference = p.toBool();
442}
443
444bool KCoreConfigSkeleton::ItemBool::isEqual(const QVariant &v) const
445{
446 return mReference == v.toBool();
447}
448
449QVariant KCoreConfigSkeleton::ItemBool::property() const
450{
451 return QVariant(mReference);
452}
453
454KCoreConfigSkeleton::ItemInt::ItemInt(const QString &_group, const QString &_key, qint32 &reference, qint32 defaultValue)
455 : KConfigSkeletonGenericItem<qint32>(_group, _key, reference, defaultValue)
456 , mHasMin(false)
457 , mHasMax(false)
458{
459}
460
461void KCoreConfigSkeleton::ItemInt::readConfig(KConfig *config)
462{
463 KConfigGroup cg = configGroup(config);
464 mReference = cg.readEntry(key: mKey, aDefault: mDefault);
465 if (mHasMin) {
466 mReference = qMax(a: mReference, b: mMin);
467 }
468 if (mHasMax) {
469 mReference = qMin(a: mReference, b: mMax);
470 }
471 mLoadedValue = mReference;
472
473 readImmutability(group: cg);
474}
475
476void KCoreConfigSkeleton::ItemInt::setProperty(const QVariant &p)
477{
478 mReference = p.toInt();
479}
480
481bool KCoreConfigSkeleton::ItemInt::isEqual(const QVariant &v) const
482{
483 return mReference == v.toInt();
484}
485
486QVariant KCoreConfigSkeleton::ItemInt::property() const
487{
488 return QVariant(mReference);
489}
490
491QVariant KCoreConfigSkeleton::ItemInt::minValue() const
492{
493 if (mHasMin) {
494 return QVariant(mMin);
495 }
496 return QVariant();
497}
498
499QVariant KCoreConfigSkeleton::ItemInt::maxValue() const
500{
501 if (mHasMax) {
502 return QVariant(mMax);
503 }
504 return QVariant();
505}
506
507void KCoreConfigSkeleton::ItemInt::setMinValue(qint32 v)
508{
509 mHasMin = true;
510 mMin = v;
511}
512
513void KCoreConfigSkeleton::ItemInt::setMaxValue(qint32 v)
514{
515 mHasMax = true;
516 mMax = v;
517}
518
519KCoreConfigSkeleton::ItemLongLong::ItemLongLong(const QString &_group, const QString &_key, qint64 &reference, qint64 defaultValue)
520 : KConfigSkeletonGenericItem<qint64>(_group, _key, reference, defaultValue)
521 , mHasMin(false)
522 , mHasMax(false)
523{
524}
525
526void KCoreConfigSkeleton::ItemLongLong::readConfig(KConfig *config)
527{
528 KConfigGroup cg = configGroup(config);
529 mReference = cg.readEntry(key: mKey, aDefault: mDefault);
530 if (mHasMin) {
531 mReference = qMax(a: mReference, b: mMin);
532 }
533 if (mHasMax) {
534 mReference = qMin(a: mReference, b: mMax);
535 }
536 mLoadedValue = mReference;
537
538 readImmutability(group: cg);
539}
540
541void KCoreConfigSkeleton::ItemLongLong::setProperty(const QVariant &p)
542{
543 mReference = p.toLongLong();
544}
545
546bool KCoreConfigSkeleton::ItemLongLong::isEqual(const QVariant &v) const
547{
548 return mReference == v.toLongLong();
549}
550
551QVariant KCoreConfigSkeleton::ItemLongLong::property() const
552{
553 return QVariant(mReference);
554}
555
556QVariant KCoreConfigSkeleton::ItemLongLong::minValue() const
557{
558 if (mHasMin) {
559 return QVariant(mMin);
560 }
561 return QVariant();
562}
563
564QVariant KCoreConfigSkeleton::ItemLongLong::maxValue() const
565{
566 if (mHasMax) {
567 return QVariant(mMax);
568 }
569 return QVariant();
570}
571
572void KCoreConfigSkeleton::ItemLongLong::setMinValue(qint64 v)
573{
574 mHasMin = true;
575 mMin = v;
576}
577
578void KCoreConfigSkeleton::ItemLongLong::setMaxValue(qint64 v)
579{
580 mHasMax = true;
581 mMax = v;
582}
583
584QString KCoreConfigSkeleton::ItemEnum::valueForChoice(const QString &name) const
585{
586 for (auto it = mChoices.cbegin(); it != mChoices.cend(); ++it) {
587 if (it->name == name) {
588 return it->value.isEmpty() ? it->name : it->value;
589 }
590 }
591 return name;
592}
593
594void KCoreConfigSkeleton::ItemEnum::setValueForChoice(const QString &name, const QString &value)
595{
596 for (auto it = mChoices.begin(); it != mChoices.end(); ++it) {
597 if (it->name == name) {
598 it->value = value;
599 return;
600 }
601 }
602}
603
604KCoreConfigSkeleton::ItemEnum::ItemEnum(const QString &_group, const QString &_key, qint32 &reference, const QList<Choice> &choices, qint32 defaultValue)
605 : ItemInt(_group, _key, reference, defaultValue)
606 , mChoices(choices)
607{
608}
609
610void KCoreConfigSkeleton::ItemEnum::readConfig(KConfig *config)
611{
612 KConfigGroup cg = configGroup(config);
613 if (!cg.hasKey(key: mKey)) {
614 mReference = mDefault;
615 } else {
616 int i = 0;
617 mReference = -1;
618 const QString entryString = cg.readEntry(key: mKey, aDefault: QString());
619 for (auto it = mChoices.cbegin(); it != mChoices.cend(); ++it, ++i) {
620 QString choiceName = (*it).name;
621 if (valueForChoice(name: choiceName).compare(s: entryString, cs: Qt::CaseInsensitive) == 0) {
622 mReference = i;
623 break;
624 }
625 }
626 if (mReference == -1) {
627 mReference = cg.readEntry(key: mKey, aDefault: mDefault);
628 }
629 }
630 mLoadedValue = mReference;
631
632 readImmutability(group: cg);
633}
634
635void KCoreConfigSkeleton::ItemEnum::writeConfig(KConfig *config)
636{
637 if (mReference != mLoadedValue) { // WABA: Is this test needed?
638 KConfigGroup cg = configGroup(config);
639 if ((mDefault == mReference) && !cg.hasDefault(key: mKey)) {
640 cg.revertToDefault(key: mKey, pFlag: writeFlags());
641 } else if ((mReference >= 0) && (mReference < mChoices.count())) {
642 cg.writeEntry(key: mKey, value: valueForChoice(name: mChoices.at(i: mReference).name), pFlags: writeFlags());
643 } else {
644 cg.writeEntry(key: mKey, value: mReference, pFlags: writeFlags());
645 }
646 mLoadedValue = mReference;
647 }
648}
649
650QList<KCoreConfigSkeleton::ItemEnum::Choice> KCoreConfigSkeleton::ItemEnum::choices() const
651{
652 return mChoices;
653}
654
655KCoreConfigSkeleton::ItemUInt::ItemUInt(const QString &_group, const QString &_key, quint32 &reference, quint32 defaultValue)
656 : KConfigSkeletonGenericItem<quint32>(_group, _key, reference, defaultValue)
657 , mHasMin(false)
658 , mHasMax(false)
659{
660}
661
662void KCoreConfigSkeleton::ItemUInt::readConfig(KConfig *config)
663{
664 KConfigGroup cg = configGroup(config);
665 mReference = cg.readEntry(key: mKey, aDefault: mDefault);
666 if (mHasMin) {
667 mReference = qMax(a: mReference, b: mMin);
668 }
669 if (mHasMax) {
670 mReference = qMin(a: mReference, b: mMax);
671 }
672 mLoadedValue = mReference;
673
674 readImmutability(group: cg);
675}
676
677void KCoreConfigSkeleton::ItemUInt::setProperty(const QVariant &p)
678{
679 mReference = p.toUInt();
680}
681
682bool KCoreConfigSkeleton::ItemUInt::isEqual(const QVariant &v) const
683{
684 return mReference == v.toUInt();
685}
686
687QVariant KCoreConfigSkeleton::ItemUInt::property() const
688{
689 return QVariant(mReference);
690}
691
692QVariant KCoreConfigSkeleton::ItemUInt::minValue() const
693{
694 if (mHasMin) {
695 return QVariant(mMin);
696 }
697 return QVariant();
698}
699
700QVariant KCoreConfigSkeleton::ItemUInt::maxValue() const
701{
702 if (mHasMax) {
703 return QVariant(mMax);
704 }
705 return QVariant();
706}
707
708void KCoreConfigSkeleton::ItemUInt::setMinValue(quint32 v)
709{
710 mHasMin = true;
711 mMin = v;
712}
713
714void KCoreConfigSkeleton::ItemUInt::setMaxValue(quint32 v)
715{
716 mHasMax = true;
717 mMax = v;
718}
719
720KCoreConfigSkeleton::ItemULongLong::ItemULongLong(const QString &_group, const QString &_key, quint64 &reference, quint64 defaultValue)
721 : KConfigSkeletonGenericItem<quint64>(_group, _key, reference, defaultValue)
722 , mHasMin(false)
723 , mHasMax(false)
724{
725}
726
727void KCoreConfigSkeleton::ItemULongLong::readConfig(KConfig *config)
728{
729 KConfigGroup cg = configGroup(config);
730 mReference = cg.readEntry(key: mKey, aDefault: mDefault);
731 if (mHasMin) {
732 mReference = qMax(a: mReference, b: mMin);
733 }
734 if (mHasMax) {
735 mReference = qMin(a: mReference, b: mMax);
736 }
737 mLoadedValue = mReference;
738
739 readImmutability(group: cg);
740}
741
742void KCoreConfigSkeleton::ItemULongLong::setProperty(const QVariant &p)
743{
744 mReference = p.toULongLong();
745}
746
747bool KCoreConfigSkeleton::ItemULongLong::isEqual(const QVariant &v) const
748{
749 return mReference == v.toULongLong();
750}
751
752QVariant KCoreConfigSkeleton::ItemULongLong::property() const
753{
754 return QVariant(mReference);
755}
756
757QVariant KCoreConfigSkeleton::ItemULongLong::minValue() const
758{
759 if (mHasMin) {
760 return QVariant(mMin);
761 }
762 return QVariant();
763}
764
765QVariant KCoreConfigSkeleton::ItemULongLong::maxValue() const
766{
767 if (mHasMax) {
768 return QVariant(mMax);
769 }
770 return QVariant();
771}
772
773void KCoreConfigSkeleton::ItemULongLong::setMinValue(quint64 v)
774{
775 mHasMin = true;
776 mMin = v;
777}
778
779void KCoreConfigSkeleton::ItemULongLong::setMaxValue(quint64 v)
780{
781 mHasMax = true;
782 mMax = v;
783}
784
785KCoreConfigSkeleton::ItemDouble::ItemDouble(const QString &_group, const QString &_key, double &reference, double defaultValue)
786 : KConfigSkeletonGenericItem<double>(_group, _key, reference, defaultValue)
787 , mHasMin(false)
788 , mHasMax(false)
789{
790}
791
792void KCoreConfigSkeleton::ItemDouble::readConfig(KConfig *config)
793{
794 KConfigGroup cg = configGroup(config);
795 mReference = cg.readEntry(key: mKey, aDefault: mDefault);
796 if (mHasMin) {
797 mReference = qMax(a: mReference, b: mMin);
798 }
799 if (mHasMax) {
800 mReference = qMin(a: mReference, b: mMax);
801 }
802 mLoadedValue = mReference;
803
804 readImmutability(group: cg);
805}
806
807void KCoreConfigSkeleton::ItemDouble::setProperty(const QVariant &p)
808{
809 mReference = p.toDouble();
810}
811
812bool KCoreConfigSkeleton::ItemDouble::isEqual(const QVariant &v) const
813{
814 return mReference == v.toDouble();
815}
816
817QVariant KCoreConfigSkeleton::ItemDouble::property() const
818{
819 return QVariant(mReference);
820}
821
822QVariant KCoreConfigSkeleton::ItemDouble::minValue() const
823{
824 if (mHasMin) {
825 return QVariant(mMin);
826 }
827 return QVariant();
828}
829
830QVariant KCoreConfigSkeleton::ItemDouble::maxValue() const
831{
832 if (mHasMax) {
833 return QVariant(mMax);
834 }
835 return QVariant();
836}
837
838void KCoreConfigSkeleton::ItemDouble::setMinValue(double v)
839{
840 mHasMin = true;
841 mMin = v;
842}
843
844void KCoreConfigSkeleton::ItemDouble::setMaxValue(double v)
845{
846 mHasMax = true;
847 mMax = v;
848}
849
850KCoreConfigSkeleton::ItemRect::ItemRect(const QString &_group, const QString &_key, QRect &reference, const QRect &defaultValue)
851 : KConfigSkeletonGenericItem<QRect>(_group, _key, reference, defaultValue)
852{
853}
854
855void KCoreConfigSkeleton::ItemRect::readConfig(KConfig *config)
856{
857 KConfigGroup cg = configGroup(config);
858 mReference = cg.readEntry(key: mKey, aDefault: mDefault);
859 mLoadedValue = mReference;
860
861 readImmutability(group: cg);
862}
863
864void KCoreConfigSkeleton::ItemRect::setProperty(const QVariant &p)
865{
866 mReference = p.toRect();
867}
868
869bool KCoreConfigSkeleton::ItemRect::isEqual(const QVariant &v) const
870{
871 return mReference == v.toRect();
872}
873
874QVariant KCoreConfigSkeleton::ItemRect::property() const
875{
876 return QVariant(mReference);
877}
878
879KCoreConfigSkeleton::ItemRectF::ItemRectF(const QString &_group, const QString &_key, QRectF &reference, const QRectF &defaultValue)
880 : KConfigSkeletonGenericItem<QRectF>(_group, _key, reference, defaultValue)
881{
882}
883
884void KCoreConfigSkeleton::ItemRectF::readConfig(KConfig *config)
885{
886 KConfigGroup cg = configGroup(config);
887 mReference = cg.readEntry(key: mKey, aDefault: mDefault);
888 mLoadedValue = mReference;
889
890 readImmutability(group: cg);
891}
892
893void KCoreConfigSkeleton::ItemRectF::setProperty(const QVariant &p)
894{
895 mReference = p.toRectF();
896}
897
898bool KCoreConfigSkeleton::ItemRectF::isEqual(const QVariant &v) const
899{
900 return mReference == v.toRectF();
901}
902
903QVariant KCoreConfigSkeleton::ItemRectF::property() const
904{
905 return QVariant(mReference);
906}
907
908KCoreConfigSkeleton::ItemPoint::ItemPoint(const QString &_group, const QString &_key, QPoint &reference, const QPoint &defaultValue)
909 : KConfigSkeletonGenericItem<QPoint>(_group, _key, reference, defaultValue)
910{
911}
912
913void KCoreConfigSkeleton::ItemPoint::readConfig(KConfig *config)
914{
915 KConfigGroup cg = configGroup(config);
916 mReference = cg.readEntry(key: mKey, aDefault: mDefault);
917 mLoadedValue = mReference;
918
919 readImmutability(group: cg);
920}
921
922void KCoreConfigSkeleton::ItemPoint::setProperty(const QVariant &p)
923{
924 mReference = p.toPoint();
925}
926
927bool KCoreConfigSkeleton::ItemPoint::isEqual(const QVariant &v) const
928{
929 return mReference == v.toPoint();
930}
931
932QVariant KCoreConfigSkeleton::ItemPoint::property() const
933{
934 return QVariant(mReference);
935}
936
937KCoreConfigSkeleton::ItemPointF::ItemPointF(const QString &_group, const QString &_key, QPointF &reference, const QPointF &defaultValue)
938 : KConfigSkeletonGenericItem<QPointF>(_group, _key, reference, defaultValue)
939{
940}
941
942void KCoreConfigSkeleton::ItemPointF::readConfig(KConfig *config)
943{
944 KConfigGroup cg = configGroup(config);
945 mReference = cg.readEntry(key: mKey, aDefault: mDefault);
946 mLoadedValue = mReference;
947
948 readImmutability(group: cg);
949}
950
951void KCoreConfigSkeleton::ItemPointF::setProperty(const QVariant &p)
952{
953 mReference = p.toPointF();
954}
955
956bool KCoreConfigSkeleton::ItemPointF::isEqual(const QVariant &v) const
957{
958 return mReference == v.toPointF();
959}
960
961QVariant KCoreConfigSkeleton::ItemPointF::property() const
962{
963 return QVariant(mReference);
964}
965
966KCoreConfigSkeleton::ItemSize::ItemSize(const QString &_group, const QString &_key, QSize &reference, const QSize &defaultValue)
967 : KConfigSkeletonGenericItem<QSize>(_group, _key, reference, defaultValue)
968{
969}
970
971void KCoreConfigSkeleton::ItemSize::readConfig(KConfig *config)
972{
973 KConfigGroup cg = configGroup(config);
974 mReference = cg.readEntry(key: mKey, aDefault: mDefault);
975 mLoadedValue = mReference;
976
977 readImmutability(group: cg);
978}
979
980void KCoreConfigSkeleton::ItemSize::setProperty(const QVariant &p)
981{
982 mReference = p.toSize();
983}
984
985bool KCoreConfigSkeleton::ItemSize::isEqual(const QVariant &v) const
986{
987 return mReference == v.toSize();
988}
989
990QVariant KCoreConfigSkeleton::ItemSize::property() const
991{
992 return QVariant(mReference);
993}
994
995KCoreConfigSkeleton::ItemSizeF::ItemSizeF(const QString &_group, const QString &_key, QSizeF &reference, const QSizeF &defaultValue)
996 : KConfigSkeletonGenericItem<QSizeF>(_group, _key, reference, defaultValue)
997{
998}
999
1000void KCoreConfigSkeleton::ItemSizeF::readConfig(KConfig *config)
1001{
1002 KConfigGroup cg = configGroup(config);
1003 mReference = cg.readEntry(key: mKey, aDefault: mDefault);
1004 mLoadedValue = mReference;
1005
1006 readImmutability(group: cg);
1007}
1008
1009void KCoreConfigSkeleton::ItemSizeF::setProperty(const QVariant &p)
1010{
1011 mReference = p.toSizeF();
1012}
1013
1014bool KCoreConfigSkeleton::ItemSizeF::isEqual(const QVariant &v) const
1015{
1016 return mReference == v.toSizeF();
1017}
1018
1019QVariant KCoreConfigSkeleton::ItemSizeF::property() const
1020{
1021 return QVariant(mReference);
1022}
1023
1024KCoreConfigSkeleton::ItemDateTime::ItemDateTime(const QString &_group, const QString &_key, QDateTime &reference, const QDateTime &defaultValue)
1025 : KConfigSkeletonGenericItem<QDateTime>(_group, _key, reference, defaultValue)
1026{
1027}
1028
1029void KCoreConfigSkeleton::ItemDateTime::readConfig(KConfig *config)
1030{
1031 KConfigGroup cg = configGroup(config);
1032 mReference = cg.readEntry(key: mKey, aDefault: mDefault);
1033 mLoadedValue = mReference;
1034
1035 readImmutability(group: cg);
1036}
1037
1038void KCoreConfigSkeleton::ItemDateTime::setProperty(const QVariant &p)
1039{
1040 mReference = p.toDateTime();
1041}
1042
1043bool KCoreConfigSkeleton::ItemDateTime::isEqual(const QVariant &v) const
1044{
1045 return mReference == v.toDateTime();
1046}
1047
1048QVariant KCoreConfigSkeleton::ItemDateTime::property() const
1049{
1050 return QVariant(mReference);
1051}
1052
1053KCoreConfigSkeleton::ItemTime::ItemTime(const QString &_group, const QString &_key, QTime &reference, QTime defaultValue)
1054 : KConfigSkeletonGenericItem<QTime>(_group, _key, reference, defaultValue)
1055{
1056}
1057
1058void KCoreConfigSkeleton::ItemTime::readConfig(KConfig *config)
1059{
1060 KConfigGroup cg = configGroup(config);
1061 mReference = cg.readEntry(key: mKey, aDefault: mDefault);
1062 mLoadedValue = mReference;
1063
1064 readImmutability(group: cg);
1065}
1066
1067void KCoreConfigSkeleton::ItemTime::setProperty(const QVariant &p)
1068{
1069 mReference = p.toTime();
1070}
1071
1072bool KCoreConfigSkeleton::ItemTime::isEqual(const QVariant &v) const
1073{
1074 return mReference == v.toTime();
1075}
1076
1077QVariant KCoreConfigSkeleton::ItemTime::property() const
1078{
1079 return QVariant(mReference);
1080}
1081
1082KCoreConfigSkeleton::ItemStringList::ItemStringList(const QString &_group, const QString &_key, QStringList &reference, const QStringList &defaultValue)
1083 : KConfigSkeletonGenericItem<QStringList>(_group, _key, reference, defaultValue)
1084{
1085}
1086
1087void KCoreConfigSkeleton::ItemStringList::readConfig(KConfig *config)
1088{
1089 KConfigGroup cg = configGroup(config);
1090 if (!cg.hasKey(key: mKey)) {
1091 mReference = mDefault;
1092 } else {
1093 mReference = cg.readEntry(key: mKey, aDefault: mDefault);
1094 }
1095 mLoadedValue = mReference;
1096
1097 readImmutability(group: cg);
1098}
1099
1100void KCoreConfigSkeleton::ItemStringList::setProperty(const QVariant &p)
1101{
1102 mReference = p.toStringList();
1103}
1104
1105bool KCoreConfigSkeleton::ItemStringList::isEqual(const QVariant &v) const
1106{
1107 return mReference == v.toStringList();
1108}
1109
1110QVariant KCoreConfigSkeleton::ItemStringList::property() const
1111{
1112 return QVariant(mReference);
1113}
1114
1115KCoreConfigSkeleton::ItemPathList::ItemPathList(const QString &_group, const QString &_key, QStringList &reference, const QStringList &defaultValue)
1116 : ItemStringList(_group, _key, reference, defaultValue)
1117{
1118}
1119
1120void KCoreConfigSkeleton::ItemPathList::readConfig(KConfig *config)
1121{
1122 KConfigGroup cg = configGroup(config);
1123 if (!cg.hasKey(key: mKey)) {
1124 mReference = mDefault;
1125 } else {
1126 mReference = cg.readPathEntry(pKey: mKey, aDefault: QStringList());
1127 }
1128 mLoadedValue = mReference;
1129
1130 readImmutability(group: cg);
1131}
1132
1133void KCoreConfigSkeleton::ItemPathList::writeConfig(KConfig *config)
1134{
1135 if (mReference != mLoadedValue) { // WABA: Is this test needed?
1136 KConfigGroup cg = configGroup(config);
1137 if ((mDefault == mReference) && !cg.hasDefault(key: mKey)) {
1138 cg.revertToDefault(key: mKey, pFlag: writeFlags());
1139 } else {
1140 QStringList sl = mReference;
1141 cg.writePathEntry(pKey: mKey, value: sl, pFlags: writeFlags());
1142 }
1143 mLoadedValue = mReference;
1144 }
1145}
1146
1147KCoreConfigSkeleton::ItemUrlList::ItemUrlList(const QString &_group, const QString &_key, QList<QUrl> &reference, const QList<QUrl> &defaultValue)
1148 : KConfigSkeletonGenericItem<QList<QUrl>>(_group, _key, reference, defaultValue)
1149{
1150}
1151
1152void KCoreConfigSkeleton::ItemUrlList::readConfig(KConfig *config)
1153{
1154 KConfigGroup cg = configGroup(config);
1155 if (!cg.hasKey(key: mKey)) {
1156 mReference = mDefault;
1157 } else {
1158 QStringList strList;
1159 for (const QUrl &url : std::as_const(t&: mDefault)) {
1160 strList.append(t: url.toString());
1161 }
1162 mReference.clear();
1163 const QStringList readList = cg.readEntry<QStringList>(key: mKey, aDefault: strList);
1164 for (const QString &str : readList) {
1165 mReference.append(t: QUrl(str));
1166 }
1167 }
1168 mLoadedValue = mReference;
1169
1170 readImmutability(group: cg);
1171}
1172
1173void KCoreConfigSkeleton::ItemUrlList::writeConfig(KConfig *config)
1174{
1175 if (mReference != mLoadedValue) { // WABA: Is this test needed?
1176 KConfigGroup cg = configGroup(config);
1177 if ((mDefault == mReference) && !cg.hasDefault(key: mKey)) {
1178 cg.revertToDefault(key: mKey, pFlag: writeFlags());
1179 } else {
1180 QStringList strList;
1181 for (const QUrl &url : std::as_const(t&: mReference)) {
1182 strList.append(t: url.toString());
1183 }
1184 cg.writeEntry<QStringList>(key: mKey, value: strList, pFlags: writeFlags());
1185 }
1186 mLoadedValue = mReference;
1187 }
1188}
1189
1190void KCoreConfigSkeleton::ItemUrlList::setProperty(const QVariant &p)
1191{
1192 mReference = qvariant_cast<QList<QUrl>>(v: p);
1193}
1194
1195bool KCoreConfigSkeleton::ItemUrlList::isEqual(const QVariant &v) const
1196{
1197 return mReference == qvariant_cast<QList<QUrl>>(v);
1198}
1199
1200QVariant KCoreConfigSkeleton::ItemUrlList::property() const
1201{
1202 return QVariant::fromValue<QList<QUrl>>(value: mReference);
1203}
1204
1205KCoreConfigSkeleton::ItemIntList::ItemIntList(const QString &_group, const QString &_key, QList<int> &reference, const QList<int> &defaultValue)
1206 : KConfigSkeletonGenericItem<QList<int>>(_group, _key, reference, defaultValue)
1207{
1208}
1209
1210void KCoreConfigSkeleton::ItemIntList::readConfig(KConfig *config)
1211{
1212 KConfigGroup cg = configGroup(config);
1213 if (!cg.hasKey(key: mKey)) {
1214 mReference = mDefault;
1215 } else {
1216 mReference = cg.readEntry(key: mKey, aDefault: mDefault);
1217 }
1218 mLoadedValue = mReference;
1219
1220 readImmutability(group: cg);
1221}
1222
1223void KCoreConfigSkeleton::ItemIntList::setProperty(const QVariant &p)
1224{
1225 mReference = qvariant_cast<QList<int>>(v: p);
1226}
1227
1228bool KCoreConfigSkeleton::ItemIntList::isEqual(const QVariant &v) const
1229{
1230 return mReference == qvariant_cast<QList<int>>(v);
1231}
1232
1233QVariant KCoreConfigSkeleton::ItemIntList::property() const
1234{
1235 return QVariant::fromValue<QList<int>>(value: mReference);
1236}
1237
1238// static int kCoreConfigSkeletionDebugArea() { static int s_area = KDebug::registerArea("kdecore (KConfigSkeleton)"); return s_area; }
1239
1240KCoreConfigSkeleton::KCoreConfigSkeleton(const QString &configname, QObject *parent)
1241 : QObject(parent)
1242 , d(new KCoreConfigSkeletonPrivate)
1243{
1244 // qDebug() << "Creating KCoreConfigSkeleton (" << (void *)this << ")";
1245
1246 d->mConfig = KSharedConfig::openConfig(fileName: configname, mode: KConfig::FullConfig);
1247}
1248
1249KCoreConfigSkeleton::KCoreConfigSkeleton(KSharedConfig::Ptr pConfig, QObject *parent)
1250 : QObject(parent)
1251 , d(new KCoreConfigSkeletonPrivate)
1252{
1253 // qDebug() << "Creating KCoreConfigSkeleton (" << (void *)this << ")";
1254 d->mConfig = std::move(pConfig);
1255}
1256
1257KCoreConfigSkeleton::~KCoreConfigSkeleton()
1258{
1259 delete d;
1260}
1261
1262void KCoreConfigSkeleton::setCurrentGroup(const QString &group)
1263{
1264 d->mCurrentGroup = group;
1265}
1266
1267QString KCoreConfigSkeleton::currentGroup() const
1268{
1269 return d->mCurrentGroup;
1270}
1271
1272KConfig *KCoreConfigSkeleton::config()
1273{
1274 return d->mConfig.data();
1275}
1276
1277const KConfig *KCoreConfigSkeleton::config() const
1278{
1279 return d->mConfig.data();
1280}
1281
1282KSharedConfig::Ptr KCoreConfigSkeleton::sharedConfig() const
1283{
1284 return d->mConfig;
1285}
1286
1287void KCoreConfigSkeleton::setSharedConfig(KSharedConfig::Ptr pConfig)
1288{
1289 d->mConfig = std::move(pConfig);
1290}
1291
1292KConfigSkeletonItem::List KCoreConfigSkeleton::items() const
1293{
1294 return d->mItems;
1295}
1296
1297bool KCoreConfigSkeleton::useDefaults(bool b)
1298{
1299 if (b == d->mUseDefaults) {
1300 return d->mUseDefaults;
1301 }
1302
1303 d->mUseDefaults = b;
1304 for (auto *skelItem : std::as_const(t&: d->mItems)) {
1305 skelItem->swapDefault();
1306 }
1307
1308 usrUseDefaults(b);
1309 return !d->mUseDefaults;
1310}
1311
1312void KCoreConfigSkeleton::setDefaults()
1313{
1314 for (auto *skelItem : std::as_const(t&: d->mItems)) {
1315 skelItem->setDefault();
1316 }
1317 usrSetDefaults();
1318}
1319
1320void KCoreConfigSkeleton::load()
1321{
1322 d->mConfig->reparseConfiguration();
1323 read();
1324}
1325
1326void KCoreConfigSkeleton::read()
1327{
1328 for (auto *skelItem : std::as_const(t&: d->mItems)) {
1329 skelItem->readConfig(d->mConfig.data());
1330 }
1331 usrRead();
1332}
1333
1334bool KCoreConfigSkeleton::isDefaults() const
1335{
1336 return std::all_of(first: d->mItems.cbegin(), last: d->mItems.cend(), pred: [](KConfigSkeletonItem *skelItem) {
1337 return skelItem->isDefault();
1338 });
1339}
1340
1341bool KCoreConfigSkeleton::isSaveNeeded() const
1342{
1343 return std::any_of(first: d->mItems.cbegin(), last: d->mItems.cend(), pred: [](KConfigSkeletonItem *skelItem) {
1344 return skelItem->isSaveNeeded();
1345 });
1346}
1347
1348bool KCoreConfigSkeleton::save()
1349{
1350 // qDebug();
1351 for (auto *skelItem : std::as_const(t&: d->mItems)) {
1352 skelItem->writeConfig(d->mConfig.data());
1353 }
1354
1355 if (!usrSave()) {
1356 return false;
1357 }
1358
1359 if (d->mConfig->isDirty()) {
1360 if (!d->mConfig->sync()) {
1361 return false;
1362 }
1363 Q_EMIT configChanged();
1364 }
1365 return true;
1366}
1367
1368bool KCoreConfigSkeleton::usrUseDefaults(bool)
1369{
1370 return false;
1371}
1372
1373void KCoreConfigSkeleton::usrSetDefaults()
1374{
1375}
1376
1377void KCoreConfigSkeleton::usrRead()
1378{
1379}
1380
1381bool KCoreConfigSkeleton::usrSave()
1382{
1383 return true;
1384}
1385
1386void KCoreConfigSkeleton::addItem(KConfigSkeletonItem *item, const QString &name)
1387{
1388 if (d->mItems.contains(t: item)) {
1389 if (item->name() == name || (name.isEmpty() && item->name() == item->key())) {
1390 // nothing to do -> it is already in our collection
1391 // and the name isn't changing
1392 return;
1393 }
1394
1395 d->mItemDict.remove(key: item->name());
1396 } else {
1397 d->mItems.append(t: item);
1398 }
1399
1400 item->setName(name.isEmpty() ? item->key() : name);
1401 d->mItemDict.insert(key: item->name(), value: item);
1402 item->readDefault(d->mConfig.data());
1403 item->readConfig(d->mConfig.data());
1404}
1405
1406void KCoreConfigSkeleton::removeItem(const QString &name)
1407{
1408 KConfigSkeletonItem *item = d->mItemDict.value(key: name);
1409 if (item) {
1410 d->mItems.removeAll(t: item);
1411 d->mItemDict.remove(key: item->name());
1412 delete item;
1413 }
1414}
1415
1416void KCoreConfigSkeleton::clearItems()
1417{
1418 KConfigSkeletonItem::List items = d->mItems;
1419 d->mItems.clear();
1420 d->mItemDict.clear();
1421 qDeleteAll(c: items);
1422}
1423
1424KCoreConfigSkeleton::ItemString *KCoreConfigSkeleton::addItemString(const QString &name, QString &reference, const QString &defaultValue, const QString &key)
1425{
1426 KCoreConfigSkeleton::ItemString *item;
1427 item = new KCoreConfigSkeleton::ItemString(d->mCurrentGroup, key.isEmpty() ? name : key, reference, defaultValue, KCoreConfigSkeleton::ItemString::Normal);
1428 addItem(item, name);
1429 return item;
1430}
1431
1432KCoreConfigSkeleton::ItemPassword *
1433KCoreConfigSkeleton::addItemPassword(const QString &name, QString &reference, const QString &defaultValue, const QString &key)
1434{
1435 KCoreConfigSkeleton::ItemPassword *item;
1436 item = new KCoreConfigSkeleton::ItemPassword(d->mCurrentGroup, key.isNull() ? name : key, reference, defaultValue);
1437 addItem(item, name);
1438 return item;
1439}
1440
1441KCoreConfigSkeleton::ItemPath *KCoreConfigSkeleton::addItemPath(const QString &name, QString &reference, const QString &defaultValue, const QString &key)
1442{
1443 KCoreConfigSkeleton::ItemPath *item;
1444 item = new KCoreConfigSkeleton::ItemPath(d->mCurrentGroup, key.isNull() ? name : key, reference, defaultValue);
1445 addItem(item, name);
1446 return item;
1447}
1448
1449KCoreConfigSkeleton::ItemProperty *
1450KCoreConfigSkeleton::addItemProperty(const QString &name, QVariant &reference, const QVariant &defaultValue, const QString &key)
1451{
1452 KCoreConfigSkeleton::ItemProperty *item;
1453 item = new KCoreConfigSkeleton::ItemProperty(d->mCurrentGroup, key.isNull() ? name : key, reference, defaultValue);
1454 addItem(item, name);
1455 return item;
1456}
1457
1458KCoreConfigSkeleton::ItemBool *KCoreConfigSkeleton::addItemBool(const QString &name, bool &reference, bool defaultValue, const QString &key)
1459{
1460 KCoreConfigSkeleton::ItemBool *item;
1461 item = new KCoreConfigSkeleton::ItemBool(d->mCurrentGroup, key.isNull() ? name : key, reference, defaultValue);
1462 addItem(item, name);
1463 return item;
1464}
1465
1466KCoreConfigSkeleton::ItemInt *KCoreConfigSkeleton::addItemInt(const QString &name, qint32 &reference, qint32 defaultValue, const QString &key)
1467{
1468 KCoreConfigSkeleton::ItemInt *item;
1469 item = new KCoreConfigSkeleton::ItemInt(d->mCurrentGroup, key.isNull() ? name : key, reference, defaultValue);
1470 addItem(item, name);
1471 return item;
1472}
1473
1474KCoreConfigSkeleton::ItemUInt *KCoreConfigSkeleton::addItemUInt(const QString &name, quint32 &reference, quint32 defaultValue, const QString &key)
1475{
1476 KCoreConfigSkeleton::ItemUInt *item;
1477 item = new KCoreConfigSkeleton::ItemUInt(d->mCurrentGroup, key.isNull() ? name : key, reference, defaultValue);
1478 addItem(item, name);
1479 return item;
1480}
1481
1482KCoreConfigSkeleton::ItemLongLong *KCoreConfigSkeleton::addItemLongLong(const QString &name, qint64 &reference, qint64 defaultValue, const QString &key)
1483{
1484 KCoreConfigSkeleton::ItemLongLong *item;
1485 item = new KCoreConfigSkeleton::ItemLongLong(d->mCurrentGroup, key.isNull() ? name : key, reference, defaultValue);
1486 addItem(item, name);
1487 return item;
1488}
1489
1490KCoreConfigSkeleton::ItemULongLong *KCoreConfigSkeleton::addItemULongLong(const QString &name, quint64 &reference, quint64 defaultValue, const QString &key)
1491{
1492 KCoreConfigSkeleton::ItemULongLong *item;
1493 item = new KCoreConfigSkeleton::ItemULongLong(d->mCurrentGroup, key.isNull() ? name : key, reference, defaultValue);
1494 addItem(item, name);
1495 return item;
1496}
1497
1498KCoreConfigSkeleton::ItemDouble *KCoreConfigSkeleton::addItemDouble(const QString &name, double &reference, double defaultValue, const QString &key)
1499{
1500 KCoreConfigSkeleton::ItemDouble *item;
1501 item = new KCoreConfigSkeleton::ItemDouble(d->mCurrentGroup, key.isNull() ? name : key, reference, defaultValue);
1502 addItem(item, name);
1503 return item;
1504}
1505
1506KCoreConfigSkeleton::ItemRect *KCoreConfigSkeleton::addItemRect(const QString &name, QRect &reference, const QRect &defaultValue, const QString &key)
1507{
1508 KCoreConfigSkeleton::ItemRect *item;
1509 item = new KCoreConfigSkeleton::ItemRect(d->mCurrentGroup, key.isNull() ? name : key, reference, defaultValue);
1510 addItem(item, name);
1511 return item;
1512}
1513
1514KCoreConfigSkeleton::ItemRectF *KCoreConfigSkeleton::addItemRectF(const QString &name, QRectF &reference, const QRectF &defaultValue, const QString &key)
1515{
1516 KCoreConfigSkeleton::ItemRectF *item;
1517 item = new KCoreConfigSkeleton::ItemRectF(d->mCurrentGroup, key.isNull() ? name : key, reference, defaultValue);
1518 addItem(item, name);
1519 return item;
1520}
1521
1522KCoreConfigSkeleton::ItemPoint *KCoreConfigSkeleton::addItemPoint(const QString &name, QPoint &reference, const QPoint &defaultValue, const QString &key)
1523{
1524 KCoreConfigSkeleton::ItemPoint *item;
1525 item = new KCoreConfigSkeleton::ItemPoint(d->mCurrentGroup, key.isNull() ? name : key, reference, defaultValue);
1526 addItem(item, name);
1527 return item;
1528}
1529
1530KCoreConfigSkeleton::ItemPointF *KCoreConfigSkeleton::addItemPointF(const QString &name, QPointF &reference, const QPointF &defaultValue, const QString &key)
1531{
1532 KCoreConfigSkeleton::ItemPointF *item;
1533 item = new KCoreConfigSkeleton::ItemPointF(d->mCurrentGroup, key.isNull() ? name : key, reference, defaultValue);
1534 addItem(item, name);
1535 return item;
1536}
1537
1538KCoreConfigSkeleton::ItemSize *KCoreConfigSkeleton::addItemSize(const QString &name, QSize &reference, const QSize &defaultValue, const QString &key)
1539{
1540 KCoreConfigSkeleton::ItemSize *item;
1541 item = new KCoreConfigSkeleton::ItemSize(d->mCurrentGroup, key.isNull() ? name : key, reference, defaultValue);
1542 addItem(item, name);
1543 return item;
1544}
1545
1546KCoreConfigSkeleton::ItemSizeF *KCoreConfigSkeleton::addItemSizeF(const QString &name, QSizeF &reference, const QSizeF &defaultValue, const QString &key)
1547{
1548 KCoreConfigSkeleton::ItemSizeF *item;
1549 item = new KCoreConfigSkeleton::ItemSizeF(d->mCurrentGroup, key.isNull() ? name : key, reference, defaultValue);
1550 addItem(item, name);
1551 return item;
1552}
1553
1554KCoreConfigSkeleton::ItemDateTime *
1555KCoreConfigSkeleton::addItemDateTime(const QString &name, QDateTime &reference, const QDateTime &defaultValue, const QString &key)
1556{
1557 KCoreConfigSkeleton::ItemDateTime *item;
1558 item = new KCoreConfigSkeleton::ItemDateTime(d->mCurrentGroup, key.isNull() ? name : key, reference, defaultValue);
1559 addItem(item, name);
1560 return item;
1561}
1562
1563KCoreConfigSkeleton::ItemTime *KCoreConfigSkeleton::addItemTime(const QString &name, QTime &reference, QTime defaultValue, const QString &key)
1564{
1565 KCoreConfigSkeleton::ItemTime *item;
1566 item = new KCoreConfigSkeleton::ItemTime(d->mCurrentGroup, key.isNull() ? name : key, reference, defaultValue);
1567 addItem(item, name);
1568 return item;
1569}
1570
1571KCoreConfigSkeleton::ItemStringList *
1572KCoreConfigSkeleton::addItemStringList(const QString &name, QStringList &reference, const QStringList &defaultValue, const QString &key)
1573{
1574 KCoreConfigSkeleton::ItemStringList *item;
1575 item = new KCoreConfigSkeleton::ItemStringList(d->mCurrentGroup, key.isNull() ? name : key, reference, defaultValue);
1576 addItem(item, name);
1577 return item;
1578}
1579
1580KCoreConfigSkeleton::ItemIntList *
1581KCoreConfigSkeleton::addItemIntList(const QString &name, QList<int> &reference, const QList<int> &defaultValue, const QString &key)
1582{
1583 KCoreConfigSkeleton::ItemIntList *item;
1584 item = new KCoreConfigSkeleton::ItemIntList(d->mCurrentGroup, key.isNull() ? name : key, reference, defaultValue);
1585 addItem(item, name);
1586 return item;
1587}
1588
1589bool KCoreConfigSkeleton::isImmutable(const QString &name) const
1590{
1591 KConfigSkeletonItem *item = findItem(name);
1592 return !item || item->isImmutable();
1593}
1594
1595KConfigSkeletonItem *KCoreConfigSkeleton::findItem(const QString &name) const
1596{
1597 return d->mItemDict.value(key: name);
1598}
1599
1600KConfigCompilerSignallingItem::KConfigCompilerSignallingItem(KConfigSkeletonItem *item,
1601 QObject *object,
1602 KConfigCompilerSignallingItem::NotifyFunction targetFunction,
1603 quint64 userData)
1604 : KConfigSkeletonItem(item->group(), item->key())
1605 , mItem(item)
1606 , mTargetFunction(targetFunction)
1607 , mObject(object)
1608 , mUserData(userData)
1609{
1610 Q_ASSERT(mTargetFunction);
1611 Q_ASSERT(mItem);
1612 Q_ASSERT(mObject);
1613
1614 setIsDefaultImpl([this] {
1615 return mItem->isDefault();
1616 });
1617 setIsSaveNeededImpl([this] {
1618 return mItem->isSaveNeeded();
1619 });
1620 setGetDefaultImpl([this] {
1621 return mItem->getDefault();
1622 });
1623}
1624
1625KConfigCompilerSignallingItem::~KConfigCompilerSignallingItem()
1626{
1627}
1628
1629bool KConfigCompilerSignallingItem::isEqual(const QVariant &p) const
1630{
1631 return mItem->isEqual(p);
1632}
1633
1634QVariant KConfigCompilerSignallingItem::property() const
1635{
1636 return mItem->property();
1637}
1638
1639QVariant KConfigCompilerSignallingItem::minValue() const
1640{
1641 return mItem->minValue();
1642}
1643
1644QVariant KConfigCompilerSignallingItem::maxValue() const
1645{
1646 return mItem->maxValue();
1647}
1648
1649void KConfigCompilerSignallingItem::readConfig(KConfig *c)
1650{
1651 QVariant oldValue = mItem->property();
1652 mItem->readConfig(c);
1653 // readConfig() changes mIsImmutable, update it here as well
1654 KConfigGroup cg = configGroup(config: c);
1655 readImmutability(group: cg);
1656 if (!mItem->isEqual(p: oldValue)) {
1657 invokeNotifyFunction();
1658 }
1659}
1660
1661void KConfigCompilerSignallingItem::readDefault(KConfig *c)
1662{
1663 mItem->readDefault(c);
1664 // readDefault() changes mIsImmutable, update it here as well
1665 KConfigGroup cg = configGroup(config: c);
1666 readImmutability(group: cg);
1667}
1668
1669void KConfigCompilerSignallingItem::writeConfig(KConfig *c)
1670{
1671 mItem->writeConfig(c);
1672}
1673
1674void KConfigCompilerSignallingItem::setDefault()
1675{
1676 QVariant oldValue = mItem->property();
1677 mItem->setDefault();
1678 if (!mItem->isEqual(p: oldValue)) {
1679 invokeNotifyFunction();
1680 }
1681}
1682
1683void KConfigCompilerSignallingItem::setProperty(const QVariant &p)
1684{
1685 if (!mItem->isEqual(p)) {
1686 mItem->setProperty(p);
1687 invokeNotifyFunction();
1688 }
1689}
1690
1691void KConfigCompilerSignallingItem::swapDefault()
1692{
1693 QVariant oldValue = mItem->property();
1694 mItem->swapDefault();
1695 if (!mItem->isEqual(p: oldValue)) {
1696 invokeNotifyFunction();
1697 }
1698}
1699
1700void KConfigCompilerSignallingItem::setWriteFlags(KConfigBase::WriteConfigFlags flags)
1701{
1702 mItem->setWriteFlags(flags);
1703}
1704
1705KConfigBase::WriteConfigFlags KConfigCompilerSignallingItem::writeFlags() const
1706{
1707 return mItem->writeFlags();
1708}
1709
1710void KConfigCompilerSignallingItem::setGroup(const KConfigGroup &cg)
1711{
1712 mItem->setGroup(cg);
1713}
1714
1715KConfigGroup KConfigCompilerSignallingItem::configGroup(KConfig *config) const
1716{
1717 return mItem->configGroup(config);
1718}
1719
1720#include "moc_kcoreconfigskeleton.cpp"
1721

source code of kconfig/src/core/kcoreconfigskeleton.cpp