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
obscuredString(const QString & str)16 static 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
29 KConfigSkeletonItemPrivate::~KConfigSkeletonItemPrivate() = default;
30
KConfigSkeletonItem(const QString & _group,const QString & _key)31 KConfigSkeletonItem::KConfigSkeletonItem(const QString &_group, const QString &_key)
32 : mGroup(_group)
33 , mKey(_key)
34 , d_ptr(new KConfigSkeletonItemPrivate)
35 {
36 }
37
KConfigSkeletonItem(KConfigSkeletonItemPrivate & dd,const QString & _group,const QString & _key)38 KConfigSkeletonItem::KConfigSkeletonItem(KConfigSkeletonItemPrivate &dd, const QString &_group, const QString &_key)
39 : mGroup(_group)
40 , mKey(_key)
41 , d_ptr(&dd)
42 {
43 }
44
~KConfigSkeletonItem()45 KConfigSkeletonItem::~KConfigSkeletonItem()
46 {
47 delete d_ptr;
48 }
49
setGroup(const QString & _group)50 void KConfigSkeletonItem::setGroup(const QString &_group)
51 {
52 mGroup = _group;
53 }
54
setGroup(const KConfigGroup & cg)55 void KConfigSkeletonItem::setGroup(const KConfigGroup &cg)
56 {
57 Q_D(KConfigSkeletonItem);
58 d->mConfigGroup = cg;
59 }
60
configGroup(KConfig * config) const61 KConfigGroup 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
group() const70 QString KConfigSkeletonItem::group() const
71 {
72 return mGroup;
73 }
74
setKey(const QString & _key)75 void KConfigSkeletonItem::setKey(const QString &_key)
76 {
77 mKey = _key;
78 }
79
key() const80 QString KConfigSkeletonItem::key() const
81 {
82 return mKey;
83 }
84
setName(const QString & _name)85 void KConfigSkeletonItem::setName(const QString &_name)
86 {
87 mName = _name;
88 }
89
name() const90 QString KConfigSkeletonItem::name() const
91 {
92 return mName;
93 }
94
setLabel(const QString & l)95 void KConfigSkeletonItem::setLabel(const QString &l)
96 {
97 Q_D(KConfigSkeletonItem);
98 d->mLabel = l;
99 }
100
label() const101 QString KConfigSkeletonItem::label() const
102 {
103 Q_D(const KConfigSkeletonItem);
104 return d->mLabel;
105 }
106
setToolTip(const QString & t)107 void KConfigSkeletonItem::setToolTip(const QString &t)
108 {
109 Q_D(KConfigSkeletonItem);
110 d->mToolTip = t;
111 }
112
toolTip() const113 QString KConfigSkeletonItem::toolTip() const
114 {
115 Q_D(const KConfigSkeletonItem);
116 return d->mToolTip;
117 }
118
setWhatsThis(const QString & w)119 void KConfigSkeletonItem::setWhatsThis(const QString &w)
120 {
121 Q_D(KConfigSkeletonItem);
122 d->mWhatsThis = w;
123 }
124
whatsThis() const125 QString KConfigSkeletonItem::whatsThis() const
126 {
127 Q_D(const KConfigSkeletonItem);
128 return d->mWhatsThis;
129 }
130
setWriteFlags(KConfigBase::WriteConfigFlags flags)131 void KConfigSkeletonItem::setWriteFlags(KConfigBase::WriteConfigFlags flags)
132 {
133 Q_D(KConfigSkeletonItem);
134 d->mWriteFlags = flags;
135 }
136
writeFlags() const137 KConfigBase::WriteConfigFlags KConfigSkeletonItem::writeFlags() const
138 {
139 Q_D(const KConfigSkeletonItem);
140 return d->mWriteFlags;
141 }
142
minValue() const143 QVariant KConfigSkeletonItem::minValue() const
144 {
145 return QVariant();
146 }
147
maxValue() const148 QVariant KConfigSkeletonItem::maxValue() const
149 {
150 return QVariant();
151 }
152
isImmutable() const153 bool KConfigSkeletonItem::isImmutable() const
154 {
155 Q_D(const KConfigSkeletonItem);
156 return d->mIsImmutable;
157 }
158
isDefault() const159 bool KConfigSkeletonItem::isDefault() const
160 {
161 Q_D(const KConfigSkeletonItem);
162 return d->mIsDefaultImpl();
163 }
164
isSaveNeeded() const165 bool KConfigSkeletonItem::isSaveNeeded() const
166 {
167 Q_D(const KConfigSkeletonItem);
168 return d->mIsSaveNeededImpl();
169 }
170
getDefault() const171 QVariant KConfigSkeletonItem::getDefault() const
172 {
173 Q_D(const KConfigSkeletonItem);
174 return d->mGetDefaultImpl();
175 }
176
readImmutability(const KConfigGroup & group)177 void KConfigSkeletonItem::readImmutability(const KConfigGroup &group)
178 {
179 Q_D(KConfigSkeletonItem);
180 d->mIsImmutable = group.isEntryImmutable(mKey);
181 }
182
setIsDefaultImpl(const std::function<bool ()> & impl)183 void KConfigSkeletonItem::setIsDefaultImpl(const std::function<bool()> &impl)
184 {
185 Q_D(KConfigSkeletonItem);
186 d->mIsDefaultImpl = impl;
187 }
188
setIsSaveNeededImpl(const std::function<bool ()> & impl)189 void KConfigSkeletonItem::setIsSaveNeededImpl(const std::function<bool()> &impl)
190 {
191 Q_D(KConfigSkeletonItem);
192 d->mIsSaveNeededImpl = impl;
193 }
194
setGetDefaultImpl(const std::function<QVariant ()> & impl)195 void KConfigSkeletonItem::setGetDefaultImpl(const std::function<QVariant()> &impl)
196 {
197 Q_D(KConfigSkeletonItem);
198 d->mGetDefaultImpl = impl;
199 }
200
KPropertySkeletonItem(QObject * object,const QByteArray & propertyName,const QVariant & defaultValue)201 KPropertySkeletonItem::KPropertySkeletonItem(QObject *object, const QByteArray &propertyName, const QVariant &defaultValue)
202 : KConfigSkeletonItem(*new KPropertySkeletonItemPrivate(object, propertyName, defaultValue), {}, {})
203 {
__anond7aec2ea0102null204 setIsDefaultImpl([this] {
205 Q_D(const KPropertySkeletonItem);
206 return d->mReference == d->mDefaultValue;
207 });
__anond7aec2ea0202null208 setIsSaveNeededImpl([this] {
209 Q_D(const KPropertySkeletonItem);
210 return d->mReference != d->mLoadedValue;
211 });
__anond7aec2ea0302null212 setGetDefaultImpl([this] {
213 Q_D(const KPropertySkeletonItem);
214 return d->mDefaultValue;
215 });
216 }
217
property() const218 QVariant KPropertySkeletonItem::property() const
219 {
220 Q_D(const KPropertySkeletonItem);
221 return d->mReference;
222 }
223
setProperty(const QVariant & p)224 void 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
isEqual(const QVariant & p) const236 bool KPropertySkeletonItem::isEqual(const QVariant &p) const
237 {
238 Q_D(const KPropertySkeletonItem);
239 return d->mReference == p;
240 }
241
readConfig(KConfig *)242 void KPropertySkeletonItem::readConfig(KConfig *)
243 {
244 Q_D(KPropertySkeletonItem);
245 setProperty(d->mObject->property(d->mPropertyName.constData()));
246 d->mLoadedValue = d->mReference;
247 }
248
writeConfig(KConfig *)249 void KPropertySkeletonItem::writeConfig(KConfig *)
250 {
251 Q_D(KPropertySkeletonItem);
252 d->mObject->setProperty(d->mPropertyName.constData(), d->mReference);
253 d->mLoadedValue = d->mReference;
254 }
255
readDefault(KConfig *)256 void KPropertySkeletonItem::readDefault(KConfig *)
257 {
258 Q_D(KPropertySkeletonItem);
259 setProperty(d->mConstDefaultValue);
260 }
261
setDefault()262 void KPropertySkeletonItem::setDefault()
263 {
264 Q_D(KPropertySkeletonItem);
265 setProperty(d->mDefaultValue);
266 }
267
swapDefault()268 void KPropertySkeletonItem::swapDefault()
269 {
270 Q_D(KPropertySkeletonItem);
271 if (d->mReference == d->mDefaultValue) {
272 return;
273 }
274 std::swap(d->mReference, d->mDefaultValue);
275 if (d->mNotifyFunction) {
276 d->mNotifyFunction();
277 }
278 }
279
setNotifyFunction(const std::function<void ()> & impl)280 void KPropertySkeletonItem::setNotifyFunction(const std::function<void()> &impl)
281 {
282 Q_D(KPropertySkeletonItem);
283 d->mNotifyFunction = impl;
284 }
285
ItemString(const QString & _group,const QString & _key,QString & reference,const QString & defaultValue,Type type)286 KCoreConfigSkeleton::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
writeConfig(KConfig * config)292 void 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(mKey)) {
297 cg.revertToDefault(mKey, writeFlags());
298 } else if (mType == Path) {
299 cg.writePathEntry(mKey, mReference, writeFlags());
300 } else if (mType == Password) {
301 cg.writeEntry(mKey, obscuredString(mReference), writeFlags());
302 } else {
303 cg.writeEntry(mKey, mReference, writeFlags());
304 }
305 mLoadedValue = mReference;
306 }
307 }
308
readConfig(KConfig * config)309 void KCoreConfigSkeleton::ItemString::readConfig(KConfig *config)
310 {
311 KConfigGroup cg = configGroup(config);
312
313 if (mType == Path) {
314 mReference = cg.readPathEntry(mKey, mDefault);
315 } else if (mType == Password) {
316 QString val = cg.readEntry(mKey, obscuredString(mDefault));
317 mReference = obscuredString(val);
318 } else {
319 mReference = cg.readEntry(mKey, mDefault);
320 }
321
322 mLoadedValue = mReference;
323
324 readImmutability(cg);
325 }
326
setProperty(const QVariant & p)327 void KCoreConfigSkeleton::ItemString::setProperty(const QVariant &p)
328 {
329 mReference = p.toString();
330 }
331
isEqual(const QVariant & v) const332 bool KCoreConfigSkeleton::ItemString::isEqual(const QVariant &v) const
333 {
334 return mReference == v.toString();
335 }
336
property() const337 QVariant KCoreConfigSkeleton::ItemString::property() const
338 {
339 return QVariant(mReference);
340 }
341
ItemPassword(const QString & _group,const QString & _key,QString & reference,const QString & defaultValue)342 KCoreConfigSkeleton::ItemPassword::ItemPassword(const QString &_group, const QString &_key, QString &reference, const QString &defaultValue)
343 : ItemString(_group, _key, reference, defaultValue, Password)
344 {
345 }
346
ItemPath(const QString & _group,const QString & _key,QString & reference,const QString & defaultValue)347 KCoreConfigSkeleton::ItemPath::ItemPath(const QString &_group, const QString &_key, QString &reference, const QString &defaultValue)
348 : ItemString(_group, _key, reference, defaultValue, Path)
349 {
350 }
351
ItemUrl(const QString & _group,const QString & _key,QUrl & reference,const QUrl & defaultValue)352 KCoreConfigSkeleton::ItemUrl::ItemUrl(const QString &_group, const QString &_key, QUrl &reference, const QUrl &defaultValue)
353 : KConfigSkeletonGenericItem<QUrl>(_group, _key, reference, defaultValue)
354 {
355 }
356
writeConfig(KConfig * config)357 void 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(mKey)) {
362 cg.revertToDefault(mKey, writeFlags());
363 } else {
364 cg.writeEntry<QString>(mKey, mReference.toString(), writeFlags());
365 }
366 mLoadedValue = mReference;
367 }
368 }
369
readConfig(KConfig * config)370 void KCoreConfigSkeleton::ItemUrl::readConfig(KConfig *config)
371 {
372 KConfigGroup cg = configGroup(config);
373
374 mReference = QUrl(cg.readEntry<QString>(mKey, mDefault.toString()));
375 mLoadedValue = mReference;
376
377 readImmutability(cg);
378 }
379
setProperty(const QVariant & p)380 void KCoreConfigSkeleton::ItemUrl::setProperty(const QVariant &p)
381 {
382 mReference = qvariant_cast<QUrl>(p);
383 }
384
isEqual(const QVariant & v) const385 bool KCoreConfigSkeleton::ItemUrl::isEqual(const QVariant &v) const
386 {
387 return mReference == qvariant_cast<QUrl>(v);
388 }
389
property() const390 QVariant KCoreConfigSkeleton::ItemUrl::property() const
391 {
392 return QVariant::fromValue<QUrl>(mReference);
393 }
394
ItemProperty(const QString & _group,const QString & _key,QVariant & reference,const QVariant & defaultValue)395 KCoreConfigSkeleton::ItemProperty::ItemProperty(const QString &_group, const QString &_key, QVariant &reference, const QVariant &defaultValue)
396 : KConfigSkeletonGenericItem<QVariant>(_group, _key, reference, defaultValue)
397 {
398 }
399
readConfig(KConfig * config)400 void KCoreConfigSkeleton::ItemProperty::readConfig(KConfig *config)
401 {
402 KConfigGroup cg = configGroup(config);
403 mReference = cg.readEntry(mKey, mDefault);
404 mLoadedValue = mReference;
405
406 readImmutability(cg);
407 }
408
setProperty(const QVariant & p)409 void KCoreConfigSkeleton::ItemProperty::setProperty(const QVariant &p)
410 {
411 mReference = p;
412 }
413
isEqual(const QVariant & v) const414 bool 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
property() const420 QVariant KCoreConfigSkeleton::ItemProperty::property() const
421 {
422 return mReference;
423 }
424
ItemBool(const QString & _group,const QString & _key,bool & reference,bool defaultValue)425 KCoreConfigSkeleton::ItemBool::ItemBool(const QString &_group, const QString &_key, bool &reference, bool defaultValue)
426 : KConfigSkeletonGenericItem<bool>(_group, _key, reference, defaultValue)
427 {
428 }
429
readConfig(KConfig * config)430 void KCoreConfigSkeleton::ItemBool::readConfig(KConfig *config)
431 {
432 KConfigGroup cg = configGroup(config);
433 mReference = cg.readEntry(mKey, mDefault);
434 mLoadedValue = mReference;
435
436 readImmutability(cg);
437 }
438
setProperty(const QVariant & p)439 void KCoreConfigSkeleton::ItemBool::setProperty(const QVariant &p)
440 {
441 mReference = p.toBool();
442 }
443
isEqual(const QVariant & v) const444 bool KCoreConfigSkeleton::ItemBool::isEqual(const QVariant &v) const
445 {
446 return mReference == v.toBool();
447 }
448
property() const449 QVariant KCoreConfigSkeleton::ItemBool::property() const
450 {
451 return QVariant(mReference);
452 }
453
ItemInt(const QString & _group,const QString & _key,qint32 & reference,qint32 defaultValue)454 KCoreConfigSkeleton::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
readConfig(KConfig * config)461 void KCoreConfigSkeleton::ItemInt::readConfig(KConfig *config)
462 {
463 KConfigGroup cg = configGroup(config);
464 mReference = cg.readEntry(mKey, mDefault);
465 if (mHasMin) {
466 mReference = qMax(mReference, mMin);
467 }
468 if (mHasMax) {
469 mReference = qMin(mReference, mMax);
470 }
471 mLoadedValue = mReference;
472
473 readImmutability(cg);
474 }
475
setProperty(const QVariant & p)476 void KCoreConfigSkeleton::ItemInt::setProperty(const QVariant &p)
477 {
478 mReference = p.toInt();
479 }
480
isEqual(const QVariant & v) const481 bool KCoreConfigSkeleton::ItemInt::isEqual(const QVariant &v) const
482 {
483 return mReference == v.toInt();
484 }
485
property() const486 QVariant KCoreConfigSkeleton::ItemInt::property() const
487 {
488 return QVariant(mReference);
489 }
490
minValue() const491 QVariant KCoreConfigSkeleton::ItemInt::minValue() const
492 {
493 if (mHasMin) {
494 return QVariant(mMin);
495 }
496 return QVariant();
497 }
498
maxValue() const499 QVariant KCoreConfigSkeleton::ItemInt::maxValue() const
500 {
501 if (mHasMax) {
502 return QVariant(mMax);
503 }
504 return QVariant();
505 }
506
setMinValue(qint32 v)507 void KCoreConfigSkeleton::ItemInt::setMinValue(qint32 v)
508 {
509 mHasMin = true;
510 mMin = v;
511 }
512
setMaxValue(qint32 v)513 void KCoreConfigSkeleton::ItemInt::setMaxValue(qint32 v)
514 {
515 mHasMax = true;
516 mMax = v;
517 }
518
ItemLongLong(const QString & _group,const QString & _key,qint64 & reference,qint64 defaultValue)519 KCoreConfigSkeleton::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
readConfig(KConfig * config)526 void KCoreConfigSkeleton::ItemLongLong::readConfig(KConfig *config)
527 {
528 KConfigGroup cg = configGroup(config);
529 mReference = cg.readEntry(mKey, mDefault);
530 if (mHasMin) {
531 mReference = qMax(mReference, mMin);
532 }
533 if (mHasMax) {
534 mReference = qMin(mReference, mMax);
535 }
536 mLoadedValue = mReference;
537
538 readImmutability(cg);
539 }
540
setProperty(const QVariant & p)541 void KCoreConfigSkeleton::ItemLongLong::setProperty(const QVariant &p)
542 {
543 mReference = p.toLongLong();
544 }
545
isEqual(const QVariant & v) const546 bool KCoreConfigSkeleton::ItemLongLong::isEqual(const QVariant &v) const
547 {
548 return mReference == v.toLongLong();
549 }
550
property() const551 QVariant KCoreConfigSkeleton::ItemLongLong::property() const
552 {
553 return QVariant(mReference);
554 }
555
minValue() const556 QVariant KCoreConfigSkeleton::ItemLongLong::minValue() const
557 {
558 if (mHasMin) {
559 return QVariant(mMin);
560 }
561 return QVariant();
562 }
563
maxValue() const564 QVariant KCoreConfigSkeleton::ItemLongLong::maxValue() const
565 {
566 if (mHasMax) {
567 return QVariant(mMax);
568 }
569 return QVariant();
570 }
571
setMinValue(qint64 v)572 void KCoreConfigSkeleton::ItemLongLong::setMinValue(qint64 v)
573 {
574 mHasMin = true;
575 mMin = v;
576 }
577
setMaxValue(qint64 v)578 void KCoreConfigSkeleton::ItemLongLong::setMaxValue(qint64 v)
579 {
580 mHasMax = true;
581 mMax = v;
582 }
583
valueForChoice(const QString & name) const584 QString KCoreConfigSkeleton::ItemEnum::valueForChoice(const QString &name) const
585 {
586 // HACK for BC concerns
587 // TODO KF6: remove KConfigSkeletonItemPrivate::mValues and add a value field to KCoreConfigSkeleton::ItemEnum::Choice
588 const auto inHash = d_ptr->mValues.value(name);
589 return !inHash.isEmpty() ? inHash : name;
590 }
591
setValueForChoice(const QString & name,const QString & value)592 void KCoreConfigSkeleton::ItemEnum::setValueForChoice(const QString &name, const QString &value)
593 {
594 d_ptr->mValues.insert(name, value);
595 }
596
ItemEnum(const QString & _group,const QString & _key,qint32 & reference,const QList<Choice> & choices,qint32 defaultValue)597 KCoreConfigSkeleton::ItemEnum::ItemEnum(const QString &_group, const QString &_key, qint32 &reference, const QList<Choice> &choices, qint32 defaultValue)
598 : ItemInt(_group, _key, reference, defaultValue)
599 , mChoices(choices)
600 {
601 }
602
readConfig(KConfig * config)603 void KCoreConfigSkeleton::ItemEnum::readConfig(KConfig *config)
604 {
605 KConfigGroup cg = configGroup(config);
606 if (!cg.hasKey(mKey)) {
607 mReference = mDefault;
608 } else {
609 int i = 0;
610 mReference = -1;
611 const QString entryString = cg.readEntry(mKey, QString());
612 for (auto it = mChoices.cbegin(); it != mChoices.cend(); ++it, ++i) {
613 QString choiceName = (*it).name;
614 if (valueForChoice(choiceName).compare(entryString, Qt::CaseInsensitive) == 0) {
615 mReference = i;
616 break;
617 }
618 }
619 if (mReference == -1) {
620 mReference = cg.readEntry(mKey, mDefault);
621 }
622 }
623 mLoadedValue = mReference;
624
625 readImmutability(cg);
626 }
627
writeConfig(KConfig * config)628 void KCoreConfigSkeleton::ItemEnum::writeConfig(KConfig *config)
629 {
630 if (mReference != mLoadedValue) { // WABA: Is this test needed?
631 KConfigGroup cg = configGroup(config);
632 if ((mDefault == mReference) && !cg.hasDefault(mKey)) {
633 cg.revertToDefault(mKey, writeFlags());
634 } else if ((mReference >= 0) && (mReference < mChoices.count())) {
635 cg.writeEntry(mKey, valueForChoice(mChoices.at(mReference).name), writeFlags());
636 } else {
637 cg.writeEntry(mKey, mReference, writeFlags());
638 }
639 mLoadedValue = mReference;
640 }
641 }
642
choices() const643 QList<KCoreConfigSkeleton::ItemEnum::Choice> KCoreConfigSkeleton::ItemEnum::choices() const
644 {
645 return mChoices;
646 }
647
choices2() const648 QList<KCoreConfigSkeleton::ItemEnum::Choice> KCoreConfigSkeleton::ItemEnum::choices2() const
649 {
650 return mChoices;
651 }
652
ItemUInt(const QString & _group,const QString & _key,quint32 & reference,quint32 defaultValue)653 KCoreConfigSkeleton::ItemUInt::ItemUInt(const QString &_group, const QString &_key, quint32 &reference, quint32 defaultValue)
654 : KConfigSkeletonGenericItem<quint32>(_group, _key, reference, defaultValue)
655 , mHasMin(false)
656 , mHasMax(false)
657 {
658 }
659
readConfig(KConfig * config)660 void KCoreConfigSkeleton::ItemUInt::readConfig(KConfig *config)
661 {
662 KConfigGroup cg = configGroup(config);
663 mReference = cg.readEntry(mKey, mDefault);
664 if (mHasMin) {
665 mReference = qMax(mReference, mMin);
666 }
667 if (mHasMax) {
668 mReference = qMin(mReference, mMax);
669 }
670 mLoadedValue = mReference;
671
672 readImmutability(cg);
673 }
674
setProperty(const QVariant & p)675 void KCoreConfigSkeleton::ItemUInt::setProperty(const QVariant &p)
676 {
677 mReference = p.toUInt();
678 }
679
isEqual(const QVariant & v) const680 bool KCoreConfigSkeleton::ItemUInt::isEqual(const QVariant &v) const
681 {
682 return mReference == v.toUInt();
683 }
684
property() const685 QVariant KCoreConfigSkeleton::ItemUInt::property() const
686 {
687 return QVariant(mReference);
688 }
689
minValue() const690 QVariant KCoreConfigSkeleton::ItemUInt::minValue() const
691 {
692 if (mHasMin) {
693 return QVariant(mMin);
694 }
695 return QVariant();
696 }
697
maxValue() const698 QVariant KCoreConfigSkeleton::ItemUInt::maxValue() const
699 {
700 if (mHasMax) {
701 return QVariant(mMax);
702 }
703 return QVariant();
704 }
705
setMinValue(quint32 v)706 void KCoreConfigSkeleton::ItemUInt::setMinValue(quint32 v)
707 {
708 mHasMin = true;
709 mMin = v;
710 }
711
setMaxValue(quint32 v)712 void KCoreConfigSkeleton::ItemUInt::setMaxValue(quint32 v)
713 {
714 mHasMax = true;
715 mMax = v;
716 }
717
ItemULongLong(const QString & _group,const QString & _key,quint64 & reference,quint64 defaultValue)718 KCoreConfigSkeleton::ItemULongLong::ItemULongLong(const QString &_group, const QString &_key, quint64 &reference, quint64 defaultValue)
719 : KConfigSkeletonGenericItem<quint64>(_group, _key, reference, defaultValue)
720 , mHasMin(false)
721 , mHasMax(false)
722 {
723 }
724
readConfig(KConfig * config)725 void KCoreConfigSkeleton::ItemULongLong::readConfig(KConfig *config)
726 {
727 KConfigGroup cg = configGroup(config);
728 mReference = cg.readEntry(mKey, mDefault);
729 if (mHasMin) {
730 mReference = qMax(mReference, mMin);
731 }
732 if (mHasMax) {
733 mReference = qMin(mReference, mMax);
734 }
735 mLoadedValue = mReference;
736
737 readImmutability(cg);
738 }
739
setProperty(const QVariant & p)740 void KCoreConfigSkeleton::ItemULongLong::setProperty(const QVariant &p)
741 {
742 mReference = p.toULongLong();
743 }
744
isEqual(const QVariant & v) const745 bool KCoreConfigSkeleton::ItemULongLong::isEqual(const QVariant &v) const
746 {
747 return mReference == v.toULongLong();
748 }
749
property() const750 QVariant KCoreConfigSkeleton::ItemULongLong::property() const
751 {
752 return QVariant(mReference);
753 }
754
minValue() const755 QVariant KCoreConfigSkeleton::ItemULongLong::minValue() const
756 {
757 if (mHasMin) {
758 return QVariant(mMin);
759 }
760 return QVariant();
761 }
762
maxValue() const763 QVariant KCoreConfigSkeleton::ItemULongLong::maxValue() const
764 {
765 if (mHasMax) {
766 return QVariant(mMax);
767 }
768 return QVariant();
769 }
770
setMinValue(quint64 v)771 void KCoreConfigSkeleton::ItemULongLong::setMinValue(quint64 v)
772 {
773 mHasMin = true;
774 mMin = v;
775 }
776
setMaxValue(quint64 v)777 void KCoreConfigSkeleton::ItemULongLong::setMaxValue(quint64 v)
778 {
779 mHasMax = true;
780 mMax = v;
781 }
782
ItemDouble(const QString & _group,const QString & _key,double & reference,double defaultValue)783 KCoreConfigSkeleton::ItemDouble::ItemDouble(const QString &_group, const QString &_key, double &reference, double defaultValue)
784 : KConfigSkeletonGenericItem<double>(_group, _key, reference, defaultValue)
785 , mHasMin(false)
786 , mHasMax(false)
787 {
788 }
789
readConfig(KConfig * config)790 void KCoreConfigSkeleton::ItemDouble::readConfig(KConfig *config)
791 {
792 KConfigGroup cg = configGroup(config);
793 mReference = cg.readEntry(mKey, mDefault);
794 if (mHasMin) {
795 mReference = qMax(mReference, mMin);
796 }
797 if (mHasMax) {
798 mReference = qMin(mReference, mMax);
799 }
800 mLoadedValue = mReference;
801
802 readImmutability(cg);
803 }
804
setProperty(const QVariant & p)805 void KCoreConfigSkeleton::ItemDouble::setProperty(const QVariant &p)
806 {
807 mReference = p.toDouble();
808 }
809
isEqual(const QVariant & v) const810 bool KCoreConfigSkeleton::ItemDouble::isEqual(const QVariant &v) const
811 {
812 return mReference == v.toDouble();
813 }
814
property() const815 QVariant KCoreConfigSkeleton::ItemDouble::property() const
816 {
817 return QVariant(mReference);
818 }
819
minValue() const820 QVariant KCoreConfigSkeleton::ItemDouble::minValue() const
821 {
822 if (mHasMin) {
823 return QVariant(mMin);
824 }
825 return QVariant();
826 }
827
maxValue() const828 QVariant KCoreConfigSkeleton::ItemDouble::maxValue() const
829 {
830 if (mHasMax) {
831 return QVariant(mMax);
832 }
833 return QVariant();
834 }
835
setMinValue(double v)836 void KCoreConfigSkeleton::ItemDouble::setMinValue(double v)
837 {
838 mHasMin = true;
839 mMin = v;
840 }
841
setMaxValue(double v)842 void KCoreConfigSkeleton::ItemDouble::setMaxValue(double v)
843 {
844 mHasMax = true;
845 mMax = v;
846 }
847
ItemRect(const QString & _group,const QString & _key,QRect & reference,const QRect & defaultValue)848 KCoreConfigSkeleton::ItemRect::ItemRect(const QString &_group, const QString &_key, QRect &reference, const QRect &defaultValue)
849 : KConfigSkeletonGenericItem<QRect>(_group, _key, reference, defaultValue)
850 {
851 }
852
readConfig(KConfig * config)853 void KCoreConfigSkeleton::ItemRect::readConfig(KConfig *config)
854 {
855 KConfigGroup cg = configGroup(config);
856 mReference = cg.readEntry(mKey, mDefault);
857 mLoadedValue = mReference;
858
859 readImmutability(cg);
860 }
861
setProperty(const QVariant & p)862 void KCoreConfigSkeleton::ItemRect::setProperty(const QVariant &p)
863 {
864 mReference = p.toRect();
865 }
866
isEqual(const QVariant & v) const867 bool KCoreConfigSkeleton::ItemRect::isEqual(const QVariant &v) const
868 {
869 return mReference == v.toRect();
870 }
871
property() const872 QVariant KCoreConfigSkeleton::ItemRect::property() const
873 {
874 return QVariant(mReference);
875 }
876
ItemPoint(const QString & _group,const QString & _key,QPoint & reference,const QPoint & defaultValue)877 KCoreConfigSkeleton::ItemPoint::ItemPoint(const QString &_group, const QString &_key, QPoint &reference, const QPoint &defaultValue)
878 : KConfigSkeletonGenericItem<QPoint>(_group, _key, reference, defaultValue)
879 {
880 }
881
readConfig(KConfig * config)882 void KCoreConfigSkeleton::ItemPoint::readConfig(KConfig *config)
883 {
884 KConfigGroup cg = configGroup(config);
885 mReference = cg.readEntry(mKey, mDefault);
886 mLoadedValue = mReference;
887
888 readImmutability(cg);
889 }
890
setProperty(const QVariant & p)891 void KCoreConfigSkeleton::ItemPoint::setProperty(const QVariant &p)
892 {
893 mReference = p.toPoint();
894 }
895
isEqual(const QVariant & v) const896 bool KCoreConfigSkeleton::ItemPoint::isEqual(const QVariant &v) const
897 {
898 return mReference == v.toPoint();
899 }
900
property() const901 QVariant KCoreConfigSkeleton::ItemPoint::property() const
902 {
903 return QVariant(mReference);
904 }
905
ItemSize(const QString & _group,const QString & _key,QSize & reference,const QSize & defaultValue)906 KCoreConfigSkeleton::ItemSize::ItemSize(const QString &_group, const QString &_key, QSize &reference, const QSize &defaultValue)
907 : KConfigSkeletonGenericItem<QSize>(_group, _key, reference, defaultValue)
908 {
909 }
910
readConfig(KConfig * config)911 void KCoreConfigSkeleton::ItemSize::readConfig(KConfig *config)
912 {
913 KConfigGroup cg = configGroup(config);
914 mReference = cg.readEntry(mKey, mDefault);
915 mLoadedValue = mReference;
916
917 readImmutability(cg);
918 }
919
setProperty(const QVariant & p)920 void KCoreConfigSkeleton::ItemSize::setProperty(const QVariant &p)
921 {
922 mReference = p.toSize();
923 }
924
isEqual(const QVariant & v) const925 bool KCoreConfigSkeleton::ItemSize::isEqual(const QVariant &v) const
926 {
927 return mReference == v.toSize();
928 }
929
property() const930 QVariant KCoreConfigSkeleton::ItemSize::property() const
931 {
932 return QVariant(mReference);
933 }
934
ItemDateTime(const QString & _group,const QString & _key,QDateTime & reference,const QDateTime & defaultValue)935 KCoreConfigSkeleton::ItemDateTime::ItemDateTime(const QString &_group, const QString &_key, QDateTime &reference, const QDateTime &defaultValue)
936 : KConfigSkeletonGenericItem<QDateTime>(_group, _key, reference, defaultValue)
937 {
938 }
939
readConfig(KConfig * config)940 void KCoreConfigSkeleton::ItemDateTime::readConfig(KConfig *config)
941 {
942 KConfigGroup cg = configGroup(config);
943 mReference = cg.readEntry(mKey, mDefault);
944 mLoadedValue = mReference;
945
946 readImmutability(cg);
947 }
948
setProperty(const QVariant & p)949 void KCoreConfigSkeleton::ItemDateTime::setProperty(const QVariant &p)
950 {
951 mReference = p.toDateTime();
952 }
953
isEqual(const QVariant & v) const954 bool KCoreConfigSkeleton::ItemDateTime::isEqual(const QVariant &v) const
955 {
956 return mReference == v.toDateTime();
957 }
958
property() const959 QVariant KCoreConfigSkeleton::ItemDateTime::property() const
960 {
961 return QVariant(mReference);
962 }
963
ItemStringList(const QString & _group,const QString & _key,QStringList & reference,const QStringList & defaultValue)964 KCoreConfigSkeleton::ItemStringList::ItemStringList(const QString &_group, const QString &_key, QStringList &reference, const QStringList &defaultValue)
965 : KConfigSkeletonGenericItem<QStringList>(_group, _key, reference, defaultValue)
966 {
967 }
968
readConfig(KConfig * config)969 void KCoreConfigSkeleton::ItemStringList::readConfig(KConfig *config)
970 {
971 KConfigGroup cg = configGroup(config);
972 if (!cg.hasKey(mKey)) {
973 mReference = mDefault;
974 } else {
975 mReference = cg.readEntry(mKey, mDefault);
976 }
977 mLoadedValue = mReference;
978
979 readImmutability(cg);
980 }
981
setProperty(const QVariant & p)982 void KCoreConfigSkeleton::ItemStringList::setProperty(const QVariant &p)
983 {
984 mReference = p.toStringList();
985 }
986
isEqual(const QVariant & v) const987 bool KCoreConfigSkeleton::ItemStringList::isEqual(const QVariant &v) const
988 {
989 return mReference == v.toStringList();
990 }
991
property() const992 QVariant KCoreConfigSkeleton::ItemStringList::property() const
993 {
994 return QVariant(mReference);
995 }
996
ItemPathList(const QString & _group,const QString & _key,QStringList & reference,const QStringList & defaultValue)997 KCoreConfigSkeleton::ItemPathList::ItemPathList(const QString &_group, const QString &_key, QStringList &reference, const QStringList &defaultValue)
998 : ItemStringList(_group, _key, reference, defaultValue)
999 {
1000 }
1001
readConfig(KConfig * config)1002 void KCoreConfigSkeleton::ItemPathList::readConfig(KConfig *config)
1003 {
1004 KConfigGroup cg = configGroup(config);
1005 if (!cg.hasKey(mKey)) {
1006 mReference = mDefault;
1007 } else {
1008 mReference = cg.readPathEntry(mKey, QStringList());
1009 }
1010 mLoadedValue = mReference;
1011
1012 readImmutability(cg);
1013 }
1014
writeConfig(KConfig * config)1015 void KCoreConfigSkeleton::ItemPathList::writeConfig(KConfig *config)
1016 {
1017 if (mReference != mLoadedValue) { // WABA: Is this test needed?
1018 KConfigGroup cg = configGroup(config);
1019 if ((mDefault == mReference) && !cg.hasDefault(mKey)) {
1020 cg.revertToDefault(mKey, writeFlags());
1021 } else {
1022 QStringList sl = mReference;
1023 cg.writePathEntry(mKey, sl, writeFlags());
1024 }
1025 mLoadedValue = mReference;
1026 }
1027 }
1028
ItemUrlList(const QString & _group,const QString & _key,QList<QUrl> & reference,const QList<QUrl> & defaultValue)1029 KCoreConfigSkeleton::ItemUrlList::ItemUrlList(const QString &_group, const QString &_key, QList<QUrl> &reference, const QList<QUrl> &defaultValue)
1030 : KConfigSkeletonGenericItem<QList<QUrl>>(_group, _key, reference, defaultValue)
1031 {
1032 }
1033
readConfig(KConfig * config)1034 void KCoreConfigSkeleton::ItemUrlList::readConfig(KConfig *config)
1035 {
1036 KConfigGroup cg = configGroup(config);
1037 if (!cg.hasKey(mKey)) {
1038 mReference = mDefault;
1039 } else {
1040 QStringList strList;
1041 for (const QUrl &url : std::as_const(mDefault)) {
1042 strList.append(url.toString());
1043 }
1044 mReference.clear();
1045 const QStringList readList = cg.readEntry<QStringList>(mKey, strList);
1046 for (const QString &str : readList) {
1047 mReference.append(QUrl(str));
1048 }
1049 }
1050 mLoadedValue = mReference;
1051
1052 readImmutability(cg);
1053 }
1054
writeConfig(KConfig * config)1055 void KCoreConfigSkeleton::ItemUrlList::writeConfig(KConfig *config)
1056 {
1057 if (mReference != mLoadedValue) { // WABA: Is this test needed?
1058 KConfigGroup cg = configGroup(config);
1059 if ((mDefault == mReference) && !cg.hasDefault(mKey)) {
1060 cg.revertToDefault(mKey, writeFlags());
1061 } else {
1062 QStringList strList;
1063 for (const QUrl &url : std::as_const(mReference)) {
1064 strList.append(url.toString());
1065 }
1066 cg.writeEntry<QStringList>(mKey, strList, writeFlags());
1067 }
1068 mLoadedValue = mReference;
1069 }
1070 }
1071
setProperty(const QVariant & p)1072 void KCoreConfigSkeleton::ItemUrlList::setProperty(const QVariant &p)
1073 {
1074 mReference = qvariant_cast<QList<QUrl>>(p);
1075 }
1076
isEqual(const QVariant & v) const1077 bool KCoreConfigSkeleton::ItemUrlList::isEqual(const QVariant &v) const
1078 {
1079 return mReference == qvariant_cast<QList<QUrl>>(v);
1080 }
1081
property() const1082 QVariant KCoreConfigSkeleton::ItemUrlList::property() const
1083 {
1084 return QVariant::fromValue<QList<QUrl>>(mReference);
1085 }
1086
ItemIntList(const QString & _group,const QString & _key,QList<int> & reference,const QList<int> & defaultValue)1087 KCoreConfigSkeleton::ItemIntList::ItemIntList(const QString &_group, const QString &_key, QList<int> &reference, const QList<int> &defaultValue)
1088 : KConfigSkeletonGenericItem<QList<int>>(_group, _key, reference, defaultValue)
1089 {
1090 }
1091
readConfig(KConfig * config)1092 void KCoreConfigSkeleton::ItemIntList::readConfig(KConfig *config)
1093 {
1094 KConfigGroup cg = configGroup(config);
1095 if (!cg.hasKey(mKey)) {
1096 mReference = mDefault;
1097 } else {
1098 mReference = cg.readEntry(mKey, mDefault);
1099 }
1100 mLoadedValue = mReference;
1101
1102 readImmutability(cg);
1103 }
1104
setProperty(const QVariant & p)1105 void KCoreConfigSkeleton::ItemIntList::setProperty(const QVariant &p)
1106 {
1107 mReference = qvariant_cast<QList<int>>(p);
1108 }
1109
isEqual(const QVariant & v) const1110 bool KCoreConfigSkeleton::ItemIntList::isEqual(const QVariant &v) const
1111 {
1112 return mReference == qvariant_cast<QList<int>>(v);
1113 }
1114
property() const1115 QVariant KCoreConfigSkeleton::ItemIntList::property() const
1116 {
1117 return QVariant::fromValue<QList<int>>(mReference);
1118 }
1119
1120 // static int kCoreConfigSkeletionDebugArea() { static int s_area = KDebug::registerArea("kdecore (KConfigSkeleton)"); return s_area; }
1121
KCoreConfigSkeleton(const QString & configname,QObject * parent)1122 KCoreConfigSkeleton::KCoreConfigSkeleton(const QString &configname, QObject *parent)
1123 : QObject(parent)
1124 , d(new KCoreConfigSkeletonPrivate)
1125 {
1126 // qDebug() << "Creating KCoreConfigSkeleton (" << (void *)this << ")";
1127
1128 d->mConfig = KSharedConfig::openConfig(configname, KConfig::FullConfig);
1129 }
1130
KCoreConfigSkeleton(KSharedConfig::Ptr pConfig,QObject * parent)1131 KCoreConfigSkeleton::KCoreConfigSkeleton(KSharedConfig::Ptr pConfig, QObject *parent)
1132 : QObject(parent)
1133 , d(new KCoreConfigSkeletonPrivate)
1134 {
1135 // qDebug() << "Creating KCoreConfigSkeleton (" << (void *)this << ")";
1136 d->mConfig = std::move(pConfig);
1137 }
1138
~KCoreConfigSkeleton()1139 KCoreConfigSkeleton::~KCoreConfigSkeleton()
1140 {
1141 delete d;
1142 }
1143
setCurrentGroup(const QString & group)1144 void KCoreConfigSkeleton::setCurrentGroup(const QString &group)
1145 {
1146 d->mCurrentGroup = group;
1147 }
1148
currentGroup() const1149 QString KCoreConfigSkeleton::currentGroup() const
1150 {
1151 return d->mCurrentGroup;
1152 }
1153
config()1154 KConfig *KCoreConfigSkeleton::config()
1155 {
1156 return d->mConfig.data();
1157 }
1158
config() const1159 const KConfig *KCoreConfigSkeleton::config() const
1160 {
1161 return d->mConfig.data();
1162 }
1163
sharedConfig() const1164 KSharedConfig::Ptr KCoreConfigSkeleton::sharedConfig() const
1165 {
1166 return d->mConfig;
1167 }
1168
setSharedConfig(KSharedConfig::Ptr pConfig)1169 void KCoreConfigSkeleton::setSharedConfig(KSharedConfig::Ptr pConfig)
1170 {
1171 d->mConfig = std::move(pConfig);
1172 }
1173
items() const1174 KConfigSkeletonItem::List KCoreConfigSkeleton::items() const
1175 {
1176 return d->mItems;
1177 }
1178
useDefaults(bool b)1179 bool KCoreConfigSkeleton::useDefaults(bool b)
1180 {
1181 if (b == d->mUseDefaults) {
1182 return d->mUseDefaults;
1183 }
1184
1185 d->mUseDefaults = b;
1186 for (auto *skelItem : std::as_const(d->mItems)) {
1187 skelItem->swapDefault();
1188 }
1189
1190 usrUseDefaults(b);
1191 return !d->mUseDefaults;
1192 }
1193
setDefaults()1194 void KCoreConfigSkeleton::setDefaults()
1195 {
1196 for (auto *skelItem : std::as_const(d->mItems)) {
1197 skelItem->setDefault();
1198 }
1199 usrSetDefaults();
1200 }
1201
load()1202 void KCoreConfigSkeleton::load()
1203 {
1204 d->mConfig->reparseConfiguration();
1205 read();
1206 }
1207
read()1208 void KCoreConfigSkeleton::read()
1209 {
1210 for (auto *skelItem : std::as_const(d->mItems)) {
1211 skelItem->readConfig(d->mConfig.data());
1212 }
1213 usrRead();
1214 }
1215
isDefaults() const1216 bool KCoreConfigSkeleton::isDefaults() const
1217 {
1218 return std::all_of(d->mItems.cbegin(), d->mItems.cend(), [](KConfigSkeletonItem *skelItem) {
1219 return skelItem->isDefault();
1220 });
1221 }
1222
isSaveNeeded() const1223 bool KCoreConfigSkeleton::isSaveNeeded() const
1224 {
1225 return std::any_of(d->mItems.cbegin(), d->mItems.cend(), [](KConfigSkeletonItem *skelItem) {
1226 return skelItem->isSaveNeeded();
1227 });
1228 }
1229
save()1230 bool KCoreConfigSkeleton::save()
1231 {
1232 // qDebug();
1233 for (auto *skelItem : std::as_const(d->mItems)) {
1234 skelItem->writeConfig(d->mConfig.data());
1235 }
1236
1237 if (!usrSave()) {
1238 return false;
1239 }
1240
1241 if (d->mConfig->isDirty()) {
1242 if (!d->mConfig->sync()) {
1243 return false;
1244 }
1245 Q_EMIT configChanged();
1246 }
1247 return true;
1248 }
1249
usrUseDefaults(bool)1250 bool KCoreConfigSkeleton::usrUseDefaults(bool)
1251 {
1252 return false;
1253 }
1254
usrSetDefaults()1255 void KCoreConfigSkeleton::usrSetDefaults()
1256 {
1257 }
1258
usrRead()1259 void KCoreConfigSkeleton::usrRead()
1260 {
1261 #if KCONFIGCORE_BUILD_DEPRECATED_SINCE(5, 0)
1262 usrReadConfig();
1263 #endif
1264 }
1265
1266 #if KCONFIGCORE_BUILD_DEPRECATED_SINCE(5, 0)
usrReadConfig()1267 void KCoreConfigSkeleton::usrReadConfig()
1268 {
1269 }
1270 #endif
1271
usrSave()1272 bool KCoreConfigSkeleton::usrSave()
1273 {
1274 #if KCONFIGCORE_BUILD_DEPRECATED_SINCE(5, 0)
1275 return usrWriteConfig();
1276 #else
1277 return true;
1278 #endif
1279 }
1280
1281 #if KCONFIGCORE_BUILD_DEPRECATED_SINCE(5, 0)
usrWriteConfig()1282 bool KCoreConfigSkeleton::usrWriteConfig()
1283 {
1284 return true;
1285 }
1286 #endif
1287
addItem(KConfigSkeletonItem * item,const QString & name)1288 void KCoreConfigSkeleton::addItem(KConfigSkeletonItem *item, const QString &name)
1289 {
1290 if (d->mItems.contains(item)) {
1291 if (item->name() == name || (name.isEmpty() && item->name() == item->key())) {
1292 // nothing to do -> it is already in our collection
1293 // and the name isn't changing
1294 return;
1295 }
1296
1297 d->mItemDict.remove(item->name());
1298 } else {
1299 d->mItems.append(item);
1300 }
1301
1302 item->setName(name.isEmpty() ? item->key() : name);
1303 d->mItemDict.insert(item->name(), item);
1304 item->readDefault(d->mConfig.data());
1305 item->readConfig(d->mConfig.data());
1306 }
1307
removeItem(const QString & name)1308 void KCoreConfigSkeleton::removeItem(const QString &name)
1309 {
1310 KConfigSkeletonItem *item = d->mItemDict.value(name);
1311 if (item) {
1312 d->mItems.removeAll(item);
1313 d->mItemDict.remove(item->name());
1314 delete item;
1315 }
1316 }
1317
clearItems()1318 void KCoreConfigSkeleton::clearItems()
1319 {
1320 KConfigSkeletonItem::List items = d->mItems;
1321 d->mItems.clear();
1322 d->mItemDict.clear();
1323 qDeleteAll(items);
1324 }
1325
addItemString(const QString & name,QString & reference,const QString & defaultValue,const QString & key)1326 KCoreConfigSkeleton::ItemString *KCoreConfigSkeleton::addItemString(const QString &name, QString &reference, const QString &defaultValue, const QString &key)
1327 {
1328 KCoreConfigSkeleton::ItemString *item;
1329 item = new KCoreConfigSkeleton::ItemString(d->mCurrentGroup, key.isEmpty() ? name : key, reference, defaultValue, KCoreConfigSkeleton::ItemString::Normal);
1330 addItem(item, name);
1331 return item;
1332 }
1333
1334 KCoreConfigSkeleton::ItemPassword *
addItemPassword(const QString & name,QString & reference,const QString & defaultValue,const QString & key)1335 KCoreConfigSkeleton::addItemPassword(const QString &name, QString &reference, const QString &defaultValue, const QString &key)
1336 {
1337 KCoreConfigSkeleton::ItemPassword *item;
1338 item = new KCoreConfigSkeleton::ItemPassword(d->mCurrentGroup, key.isNull() ? name : key, reference, defaultValue);
1339 addItem(item, name);
1340 return item;
1341 }
1342
addItemPath(const QString & name,QString & reference,const QString & defaultValue,const QString & key)1343 KCoreConfigSkeleton::ItemPath *KCoreConfigSkeleton::addItemPath(const QString &name, QString &reference, const QString &defaultValue, const QString &key)
1344 {
1345 KCoreConfigSkeleton::ItemPath *item;
1346 item = new KCoreConfigSkeleton::ItemPath(d->mCurrentGroup, key.isNull() ? name : key, reference, defaultValue);
1347 addItem(item, name);
1348 return item;
1349 }
1350
1351 KCoreConfigSkeleton::ItemProperty *
addItemProperty(const QString & name,QVariant & reference,const QVariant & defaultValue,const QString & key)1352 KCoreConfigSkeleton::addItemProperty(const QString &name, QVariant &reference, const QVariant &defaultValue, const QString &key)
1353 {
1354 KCoreConfigSkeleton::ItemProperty *item;
1355 item = new KCoreConfigSkeleton::ItemProperty(d->mCurrentGroup, key.isNull() ? name : key, reference, defaultValue);
1356 addItem(item, name);
1357 return item;
1358 }
1359
addItemBool(const QString & name,bool & reference,bool defaultValue,const QString & key)1360 KCoreConfigSkeleton::ItemBool *KCoreConfigSkeleton::addItemBool(const QString &name, bool &reference, bool defaultValue, const QString &key)
1361 {
1362 KCoreConfigSkeleton::ItemBool *item;
1363 item = new KCoreConfigSkeleton::ItemBool(d->mCurrentGroup, key.isNull() ? name : key, reference, defaultValue);
1364 addItem(item, name);
1365 return item;
1366 }
1367
addItemInt(const QString & name,qint32 & reference,qint32 defaultValue,const QString & key)1368 KCoreConfigSkeleton::ItemInt *KCoreConfigSkeleton::addItemInt(const QString &name, qint32 &reference, qint32 defaultValue, const QString &key)
1369 {
1370 KCoreConfigSkeleton::ItemInt *item;
1371 item = new KCoreConfigSkeleton::ItemInt(d->mCurrentGroup, key.isNull() ? name : key, reference, defaultValue);
1372 addItem(item, name);
1373 return item;
1374 }
1375
addItemUInt(const QString & name,quint32 & reference,quint32 defaultValue,const QString & key)1376 KCoreConfigSkeleton::ItemUInt *KCoreConfigSkeleton::addItemUInt(const QString &name, quint32 &reference, quint32 defaultValue, const QString &key)
1377 {
1378 KCoreConfigSkeleton::ItemUInt *item;
1379 item = new KCoreConfigSkeleton::ItemUInt(d->mCurrentGroup, key.isNull() ? name : key, reference, defaultValue);
1380 addItem(item, name);
1381 return item;
1382 }
1383
addItemLongLong(const QString & name,qint64 & reference,qint64 defaultValue,const QString & key)1384 KCoreConfigSkeleton::ItemLongLong *KCoreConfigSkeleton::addItemLongLong(const QString &name, qint64 &reference, qint64 defaultValue, const QString &key)
1385 {
1386 KCoreConfigSkeleton::ItemLongLong *item;
1387 item = new KCoreConfigSkeleton::ItemLongLong(d->mCurrentGroup, key.isNull() ? name : key, reference, defaultValue);
1388 addItem(item, name);
1389 return item;
1390 }
1391
1392 #if KCONFIGCORE_BUILD_DEPRECATED_SINCE(5, 0)
addItemInt64(const QString & name,qint64 & reference,qint64 defaultValue,const QString & key)1393 KCoreConfigSkeleton::ItemLongLong *KCoreConfigSkeleton::addItemInt64(const QString &name, qint64 &reference, qint64 defaultValue, const QString &key)
1394 {
1395 return addItemLongLong(name, reference, defaultValue, key);
1396 }
1397 #endif
1398
addItemULongLong(const QString & name,quint64 & reference,quint64 defaultValue,const QString & key)1399 KCoreConfigSkeleton::ItemULongLong *KCoreConfigSkeleton::addItemULongLong(const QString &name, quint64 &reference, quint64 defaultValue, const QString &key)
1400 {
1401 KCoreConfigSkeleton::ItemULongLong *item;
1402 item = new KCoreConfigSkeleton::ItemULongLong(d->mCurrentGroup, key.isNull() ? name : key, reference, defaultValue);
1403 addItem(item, name);
1404 return item;
1405 }
1406
1407 #if KCONFIGCORE_BUILD_DEPRECATED_SINCE(5, 0)
addItemUInt64(const QString & name,quint64 & reference,quint64 defaultValue,const QString & key)1408 KCoreConfigSkeleton::ItemULongLong *KCoreConfigSkeleton::addItemUInt64(const QString &name, quint64 &reference, quint64 defaultValue, const QString &key)
1409 {
1410 return addItemULongLong(name, reference, defaultValue, key);
1411 }
1412 #endif
1413
addItemDouble(const QString & name,double & reference,double defaultValue,const QString & key)1414 KCoreConfigSkeleton::ItemDouble *KCoreConfigSkeleton::addItemDouble(const QString &name, double &reference, double defaultValue, const QString &key)
1415 {
1416 KCoreConfigSkeleton::ItemDouble *item;
1417 item = new KCoreConfigSkeleton::ItemDouble(d->mCurrentGroup, key.isNull() ? name : key, reference, defaultValue);
1418 addItem(item, name);
1419 return item;
1420 }
1421
addItemRect(const QString & name,QRect & reference,const QRect & defaultValue,const QString & key)1422 KCoreConfigSkeleton::ItemRect *KCoreConfigSkeleton::addItemRect(const QString &name, QRect &reference, const QRect &defaultValue, const QString &key)
1423 {
1424 KCoreConfigSkeleton::ItemRect *item;
1425 item = new KCoreConfigSkeleton::ItemRect(d->mCurrentGroup, key.isNull() ? name : key, reference, defaultValue);
1426 addItem(item, name);
1427 return item;
1428 }
1429
addItemPoint(const QString & name,QPoint & reference,const QPoint & defaultValue,const QString & key)1430 KCoreConfigSkeleton::ItemPoint *KCoreConfigSkeleton::addItemPoint(const QString &name, QPoint &reference, const QPoint &defaultValue, const QString &key)
1431 {
1432 KCoreConfigSkeleton::ItemPoint *item;
1433 item = new KCoreConfigSkeleton::ItemPoint(d->mCurrentGroup, key.isNull() ? name : key, reference, defaultValue);
1434 addItem(item, name);
1435 return item;
1436 }
1437
addItemSize(const QString & name,QSize & reference,const QSize & defaultValue,const QString & key)1438 KCoreConfigSkeleton::ItemSize *KCoreConfigSkeleton::addItemSize(const QString &name, QSize &reference, const QSize &defaultValue, const QString &key)
1439 {
1440 KCoreConfigSkeleton::ItemSize *item;
1441 item = new KCoreConfigSkeleton::ItemSize(d->mCurrentGroup, key.isNull() ? name : key, reference, defaultValue);
1442 addItem(item, name);
1443 return item;
1444 }
1445
1446 KCoreConfigSkeleton::ItemDateTime *
addItemDateTime(const QString & name,QDateTime & reference,const QDateTime & defaultValue,const QString & key)1447 KCoreConfigSkeleton::addItemDateTime(const QString &name, QDateTime &reference, const QDateTime &defaultValue, const QString &key)
1448 {
1449 KCoreConfigSkeleton::ItemDateTime *item;
1450 item = new KCoreConfigSkeleton::ItemDateTime(d->mCurrentGroup, key.isNull() ? name : key, reference, defaultValue);
1451 addItem(item, name);
1452 return item;
1453 }
1454
1455 KCoreConfigSkeleton::ItemStringList *
addItemStringList(const QString & name,QStringList & reference,const QStringList & defaultValue,const QString & key)1456 KCoreConfigSkeleton::addItemStringList(const QString &name, QStringList &reference, const QStringList &defaultValue, const QString &key)
1457 {
1458 KCoreConfigSkeleton::ItemStringList *item;
1459 item = new KCoreConfigSkeleton::ItemStringList(d->mCurrentGroup, key.isNull() ? name : key, reference, defaultValue);
1460 addItem(item, name);
1461 return item;
1462 }
1463
1464 KCoreConfigSkeleton::ItemIntList *
addItemIntList(const QString & name,QList<int> & reference,const QList<int> & defaultValue,const QString & key)1465 KCoreConfigSkeleton::addItemIntList(const QString &name, QList<int> &reference, const QList<int> &defaultValue, const QString &key)
1466 {
1467 KCoreConfigSkeleton::ItemIntList *item;
1468 item = new KCoreConfigSkeleton::ItemIntList(d->mCurrentGroup, key.isNull() ? name : key, reference, defaultValue);
1469 addItem(item, name);
1470 return item;
1471 }
1472
isImmutable(const QString & name) const1473 bool KCoreConfigSkeleton::isImmutable(const QString &name) const
1474 {
1475 KConfigSkeletonItem *item = findItem(name);
1476 return !item || item->isImmutable();
1477 }
1478
findItem(const QString & name) const1479 KConfigSkeletonItem *KCoreConfigSkeleton::findItem(const QString &name) const
1480 {
1481 return d->mItemDict.value(name);
1482 }
1483
KConfigCompilerSignallingItem(KConfigSkeletonItem * item,QObject * object,KConfigCompilerSignallingItem::NotifyFunction targetFunction,quint64 userData)1484 KConfigCompilerSignallingItem::KConfigCompilerSignallingItem(KConfigSkeletonItem *item,
1485 QObject *object,
1486 KConfigCompilerSignallingItem::NotifyFunction targetFunction,
1487 quint64 userData)
1488 : KConfigSkeletonItem(item->group(), item->key())
1489 , mItem(item)
1490 , mTargetFunction(targetFunction)
1491 , mObject(object)
1492 , mUserData(userData)
1493 {
1494 Q_ASSERT(mTargetFunction);
1495 Q_ASSERT(mItem);
1496 Q_ASSERT(mObject);
1497
1498 setIsDefaultImpl([this] {
1499 return mItem->isDefault();
1500 });
1501 setIsSaveNeededImpl([this] {
1502 return mItem->isSaveNeeded();
1503 });
1504 setGetDefaultImpl([this] {
1505 return mItem->getDefault();
1506 });
1507 }
1508
~KConfigCompilerSignallingItem()1509 KConfigCompilerSignallingItem::~KConfigCompilerSignallingItem()
1510 {
1511 }
1512
isEqual(const QVariant & p) const1513 bool KConfigCompilerSignallingItem::isEqual(const QVariant &p) const
1514 {
1515 return mItem->isEqual(p);
1516 }
1517
property() const1518 QVariant KConfigCompilerSignallingItem::property() const
1519 {
1520 return mItem->property();
1521 }
1522
readConfig(KConfig * c)1523 void KConfigCompilerSignallingItem::readConfig(KConfig *c)
1524 {
1525 QVariant oldValue = mItem->property();
1526 mItem->readConfig(c);
1527 // readConfig() changes mIsImmutable, update it here as well
1528 KConfigGroup cg = configGroup(c);
1529 readImmutability(cg);
1530 if (!mItem->isEqual(oldValue)) {
1531 invokeNotifyFunction();
1532 }
1533 }
1534
readDefault(KConfig * c)1535 void KConfigCompilerSignallingItem::readDefault(KConfig *c)
1536 {
1537 mItem->readDefault(c);
1538 // readDefault() changes mIsImmutable, update it here as well
1539 KConfigGroup cg = configGroup(c);
1540 readImmutability(cg);
1541 }
1542
writeConfig(KConfig * c)1543 void KConfigCompilerSignallingItem::writeConfig(KConfig *c)
1544 {
1545 mItem->writeConfig(c);
1546 }
1547
setDefault()1548 void KConfigCompilerSignallingItem::setDefault()
1549 {
1550 QVariant oldValue = mItem->property();
1551 mItem->setDefault();
1552 if (!mItem->isEqual(oldValue)) {
1553 invokeNotifyFunction();
1554 }
1555 }
1556
setProperty(const QVariant & p)1557 void KConfigCompilerSignallingItem::setProperty(const QVariant &p)
1558 {
1559 if (!mItem->isEqual(p)) {
1560 mItem->setProperty(p);
1561 invokeNotifyFunction();
1562 }
1563 }
1564
swapDefault()1565 void KConfigCompilerSignallingItem::swapDefault()
1566 {
1567 QVariant oldValue = mItem->property();
1568 mItem->swapDefault();
1569 if (!mItem->isEqual(oldValue)) {
1570 invokeNotifyFunction();
1571 }
1572 }
1573
setWriteFlags(KConfigBase::WriteConfigFlags flags)1574 void KConfigCompilerSignallingItem::setWriteFlags(KConfigBase::WriteConfigFlags flags)
1575 {
1576 mItem->setWriteFlags(flags);
1577 }
1578
writeFlags() const1579 KConfigBase::WriteConfigFlags KConfigCompilerSignallingItem::writeFlags() const
1580 {
1581 return mItem->writeFlags();
1582 }
1583
setGroup(const KConfigGroup & cg)1584 void KConfigCompilerSignallingItem::setGroup(const KConfigGroup &cg)
1585 {
1586 mItem->setGroup(cg);
1587 }
1588
configGroup(KConfig * config) const1589 KConfigGroup KConfigCompilerSignallingItem::configGroup(KConfig *config) const
1590 {
1591 return mItem->configGroup(config);
1592 }
1593