Differential D27059 Diff 75829 src/core/kcoreconfigskeleton.cpp

Changeset View

Standalone View

View Options

src/core/kcoreconfigskeleton.cpp

Show First 20 Lines • Show All 58 Lines • ▼ Show 20 Line(s)58{
59 delete d_ptr; 59​ delete d_ptr;
60} 60​}
61 61​
62void KConfigSkeletonItem::setGroup(const QString &_group) 62​void KConfigSkeletonItem::setGroup(const QString &_group)
63{ 63​{
64 mGroup = _group; 64​ mGroup = _group;
65} 65​}
66 66​
67​void KConfigSkeletonItem::setGroup(const KConfigGroup &cg)
68​{
69​ Q_D(KConfigSkeletonItem);
70​ d->mConfigGroup = cg;
71​}
72​
73​KConfigGroup KConfigSkeletonItem::configGroup(KConfig *config) const
74​{
75​ Q_D(const KConfigSkeletonItem);
76​ if (d->mConfigGroup.isValid()) {
77​ return d->mConfigGroup;
78​ }
79​ return KConfigGroup(config, mGroup);
80​}
81​
67QString KConfigSkeletonItem::group() const 82​QString KConfigSkeletonItem::group() const
68{ 83​{
69 return mGroup; 84​ return mGroup;
70} 85​}
71 86​
72void KConfigSkeletonItem::setKey(const QString &_key) 87​void KConfigSkeletonItem::setKey(const QString &_key)
73{ 88​{
74 mKey = _key; 89​ mKey = _key;
▲ Show 20 Lines • Show All 196 Lines • ▼ Show 20 Line(s)282KCoreConfigSkeleton::ItemString::ItemString(const QString &_group, const QString &_key,
271 : KConfigSkeletonGenericItem<QString>(_group, _key, reference, defaultValue), 286​ : KConfigSkeletonGenericItem<QString>(_group, _key, reference, defaultValue),
272 mType(type) 287​ mType(type)
273{ 288​{
274} 289​}
275 290​
276void KCoreConfigSkeleton::ItemString::writeConfig(KConfig *config) 291​void KCoreConfigSkeleton::ItemString::writeConfig(KConfig *config)
277{ 292​{
278 if (mReference != mLoadedValue) { // WABA: Is this test needed? 293​ if (mReference != mLoadedValue) { // WABA: Is this test needed?
279 KConfigGroup cg(config, mGroup); 294​ KConfigGroup cg = configGroup(config);
280 if ((mDefault == mReference) && !cg.hasDefault(mKey)) { 295​ if ((mDefault == mReference) && !cg.hasDefault(mKey)) {
281 cg.revertToDefault(mKey, writeFlags()); 296​ cg.revertToDefault(mKey, writeFlags());
282 } else if (mType == Path) { 297​ } else if (mType == Path) {
283 cg.writePathEntry(mKey, mReference, writeFlags()); 298​ cg.writePathEntry(mKey, mReference, writeFlags());
284 } else if (mType == Password) { 299​ } else if (mType == Password) {
285 cg.writeEntry(mKey, obscuredString(mReference), writeFlags()); 300​ cg.writeEntry(mKey, obscuredString(mReference), writeFlags());
286 } else { 301​ } else {
287 cg.writeEntry(mKey, mReference, writeFlags()); 302​ cg.writeEntry(mKey, mReference, writeFlags());
288 } 303​ }
289 mLoadedValue = mReference; 304​ mLoadedValue = mReference;
290 } 305​ }
291} 306​}
292 307​
293void KCoreConfigSkeleton::ItemString::readConfig(KConfig *config) 308​void KCoreConfigSkeleton::ItemString::readConfig(KConfig *config)
294{ 309​{
295 KConfigGroup cg(config, mGroup); 310​ KConfigGroup cg = configGroup(config);
296 311​
297 if (mType == Path) { 312​ if (mType == Path) {
298 mReference = cg.readPathEntry(mKey, mDefault); 313​ mReference = cg.readPathEntry(mKey, mDefault);
299 } else if (mType == Password) { 314​ } else if (mType == Password) {
300 QString val = cg.readEntry(mKey, obscuredString(mDefault)); 315​ QString val = cg.readEntry(mKey, obscuredString(mDefault));
301 mReference = obscuredString(val); 316​ mReference = obscuredString(val);
302 } else { 317​ } else {
303 mReference = cg.readEntry(mKey, mDefault); 318​ mReference = cg.readEntry(mKey, mDefault);
Show All 38 Lines355KCoreConfigSkeleton::ItemUrl::ItemUrl(const QString &_group, const QString &_key,
342 const QUrl &defaultValue) 357​ const QUrl &defaultValue)
343 : KConfigSkeletonGenericItem<QUrl>(_group, _key, reference, defaultValue) 358​ : KConfigSkeletonGenericItem<QUrl>(_group, _key, reference, defaultValue)
344{ 359​{
345} 360​}
346 361​
347void KCoreConfigSkeleton::ItemUrl::writeConfig(KConfig *config) 362​void KCoreConfigSkeleton::ItemUrl::writeConfig(KConfig *config)
348{ 363​{
349 if (mReference != mLoadedValue) { // WABA: Is this test needed? 364​ if (mReference != mLoadedValue) { // WABA: Is this test needed?
350 KConfigGroup cg(config, mGroup); 365​ KConfigGroup cg = configGroup(config);
351 if ((mDefault == mReference) && !cg.hasDefault(mKey)) { 366​ if ((mDefault == mReference) && !cg.hasDefault(mKey)) {
352 cg.revertToDefault(mKey, writeFlags()); 367​ cg.revertToDefault(mKey, writeFlags());
353 } else { 368​ } else {
354 cg.writeEntry<QString>(mKey, mReference.toString(), writeFlags()); 369​ cg.writeEntry<QString>(mKey, mReference.toString(), writeFlags());
355 } 370​ }
356 mLoadedValue = mReference; 371​ mLoadedValue = mReference;
357 } 372​ }
358} 373​}
359 374​
360void KCoreConfigSkeleton::ItemUrl::readConfig(KConfig *config) 375​void KCoreConfigSkeleton::ItemUrl::readConfig(KConfig *config)
361{ 376​{
362 KConfigGroup cg(config, mGroup); 377​ KConfigGroup cg = configGroup(config);
363 378​
364 mReference = QUrl(cg.readEntry<QString>(mKey, mDefault.toString())); 379​ mReference = QUrl(cg.readEntry<QString>(mKey, mDefault.toString()));
365 mLoadedValue = mReference; 380​ mLoadedValue = mReference;
366 381​
367 readImmutability(cg); 382​ readImmutability(cg);
368} 383​}
369 384​
370void KCoreConfigSkeleton::ItemUrl::setProperty(const QVariant &p) 385​void KCoreConfigSkeleton::ItemUrl::setProperty(const QVariant &p)
Show All 16 Lines400KCoreConfigSkeleton::ItemProperty::ItemProperty(const QString &_group,
387 QVariant &reference, 402​ QVariant &reference,
388 const QVariant &defaultValue) 403​ const QVariant &defaultValue)
389 : KConfigSkeletonGenericItem<QVariant>(_group, _key, reference, defaultValue) 404​ : KConfigSkeletonGenericItem<QVariant>(_group, _key, reference, defaultValue)
390{ 405​{
391} 406​}
392 407​
393void KCoreConfigSkeleton::ItemProperty::readConfig(KConfig *config) 408​void KCoreConfigSkeleton::ItemProperty::readConfig(KConfig *config)
394{ 409​{
395 KConfigGroup cg(config, mGroup); 410​ KConfigGroup cg = configGroup(config);
396 mReference = cg.readEntry(mKey, mDefault); 411​ mReference = cg.readEntry(mKey, mDefault);
397 mLoadedValue = mReference; 412​ mLoadedValue = mReference;
398 413​
399 readImmutability(cg); 414​ readImmutability(cg);
400} 415​}
401 416​
402void KCoreConfigSkeleton::ItemProperty::setProperty(const QVariant &p) 417​void KCoreConfigSkeleton::ItemProperty::setProperty(const QVariant &p)
403{ 418​{
Show All 14 Lines
418KCoreConfigSkeleton::ItemBool::ItemBool(const QString &_group, const QString &_key, 433​KCoreConfigSkeleton::ItemBool::ItemBool(const QString &_group, const QString &_key,
419 bool &reference, bool defaultValue) 434​ bool &reference, bool defaultValue)
420 : KConfigSkeletonGenericItem<bool>(_group, _key, reference, defaultValue) 435​ : KConfigSkeletonGenericItem<bool>(_group, _key, reference, defaultValue)
421{ 436​{
422} 437​}
423 438​
424void KCoreConfigSkeleton::ItemBool::readConfig(KConfig *config) 439​void KCoreConfigSkeleton::ItemBool::readConfig(KConfig *config)
425{ 440​{
426 KConfigGroup cg(config, mGroup); 441​ KConfigGroup cg = configGroup(config);
427 mReference = cg.readEntry(mKey, mDefault); 442​ mReference = cg.readEntry(mKey, mDefault);
428 mLoadedValue = mReference; 443​ mLoadedValue = mReference;
429 444​
430 readImmutability(cg); 445​ readImmutability(cg);
431} 446​}
432 447​
433void KCoreConfigSkeleton::ItemBool::setProperty(const QVariant &p) 448​void KCoreConfigSkeleton::ItemBool::setProperty(const QVariant &p)
434{ 449​{
Show All 14 Lines463KCoreConfigSkeleton::ItemInt::ItemInt(const QString &_group, const QString &_key,
449 qint32 &reference, qint32 defaultValue) 464​ qint32 &reference, qint32 defaultValue)
450 : KConfigSkeletonGenericItem<qint32>(_group, _key, reference, defaultValue) 465​ : KConfigSkeletonGenericItem<qint32>(_group, _key, reference, defaultValue)
451 , mHasMin(false), mHasMax(false) 466​ , mHasMin(false), mHasMax(false)
452{ 467​{
453} 468​}
454 469​
455void KCoreConfigSkeleton::ItemInt::readConfig(KConfig *config) 470​void KCoreConfigSkeleton::ItemInt::readConfig(KConfig *config)
456{ 471​{
457 KConfigGroup cg(config, mGroup); 472​ KConfigGroup cg = configGroup(config);
458 mReference = cg.readEntry(mKey, mDefault); 473​ mReference = cg.readEntry(mKey, mDefault);
459 if (mHasMin) { 474​ if (mHasMin) {
460 mReference = qMax(mReference, mMin); 475​ mReference = qMax(mReference, mMin);
461 } 476​ }
462 if (mHasMax) { 477​ if (mHasMax) {
463 mReference = qMin(mReference, mMax); 478​ mReference = qMin(mReference, mMax);
464 } 479​ }
465 mLoadedValue = mReference; 480​ mLoadedValue = mReference;
▲ Show 20 Lines • Show All 48 Lines • ▼ Show 20 Line(s)528KCoreConfigSkeleton::ItemLongLong::ItemLongLong(const QString &_group, const QString &_key,
514 qint64 &reference, qint64 defaultValue) 529​ qint64 &reference, qint64 defaultValue)
515 : KConfigSkeletonGenericItem<qint64>(_group, _key, reference, defaultValue) 530​ : KConfigSkeletonGenericItem<qint64>(_group, _key, reference, defaultValue)
516 , mHasMin(false), mHasMax(false) 531​ , mHasMin(false), mHasMax(false)
517{ 532​{
518} 533​}
519 534​
520void KCoreConfigSkeleton::ItemLongLong::readConfig(KConfig *config) 535​void KCoreConfigSkeleton::ItemLongLong::readConfig(KConfig *config)
521{ 536​{
522 KConfigGroup cg(config, mGroup); 537​ KConfigGroup cg = configGroup(config);
523 mReference = cg.readEntry(mKey, mDefault); 538​ mReference = cg.readEntry(mKey, mDefault);
524 if (mHasMin) { 539​ if (mHasMin) {
525 mReference = qMax(mReference, mMin); 540​ mReference = qMax(mReference, mMin);
526 } 541​ }
527 if (mHasMax) { 542​ if (mHasMax) {
528 mReference = qMin(mReference, mMax); 543​ mReference = qMin(mReference, mMax);
529 } 544​ }
530 mLoadedValue = mReference; 545​ mLoadedValue = mReference;
▲ Show 20 Lines • Show All 49 Lines • ▼ Show 20 Line(s)593KCoreConfigSkeleton::ItemEnum::ItemEnum(const QString &_group, const QString &_key,
580 const QList<Choice> &choices, 595​ const QList<Choice> &choices,
581 qint32 defaultValue) 596​ qint32 defaultValue)
582 : ItemInt(_group, _key, reference, defaultValue), mChoices(choices) 597​ : ItemInt(_group, _key, reference, defaultValue), mChoices(choices)
583{ 598​{
584} 599​}
585 600​
586void KCoreConfigSkeleton::ItemEnum::readConfig(KConfig *config) 601​void KCoreConfigSkeleton::ItemEnum::readConfig(KConfig *config)
587{ 602​{
588 KConfigGroup cg(config, mGroup); 603​ KConfigGroup cg = configGroup(config);
589 if (!cg.hasKey(mKey)) { 604​ if (!cg.hasKey(mKey)) {
590 mReference = mDefault; 605​ mReference = mDefault;
591 } else { 606​ } else {
592 int i = 0; 607​ int i = 0;
593 mReference = -1; 608​ mReference = -1;
594 QString tmp = cg.readEntry(mKey, QString()).toLower(); 609​ QString tmp = cg.readEntry(mKey, QString()).toLower();
595 for (QList<Choice>::ConstIterator it = mChoices.constBegin(); 610​ for (QList<Choice>::ConstIterator it = mChoices.constBegin();
596 it != mChoices.constEnd(); ++it, ++i) { 611​ it != mChoices.constEnd(); ++it, ++i) {
Show All 9 Lines
606 mLoadedValue = mReference; 621​ mLoadedValue = mReference;
607 622​
608 readImmutability(cg); 623​ readImmutability(cg);
609} 624​}
610 625​
611void KCoreConfigSkeleton::ItemEnum::writeConfig(KConfig *config) 626​void KCoreConfigSkeleton::ItemEnum::writeConfig(KConfig *config)
612{ 627​{
613 if (mReference != mLoadedValue) { // WABA: Is this test needed? 628​ if (mReference != mLoadedValue) { // WABA: Is this test needed?
614 KConfigGroup cg(config, mGroup); 629​ KConfigGroup cg = configGroup(config);
615 if ((mDefault == mReference) && !cg.hasDefault(mKey)) { 630​ if ((mDefault == mReference) && !cg.hasDefault(mKey)) {
616 cg.revertToDefault(mKey, writeFlags()); 631​ cg.revertToDefault(mKey, writeFlags());
617 } else if ((mReference >= 0) && (mReference < mChoices.count())) { 632​ } else if ((mReference >= 0) && (mReference < mChoices.count())) {
618 cg.writeEntry(mKey, mChoices[mReference].name, writeFlags()); 633​ cg.writeEntry(mKey, mChoices[mReference].name, writeFlags());
619 } else { 634​ } else {
620 cg.writeEntry(mKey, mReference, writeFlags()); 635​ cg.writeEntry(mKey, mReference, writeFlags());
621 } 636​ }
622 mLoadedValue = mReference; 637​ mLoadedValue = mReference;
Show All 15 Lines651KCoreConfigSkeleton::ItemUInt::ItemUInt(const QString &_group, const QString &_key,
638 quint32 defaultValue) 653​ quint32 defaultValue)
639 : KConfigSkeletonGenericItem<quint32>(_group, _key, reference, defaultValue) 654​ : KConfigSkeletonGenericItem<quint32>(_group, _key, reference, defaultValue)
640 , mHasMin(false), mHasMax(false) 655​ , mHasMin(false), mHasMax(false)
641{ 656​{
642} 657​}
643 658​
644void KCoreConfigSkeleton::ItemUInt::readConfig(KConfig *config) 659​void KCoreConfigSkeleton::ItemUInt::readConfig(KConfig *config)
645{ 660​{
646 KConfigGroup cg(config, mGroup); 661​ KConfigGroup cg = configGroup(config);
647 mReference = cg.readEntry(mKey, mDefault); 662​ mReference = cg.readEntry(mKey, mDefault);
648 if (mHasMin) { 663​ if (mHasMin) {
649 mReference = qMax(mReference, mMin); 664​ mReference = qMax(mReference, mMin);
650 } 665​ }
651 if (mHasMax) { 666​ if (mHasMax) {
652 mReference = qMin(mReference, mMax); 667​ mReference = qMin(mReference, mMax);
653 } 668​ }
654 mLoadedValue = mReference; 669​ mLoadedValue = mReference;
▲ Show 20 Lines • Show All 48 Lines • ▼ Show 20 Line(s)717KCoreConfigSkeleton::ItemULongLong::ItemULongLong(const QString &_group, const QString &_key,
703 quint64 &reference, quint64 defaultValue) 718​ quint64 &reference, quint64 defaultValue)
704 : KConfigSkeletonGenericItem<quint64>(_group, _key, reference, defaultValue) 719​ : KConfigSkeletonGenericItem<quint64>(_group, _key, reference, defaultValue)
705 , mHasMin(false), mHasMax(false) 720​ , mHasMin(false), mHasMax(false)
706{ 721​{
707} 722​}
708 723​
709void KCoreConfigSkeleton::ItemULongLong::readConfig(KConfig *config) 724​void KCoreConfigSkeleton::ItemULongLong::readConfig(KConfig *config)
710{ 725​{
711 KConfigGroup cg(config, mGroup); 726​ KConfigGroup cg = configGroup(config);
712 mReference = cg.readEntry(mKey, mDefault); 727​ mReference = cg.readEntry(mKey, mDefault);
713 if (mHasMin) { 728​ if (mHasMin) {
714 mReference = qMax(mReference, mMin); 729​ mReference = qMax(mReference, mMin);
715 } 730​ }
716 if (mHasMax) { 731​ if (mHasMax) {
717 mReference = qMin(mReference, mMax); 732​ mReference = qMin(mReference, mMax);
718 } 733​ }
719 mLoadedValue = mReference; 734​ mLoadedValue = mReference;
▲ Show 20 Lines • Show All 48 Lines • ▼ Show 20 Line(s)782KCoreConfigSkeleton::ItemDouble::ItemDouble(const QString &_group, const QString &_key,
768 double &reference, double defaultValue) 783​ double &reference, double defaultValue)
769 : KConfigSkeletonGenericItem<double>(_group, _key, reference, defaultValue) 784​ : KConfigSkeletonGenericItem<double>(_group, _key, reference, defaultValue)
770 , mHasMin(false), mHasMax(false) 785​ , mHasMin(false), mHasMax(false)
771{ 786​{
772} 787​}
773 788​
774void KCoreConfigSkeleton::ItemDouble::readConfig(KConfig *config) 789​void KCoreConfigSkeleton::ItemDouble::readConfig(KConfig *config)
775{ 790​{
776 KConfigGroup cg(config, mGroup); 791​ KConfigGroup cg = configGroup(config);
777 mReference = cg.readEntry(mKey, mDefault); 792​ mReference = cg.readEntry(mKey, mDefault);
778 if (mHasMin) { 793​ if (mHasMin) {
779 mReference = qMax(mReference, mMin); 794​ mReference = qMax(mReference, mMin);
780 } 795​ }
781 if (mHasMax) { 796​ if (mHasMax) {
782 mReference = qMin(mReference, mMax); 797​ mReference = qMin(mReference, mMax);
783 } 798​ }
784 mLoadedValue = mReference; 799​ mLoadedValue = mReference;
▲ Show 20 Lines • Show All 48 Lines • ▼ Show 20 Line(s)847KCoreConfigSkeleton::ItemRect::ItemRect(const QString &_group, const QString &_key,
833 QRect &reference, 848​ QRect &reference,
834 const QRect &defaultValue) 849​ const QRect &defaultValue)
835 : KConfigSkeletonGenericItem<QRect>(_group, _key, reference, defaultValue) 850​ : KConfigSkeletonGenericItem<QRect>(_group, _key, reference, defaultValue)
836{ 851​{
837} 852​}
838 853​
839void KCoreConfigSkeleton::ItemRect::readConfig(KConfig *config) 854​void KCoreConfigSkeleton::ItemRect::readConfig(KConfig *config)
840{ 855​{
841 KConfigGroup cg(config, mGroup); 856​ KConfigGroup cg = configGroup(config);
842 mReference = cg.readEntry(mKey, mDefault); 857​ mReference = cg.readEntry(mKey, mDefault);
843 mLoadedValue = mReference; 858​ mLoadedValue = mReference;
844 859​
845 readImmutability(cg); 860​ readImmutability(cg);
846} 861​}
847 862​
848void KCoreConfigSkeleton::ItemRect::setProperty(const QVariant &p) 863​void KCoreConfigSkeleton::ItemRect::setProperty(const QVariant &p)
849{ 864​{
Show All 14 Lines878KCoreConfigSkeleton::ItemPoint::ItemPoint(const QString &_group, const QString &_key,
864 QPoint &reference, 879​ QPoint &reference,
865 const QPoint &defaultValue) 880​ const QPoint &defaultValue)
866 : KConfigSkeletonGenericItem<QPoint>(_group, _key, reference, defaultValue) 881​ : KConfigSkeletonGenericItem<QPoint>(_group, _key, reference, defaultValue)
867{ 882​{
868} 883​}
869 884​
870void KCoreConfigSkeleton::ItemPoint::readConfig(KConfig *config) 885​void KCoreConfigSkeleton::ItemPoint::readConfig(KConfig *config)
871{ 886​{
872 KConfigGroup cg(config, mGroup); 887​ KConfigGroup cg = configGroup(config);
873 mReference = cg.readEntry(mKey, mDefault); 888​ mReference = cg.readEntry(mKey, mDefault);
874 mLoadedValue = mReference; 889​ mLoadedValue = mReference;
875 890​
876 readImmutability(cg); 891​ readImmutability(cg);
877} 892​}
878 893​
879void KCoreConfigSkeleton::ItemPoint::setProperty(const QVariant &p) 894​void KCoreConfigSkeleton::ItemPoint::setProperty(const QVariant &p)
880{ 895​{
Show All 14 Lines909KCoreConfigSkeleton::ItemSize::ItemSize(const QString &_group, const QString &_key,
895 QSize &reference, 910​ QSize &reference,
896 const QSize &defaultValue) 911​ const QSize &defaultValue)
897 : KConfigSkeletonGenericItem<QSize>(_group, _key, reference, defaultValue) 912​ : KConfigSkeletonGenericItem<QSize>(_group, _key, reference, defaultValue)
898{ 913​{
899} 914​}
900 915​
901void KCoreConfigSkeleton::ItemSize::readConfig(KConfig *config) 916​void KCoreConfigSkeleton::ItemSize::readConfig(KConfig *config)
902{ 917​{
903 KConfigGroup cg(config, mGroup); 918​ KConfigGroup cg = configGroup(config);
904 mReference = cg.readEntry(mKey, mDefault); 919​ mReference = cg.readEntry(mKey, mDefault);
905 mLoadedValue = mReference; 920​ mLoadedValue = mReference;
906 921​
907 readImmutability(cg); 922​ readImmutability(cg);
908} 923​}
909 924​
910void KCoreConfigSkeleton::ItemSize::setProperty(const QVariant &p) 925​void KCoreConfigSkeleton::ItemSize::setProperty(const QVariant &p)
911{ 926​{
Show All 14 Lines940KCoreConfigSkeleton::ItemDateTime::ItemDateTime(const QString &_group, const QString &_key,
926 QDateTime &reference, 941​ QDateTime &reference,
927 const QDateTime &defaultValue) 942​ const QDateTime &defaultValue)
928 : KConfigSkeletonGenericItem<QDateTime>(_group, _key, reference, defaultValue) 943​ : KConfigSkeletonGenericItem<QDateTime>(_group, _key, reference, defaultValue)
929{ 944​{
930} 945​}
931 946​
932void KCoreConfigSkeleton::ItemDateTime::readConfig(KConfig *config) 947​void KCoreConfigSkeleton::ItemDateTime::readConfig(KConfig *config)
933{ 948​{
934 KConfigGroup cg(config, mGroup); 949​ KConfigGroup cg = configGroup(config);
935 mReference = cg.readEntry(mKey, mDefault); 950​ mReference = cg.readEntry(mKey, mDefault);
936 mLoadedValue = mReference; 951​ mLoadedValue = mReference;
937 952​
938 readImmutability(cg); 953​ readImmutability(cg);
939} 954​}
940 955​
941void KCoreConfigSkeleton::ItemDateTime::setProperty(const QVariant &p) 956​void KCoreConfigSkeleton::ItemDateTime::setProperty(const QVariant &p)
942{ 957​{
Show All 14 Lines971KCoreConfigSkeleton::ItemStringList::ItemStringList(const QString &_group, const QString &_key,
957 QStringList &reference, 972​ QStringList &reference,
958 const QStringList &defaultValue) 973​ const QStringList &defaultValue)
959 : KConfigSkeletonGenericItem<QStringList>(_group, _key, reference, defaultValue) 974​ : KConfigSkeletonGenericItem<QStringList>(_group, _key, reference, defaultValue)
960{ 975​{
961} 976​}
962 977​
963void KCoreConfigSkeleton::ItemStringList::readConfig(KConfig *config) 978​void KCoreConfigSkeleton::ItemStringList::readConfig(KConfig *config)
964{ 979​{
965 KConfigGroup cg(config, mGroup); 980​ KConfigGroup cg = configGroup(config);
966 if (!cg.hasKey(mKey)) { 981​ if (!cg.hasKey(mKey)) {
967 mReference = mDefault; 982​ mReference = mDefault;
968 } else { 983​ } else {
969 mReference = cg.readEntry(mKey, mDefault); 984​ mReference = cg.readEntry(mKey, mDefault);
970 } 985​ }
971 mLoadedValue = mReference; 986​ mLoadedValue = mReference;
972 987​
973 readImmutability(cg); 988​ readImmutability(cg);
Show All 18 Lines1006KCoreConfigSkeleton::ItemPathList::ItemPathList(const QString &_group, const QString &_key,
992 QStringList &reference, 1007​ QStringList &reference,
993 const QStringList &defaultValue) 1008​ const QStringList &defaultValue)
994 : ItemStringList(_group, _key, reference, defaultValue) 1009​ : ItemStringList(_group, _key, reference, defaultValue)
995{ 1010​{
996} 1011​}
997 1012​
998void KCoreConfigSkeleton::ItemPathList::readConfig(KConfig *config) 1013​void KCoreConfigSkeleton::ItemPathList::readConfig(KConfig *config)
999{ 1014​{
1000 KConfigGroup cg(config, mGroup); 1015​ KConfigGroup cg = configGroup(config);
1001 if (!cg.hasKey(mKey)) { 1016​ if (!cg.hasKey(mKey)) {
1002 mReference = mDefault; 1017​ mReference = mDefault;
1003 } else { 1018​ } else {
1004 mReference = cg.readPathEntry(mKey, QStringList()); 1019​ mReference = cg.readPathEntry(mKey, QStringList());
1005 } 1020​ }
1006 mLoadedValue = mReference; 1021​ mLoadedValue = mReference;
1007 1022​
1008 readImmutability(cg); 1023​ readImmutability(cg);
1009} 1024​}
1010 1025​
1011void KCoreConfigSkeleton::ItemPathList::writeConfig(KConfig *config) 1026​void KCoreConfigSkeleton::ItemPathList::writeConfig(KConfig *config)
1012{ 1027​{
1013 if (mReference != mLoadedValue) { // WABA: Is this test needed? 1028​ if (mReference != mLoadedValue) { // WABA: Is this test needed?
1014 KConfigGroup cg(config, mGroup); 1029​ KConfigGroup cg = configGroup(config);
1015 if ((mDefault == mReference) && !cg.hasDefault(mKey)) { 1030​ if ((mDefault == mReference) && !cg.hasDefault(mKey)) {
1016 cg.revertToDefault(mKey, writeFlags()); 1031​ cg.revertToDefault(mKey, writeFlags());
1017 } else { 1032​ } else {
1018 QStringList sl = mReference; 1033​ QStringList sl = mReference;
1019 cg.writePathEntry(mKey, sl, writeFlags()); 1034​ cg.writePathEntry(mKey, sl, writeFlags());
1020 } 1035​ }
1021 mLoadedValue = mReference; 1036​ mLoadedValue = mReference;
1022 } 1037​ }
1023} 1038​}
1024 1039​
1025KCoreConfigSkeleton::ItemUrlList::ItemUrlList(const QString &_group, const QString &_key, 1040​KCoreConfigSkeleton::ItemUrlList::ItemUrlList(const QString &_group, const QString &_key,
1026 QList<QUrl> &reference, 1041​ QList<QUrl> &reference,
1027 const QList<QUrl> &defaultValue) 1042​ const QList<QUrl> &defaultValue)
1028 : KConfigSkeletonGenericItem<QList<QUrl> >(_group, _key, reference, defaultValue) 1043​ : KConfigSkeletonGenericItem<QList<QUrl> >(_group, _key, reference, defaultValue)
1029{ 1044​{
1030} 1045​}
1031 1046​
1032void KCoreConfigSkeleton::ItemUrlList::readConfig(KConfig *config) 1047​void KCoreConfigSkeleton::ItemUrlList::readConfig(KConfig *config)
1033{ 1048​{
1034 KConfigGroup cg(config, mGroup); 1049​ KConfigGroup cg = configGroup(config);
1035 if (!cg.hasKey(mKey)) { 1050​ if (!cg.hasKey(mKey)) {
1036 mReference = mDefault; 1051​ mReference = mDefault;
1037 } else { 1052​ } else {
1038 QStringList strList; 1053​ QStringList strList;
1039 for (const QUrl &url : qAsConst(mDefault)) { 1054​ for (const QUrl &url : qAsConst(mDefault)) {
1040 strList.append(url.toString()); 1055​ strList.append(url.toString());
1041 } 1056​ }
1042 mReference.clear(); 1057​ mReference.clear();
1043 const QStringList readList = cg.readEntry<QStringList>(mKey, strList); 1058​ const QStringList readList = cg.readEntry<QStringList>(mKey, strList);
1044 for (const QString &str : readList) { 1059​ for (const QString &str : readList) {
1045 mReference.append(QUrl(str)); 1060​ mReference.append(QUrl(str));
1046 } 1061​ }
1047 } 1062​ }
1048 mLoadedValue = mReference; 1063​ mLoadedValue = mReference;
1049 1064​
1050 readImmutability(cg); 1065​ readImmutability(cg);
1051} 1066​}
1052 1067​
1053void KCoreConfigSkeleton::ItemUrlList::writeConfig(KConfig *config) 1068​void KCoreConfigSkeleton::ItemUrlList::writeConfig(KConfig *config)
1054{ 1069​{
1055 if (mReference != mLoadedValue) { // WABA: Is this test needed? 1070​ if (mReference != mLoadedValue) { // WABA: Is this test needed?
1056 KConfigGroup cg(config, mGroup); 1071​ KConfigGroup cg = configGroup(config);
1057 if ((mDefault == mReference) && !cg.hasDefault(mKey)) { 1072​ if ((mDefault == mReference) && !cg.hasDefault(mKey)) {
1058 cg.revertToDefault(mKey, writeFlags()); 1073​ cg.revertToDefault(mKey, writeFlags());
1059 } else { 1074​ } else {
1060 QStringList strList; 1075​ QStringList strList;
1061 for (const QUrl &url : qAsConst(mReference)) { 1076​ for (const QUrl &url : qAsConst(mReference)) {
1062 strList.append(url.toString()); 1077​ strList.append(url.toString());
1063 } 1078​ }
1064 cg.writeEntry<QStringList>(mKey, strList, writeFlags()); 1079​ cg.writeEntry<QStringList>(mKey, strList, writeFlags());
Show All 21 Lines1100KCoreConfigSkeleton::ItemIntList::ItemIntList(const QString &_group, const QString &_key,
1086 QList<int> &reference, 1101​ QList<int> &reference,
1087 const QList<int> &defaultValue) 1102​ const QList<int> &defaultValue)
1088 : KConfigSkeletonGenericItem<QList<int> >(_group, _key, reference, defaultValue) 1103​ : KConfigSkeletonGenericItem<QList<int> >(_group, _key, reference, defaultValue)
1089{ 1104​{
1090} 1105​}
1091 1106​
1092void KCoreConfigSkeleton::ItemIntList::readConfig(KConfig *config) 1107​void KCoreConfigSkeleton::ItemIntList::readConfig(KConfig *config)
1093{ 1108​{
1094 KConfigGroup cg(config, mGroup); 1109​ KConfigGroup cg = configGroup(config);
1095 if (!cg.hasKey(mKey)) { 1110​ if (!cg.hasKey(mKey)) {
1096 mReference = mDefault; 1111​ mReference = mDefault;
1097 } else { 1112​ } else {
1098 mReference = cg.readEntry(mKey, mDefault); 1113​ mReference = cg.readEntry(mKey, mDefault);
1099 } 1114​ }
1100 mLoadedValue = mReference; 1115​ mLoadedValue = mReference;
1101 1116​
1102 readImmutability(cg); 1117​ readImmutability(cg);
▲ Show 20 Lines • Show All 452 Lines • ▼ Show 20 Line(s)1569{
1555 return mItem->property(); 1570​ return mItem->property();
1556} 1571​}
1557 1572​
1558void KConfigCompilerSignallingItem::readConfig(KConfig* c) 1573​void KConfigCompilerSignallingItem::readConfig(KConfig* c)
1559{ 1574​{
1560 QVariant oldValue = mItem->property(); 1575​ QVariant oldValue = mItem->property();
1561 mItem->readConfig(c); 1576​ mItem->readConfig(c);
1562 //readConfig() changes mIsImmutable, update it here as well 1577​ //readConfig() changes mIsImmutable, update it here as well
1563 KConfigGroup cg(c, mGroup ); 1578​ KConfigGroup cg = configGroup(c);
1564 readImmutability(cg); 1579​ readImmutability(cg);
1565 if (!mItem->isEqual(oldValue)) { 1580​ if (!mItem->isEqual(oldValue)) {
1566 invokeNotifyFunction(); 1581​ invokeNotifyFunction();
1567 } 1582​ }
1568} 1583​}
1569 1584​
1570void KConfigCompilerSignallingItem::readDefault(KConfig* c) 1585​void KConfigCompilerSignallingItem::readDefault(KConfig* c)
1571{ 1586​{
1572 mItem->readDefault(c); 1587​ mItem->readDefault(c);
1573 //readDefault() changes mIsImmutable, update it here as well 1588​ //readDefault() changes mIsImmutable, update it here as well
1574 KConfigGroup cg(c, mGroup ); 1589​ KConfigGroup cg = configGroup(c);
1575 readImmutability(cg); 1590​ readImmutability(cg);
1576} 1591​}
1577 1592​
1578void KConfigCompilerSignallingItem::writeConfig(KConfig* c) 1593​void KConfigCompilerSignallingItem::writeConfig(KConfig* c)
1579{ 1594​{
1580 mItem->writeConfig(c); 1595​ mItem->writeConfig(c);
1581} 1596​}
1582 1597​
Show All 27 Lines
1610{ 1625​{
1611 mItem->setWriteFlags(flags); 1626​ mItem->setWriteFlags(flags);
1612} 1627​}
1613 1628​
1614KConfigBase::WriteConfigFlags KConfigCompilerSignallingItem::writeFlags() const 1629​KConfigBase::WriteConfigFlags KConfigCompilerSignallingItem::writeFlags() const
1615{ 1630​{
1616 return mItem->writeFlags(); 1631​ return mItem->writeFlags();
1617} 1632​}
1633​
1634​void KConfigCompilerSignallingItem::setGroup(const KConfigGroup &cg)
ervinUnsubmitted
Done

Space before & not after

ervin: Space before & not after
1635​{
1636​ mItem->setGroup(cg);
1637​}
1638​
1639​KConfigGroup KConfigCompilerSignallingItem::configGroup(KConfig *config) const
ervinUnsubmitted
Done

Space before * not after

ervin: Space before * not after
1640​{
1641​ return mItem->configGroup(config);
1642​}