Differential D27059 Diff 74754 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 178 Lines • ▼ Show 20 Line(s)264KCoreConfigSkeleton::ItemString::ItemString(const QString &_group, const QString &_key,
253 : KConfigSkeletonGenericItem<QString>(_group, _key, reference, defaultValue), 268​ : KConfigSkeletonGenericItem<QString>(_group, _key, reference, defaultValue),
254 mType(type) 269​ mType(type)
255{ 270​{
256} 271​}
257 272​
258void KCoreConfigSkeleton::ItemString::writeConfig(KConfig *config) 273​void KCoreConfigSkeleton::ItemString::writeConfig(KConfig *config)
259{ 274​{
260 if (mReference != mLoadedValue) { // WABA: Is this test needed? 275​ if (mReference != mLoadedValue) { // WABA: Is this test needed?
261 KConfigGroup cg(config, mGroup); 276​ KConfigGroup cg = configGroup(config);
262 if ((mDefault == mReference) && !cg.hasDefault(mKey)) { 277​ if ((mDefault == mReference) && !cg.hasDefault(mKey)) {
263 cg.revertToDefault(mKey, writeFlags()); 278​ cg.revertToDefault(mKey, writeFlags());
264 } else if (mType == Path) { 279​ } else if (mType == Path) {
265 cg.writePathEntry(mKey, mReference, writeFlags()); 280​ cg.writePathEntry(mKey, mReference, writeFlags());
266 } else if (mType == Password) { 281​ } else if (mType == Password) {
267 cg.writeEntry(mKey, obscuredString(mReference), writeFlags()); 282​ cg.writeEntry(mKey, obscuredString(mReference), writeFlags());
268 } else { 283​ } else {
269 cg.writeEntry(mKey, mReference, writeFlags()); 284​ cg.writeEntry(mKey, mReference, writeFlags());
270 } 285​ }
271 mLoadedValue = mReference; 286​ mLoadedValue = mReference;
272 } 287​ }
273} 288​}
274 289​
275void KCoreConfigSkeleton::ItemString::readConfig(KConfig *config) 290​void KCoreConfigSkeleton::ItemString::readConfig(KConfig *config)
276{ 291​{
277 KConfigGroup cg(config, mGroup); 292​ KConfigGroup cg = configGroup(config);
278 293​
279 if (mType == Path) { 294​ if (mType == Path) {
280 mReference = cg.readPathEntry(mKey, mDefault); 295​ mReference = cg.readPathEntry(mKey, mDefault);
281 } else if (mType == Password) { 296​ } else if (mType == Password) {
282 QString val = cg.readEntry(mKey, obscuredString(mDefault)); 297​ QString val = cg.readEntry(mKey, obscuredString(mDefault));
283 mReference = obscuredString(val); 298​ mReference = obscuredString(val);
284 } else { 299​ } else {
285 mReference = cg.readEntry(mKey, mDefault); 300​ mReference = cg.readEntry(mKey, mDefault);
Show All 38 Lines337KCoreConfigSkeleton::ItemUrl::ItemUrl(const QString &_group, const QString &_key,
324 const QUrl &defaultValue) 339​ const QUrl &defaultValue)
325 : KConfigSkeletonGenericItem<QUrl>(_group, _key, reference, defaultValue) 340​ : KConfigSkeletonGenericItem<QUrl>(_group, _key, reference, defaultValue)
326{ 341​{
327} 342​}
328 343​
329void KCoreConfigSkeleton::ItemUrl::writeConfig(KConfig *config) 344​void KCoreConfigSkeleton::ItemUrl::writeConfig(KConfig *config)
330{ 345​{
331 if (mReference != mLoadedValue) { // WABA: Is this test needed? 346​ if (mReference != mLoadedValue) { // WABA: Is this test needed?
332 KConfigGroup cg(config, mGroup); 347​ KConfigGroup cg = configGroup(config);
333 if ((mDefault == mReference) && !cg.hasDefault(mKey)) { 348​ if ((mDefault == mReference) && !cg.hasDefault(mKey)) {
334 cg.revertToDefault(mKey, writeFlags()); 349​ cg.revertToDefault(mKey, writeFlags());
335 } else { 350​ } else {
336 cg.writeEntry<QString>(mKey, mReference.toString(), writeFlags()); 351​ cg.writeEntry<QString>(mKey, mReference.toString(), writeFlags());
337 } 352​ }
338 mLoadedValue = mReference; 353​ mLoadedValue = mReference;
339 } 354​ }
340} 355​}
341 356​
342void KCoreConfigSkeleton::ItemUrl::readConfig(KConfig *config) 357​void KCoreConfigSkeleton::ItemUrl::readConfig(KConfig *config)
343{ 358​{
344 KConfigGroup cg(config, mGroup); 359​ KConfigGroup cg = configGroup(config);
345 360​
346 mReference = QUrl(cg.readEntry<QString>(mKey, mDefault.toString())); 361​ mReference = QUrl(cg.readEntry<QString>(mKey, mDefault.toString()));
347 mLoadedValue = mReference; 362​ mLoadedValue = mReference;
348 363​
349 readImmutability(cg); 364​ readImmutability(cg);
350} 365​}
351 366​
352void KCoreConfigSkeleton::ItemUrl::setProperty(const QVariant &p) 367​void KCoreConfigSkeleton::ItemUrl::setProperty(const QVariant &p)
Show All 16 Lines382KCoreConfigSkeleton::ItemProperty::ItemProperty(const QString &_group,
369 QVariant &reference, 384​ QVariant &reference,
370 const QVariant &defaultValue) 385​ const QVariant &defaultValue)
371 : KConfigSkeletonGenericItem<QVariant>(_group, _key, reference, defaultValue) 386​ : KConfigSkeletonGenericItem<QVariant>(_group, _key, reference, defaultValue)
372{ 387​{
373} 388​}
374 389​
375void KCoreConfigSkeleton::ItemProperty::readConfig(KConfig *config) 390​void KCoreConfigSkeleton::ItemProperty::readConfig(KConfig *config)
376{ 391​{
377 KConfigGroup cg(config, mGroup); 392​ KConfigGroup cg = configGroup(config);
378 mReference = cg.readEntry(mKey, mDefault); 393​ mReference = cg.readEntry(mKey, mDefault);
379 mLoadedValue = mReference; 394​ mLoadedValue = mReference;
380 395​
381 readImmutability(cg); 396​ readImmutability(cg);
382} 397​}
383 398​
384void KCoreConfigSkeleton::ItemProperty::setProperty(const QVariant &p) 399​void KCoreConfigSkeleton::ItemProperty::setProperty(const QVariant &p)
385{ 400​{
Show All 14 Lines
400KCoreConfigSkeleton::ItemBool::ItemBool(const QString &_group, const QString &_key, 415​KCoreConfigSkeleton::ItemBool::ItemBool(const QString &_group, const QString &_key,
401 bool &reference, bool defaultValue) 416​ bool &reference, bool defaultValue)
402 : KConfigSkeletonGenericItem<bool>(_group, _key, reference, defaultValue) 417​ : KConfigSkeletonGenericItem<bool>(_group, _key, reference, defaultValue)
403{ 418​{
404} 419​}
405 420​
406void KCoreConfigSkeleton::ItemBool::readConfig(KConfig *config) 421​void KCoreConfigSkeleton::ItemBool::readConfig(KConfig *config)
407{ 422​{
408 KConfigGroup cg(config, mGroup); 423​ KConfigGroup cg = configGroup(config);
409 mReference = cg.readEntry(mKey, mDefault); 424​ mReference = cg.readEntry(mKey, mDefault);
410 mLoadedValue = mReference; 425​ mLoadedValue = mReference;
411 426​
412 readImmutability(cg); 427​ readImmutability(cg);
413} 428​}
414 429​
415void KCoreConfigSkeleton::ItemBool::setProperty(const QVariant &p) 430​void KCoreConfigSkeleton::ItemBool::setProperty(const QVariant &p)
416{ 431​{
Show All 14 Lines445KCoreConfigSkeleton::ItemInt::ItemInt(const QString &_group, const QString &_key,
431 qint32 &reference, qint32 defaultValue) 446​ qint32 &reference, qint32 defaultValue)
432 : KConfigSkeletonGenericItem<qint32>(_group, _key, reference, defaultValue) 447​ : KConfigSkeletonGenericItem<qint32>(_group, _key, reference, defaultValue)
433 , mHasMin(false), mHasMax(false) 448​ , mHasMin(false), mHasMax(false)
434{ 449​{
435} 450​}
436 451​
437void KCoreConfigSkeleton::ItemInt::readConfig(KConfig *config) 452​void KCoreConfigSkeleton::ItemInt::readConfig(KConfig *config)
438{ 453​{
439 KConfigGroup cg(config, mGroup); 454​ KConfigGroup cg = configGroup(config);
440 mReference = cg.readEntry(mKey, mDefault); 455​ mReference = cg.readEntry(mKey, mDefault);
441 if (mHasMin) { 456​ if (mHasMin) {
442 mReference = qMax(mReference, mMin); 457​ mReference = qMax(mReference, mMin);
443 } 458​ }
444 if (mHasMax) { 459​ if (mHasMax) {
445 mReference = qMin(mReference, mMax); 460​ mReference = qMin(mReference, mMax);
446 } 461​ }
447 mLoadedValue = mReference; 462​ mLoadedValue = mReference;
▲ Show 20 Lines • Show All 48 Lines • ▼ Show 20 Line(s)510KCoreConfigSkeleton::ItemLongLong::ItemLongLong(const QString &_group, const QString &_key,
496 qint64 &reference, qint64 defaultValue) 511​ qint64 &reference, qint64 defaultValue)
497 : KConfigSkeletonGenericItem<qint64>(_group, _key, reference, defaultValue) 512​ : KConfigSkeletonGenericItem<qint64>(_group, _key, reference, defaultValue)
498 , mHasMin(false), mHasMax(false) 513​ , mHasMin(false), mHasMax(false)
499{ 514​{
500} 515​}
501 516​
502void KCoreConfigSkeleton::ItemLongLong::readConfig(KConfig *config) 517​void KCoreConfigSkeleton::ItemLongLong::readConfig(KConfig *config)
503{ 518​{
504 KConfigGroup cg(config, mGroup); 519​ KConfigGroup cg = configGroup(config);
505 mReference = cg.readEntry(mKey, mDefault); 520​ mReference = cg.readEntry(mKey, mDefault);
506 if (mHasMin) { 521​ if (mHasMin) {
507 mReference = qMax(mReference, mMin); 522​ mReference = qMax(mReference, mMin);
508 } 523​ }
509 if (mHasMax) { 524​ if (mHasMax) {
510 mReference = qMin(mReference, mMax); 525​ mReference = qMin(mReference, mMax);
511 } 526​ }
512 mLoadedValue = mReference; 527​ mLoadedValue = mReference;
▲ Show 20 Lines • Show All 49 Lines • ▼ Show 20 Line(s)575KCoreConfigSkeleton::ItemEnum::ItemEnum(const QString &_group, const QString &_key,
562 const QList<Choice> &choices, 577​ const QList<Choice> &choices,
563 qint32 defaultValue) 578​ qint32 defaultValue)
564 : ItemInt(_group, _key, reference, defaultValue), mChoices(choices) 579​ : ItemInt(_group, _key, reference, defaultValue), mChoices(choices)
565{ 580​{
566} 581​}
567 582​
568void KCoreConfigSkeleton::ItemEnum::readConfig(KConfig *config) 583​void KCoreConfigSkeleton::ItemEnum::readConfig(KConfig *config)
569{ 584​{
570 KConfigGroup cg(config, mGroup); 585​ KConfigGroup cg = configGroup(config);
571 if (!cg.hasKey(mKey)) { 586​ if (!cg.hasKey(mKey)) {
572 mReference = mDefault; 587​ mReference = mDefault;
573 } else { 588​ } else {
574 int i = 0; 589​ int i = 0;
575 mReference = -1; 590​ mReference = -1;
576 QString tmp = cg.readEntry(mKey, QString()).toLower(); 591​ QString tmp = cg.readEntry(mKey, QString()).toLower();
577 for (QList<Choice>::ConstIterator it = mChoices.constBegin(); 592​ for (QList<Choice>::ConstIterator it = mChoices.constBegin();
578 it != mChoices.constEnd(); ++it, ++i) { 593​ it != mChoices.constEnd(); ++it, ++i) {
Show All 9 Lines
588 mLoadedValue = mReference; 603​ mLoadedValue = mReference;
589 604​
590 readImmutability(cg); 605​ readImmutability(cg);
591} 606​}
592 607​
593void KCoreConfigSkeleton::ItemEnum::writeConfig(KConfig *config) 608​void KCoreConfigSkeleton::ItemEnum::writeConfig(KConfig *config)
594{ 609​{
595 if (mReference != mLoadedValue) { // WABA: Is this test needed? 610​ if (mReference != mLoadedValue) { // WABA: Is this test needed?
596 KConfigGroup cg(config, mGroup); 611​ KConfigGroup cg = configGroup(config);
597 if ((mDefault == mReference) && !cg.hasDefault(mKey)) { 612​ if ((mDefault == mReference) && !cg.hasDefault(mKey)) {
598 cg.revertToDefault(mKey, writeFlags()); 613​ cg.revertToDefault(mKey, writeFlags());
599 } else if ((mReference >= 0) && (mReference < mChoices.count())) { 614​ } else if ((mReference >= 0) && (mReference < mChoices.count())) {
600 cg.writeEntry(mKey, mChoices[mReference].name, writeFlags()); 615​ cg.writeEntry(mKey, mChoices[mReference].name, writeFlags());
601 } else { 616​ } else {
602 cg.writeEntry(mKey, mReference, writeFlags()); 617​ cg.writeEntry(mKey, mReference, writeFlags());
603 } 618​ }
604 mLoadedValue = mReference; 619​ mLoadedValue = mReference;
Show All 15 Lines633KCoreConfigSkeleton::ItemUInt::ItemUInt(const QString &_group, const QString &_key,
620 quint32 defaultValue) 635​ quint32 defaultValue)
621 : KConfigSkeletonGenericItem<quint32>(_group, _key, reference, defaultValue) 636​ : KConfigSkeletonGenericItem<quint32>(_group, _key, reference, defaultValue)
622 , mHasMin(false), mHasMax(false) 637​ , mHasMin(false), mHasMax(false)
623{ 638​{
624} 639​}
625 640​
626void KCoreConfigSkeleton::ItemUInt::readConfig(KConfig *config) 641​void KCoreConfigSkeleton::ItemUInt::readConfig(KConfig *config)
627{ 642​{
628 KConfigGroup cg(config, mGroup); 643​ KConfigGroup cg = configGroup(config);
629 mReference = cg.readEntry(mKey, mDefault); 644​ mReference = cg.readEntry(mKey, mDefault);
630 if (mHasMin) { 645​ if (mHasMin) {
631 mReference = qMax(mReference, mMin); 646​ mReference = qMax(mReference, mMin);
632 } 647​ }
633 if (mHasMax) { 648​ if (mHasMax) {
634 mReference = qMin(mReference, mMax); 649​ mReference = qMin(mReference, mMax);
635 } 650​ }
636 mLoadedValue = mReference; 651​ mLoadedValue = mReference;
▲ Show 20 Lines • Show All 48 Lines • ▼ Show 20 Line(s)699KCoreConfigSkeleton::ItemULongLong::ItemULongLong(const QString &_group, const QString &_key,
685 quint64 &reference, quint64 defaultValue) 700​ quint64 &reference, quint64 defaultValue)
686 : KConfigSkeletonGenericItem<quint64>(_group, _key, reference, defaultValue) 701​ : KConfigSkeletonGenericItem<quint64>(_group, _key, reference, defaultValue)
687 , mHasMin(false), mHasMax(false) 702​ , mHasMin(false), mHasMax(false)
688{ 703​{
689} 704​}
690 705​
691void KCoreConfigSkeleton::ItemULongLong::readConfig(KConfig *config) 706​void KCoreConfigSkeleton::ItemULongLong::readConfig(KConfig *config)
692{ 707​{
693 KConfigGroup cg(config, mGroup); 708​ KConfigGroup cg = configGroup(config);
694 mReference = cg.readEntry(mKey, mDefault); 709​ mReference = cg.readEntry(mKey, mDefault);
695 if (mHasMin) { 710​ if (mHasMin) {
696 mReference = qMax(mReference, mMin); 711​ mReference = qMax(mReference, mMin);
697 } 712​ }
698 if (mHasMax) { 713​ if (mHasMax) {
699 mReference = qMin(mReference, mMax); 714​ mReference = qMin(mReference, mMax);
700 } 715​ }
701 mLoadedValue = mReference; 716​ mLoadedValue = mReference;
▲ Show 20 Lines • Show All 48 Lines • ▼ Show 20 Line(s)764KCoreConfigSkeleton::ItemDouble::ItemDouble(const QString &_group, const QString &_key,
750 double &reference, double defaultValue) 765​ double &reference, double defaultValue)
751 : KConfigSkeletonGenericItem<double>(_group, _key, reference, defaultValue) 766​ : KConfigSkeletonGenericItem<double>(_group, _key, reference, defaultValue)
752 , mHasMin(false), mHasMax(false) 767​ , mHasMin(false), mHasMax(false)
753{ 768​{
754} 769​}
755 770​
756void KCoreConfigSkeleton::ItemDouble::readConfig(KConfig *config) 771​void KCoreConfigSkeleton::ItemDouble::readConfig(KConfig *config)
757{ 772​{
758 KConfigGroup cg(config, mGroup); 773​ KConfigGroup cg = configGroup(config);
759 mReference = cg.readEntry(mKey, mDefault); 774​ mReference = cg.readEntry(mKey, mDefault);
760 if (mHasMin) { 775​ if (mHasMin) {
761 mReference = qMax(mReference, mMin); 776​ mReference = qMax(mReference, mMin);
762 } 777​ }
763 if (mHasMax) { 778​ if (mHasMax) {
764 mReference = qMin(mReference, mMax); 779​ mReference = qMin(mReference, mMax);
765 } 780​ }
766 mLoadedValue = mReference; 781​ mLoadedValue = mReference;
▲ Show 20 Lines • Show All 48 Lines • ▼ Show 20 Line(s)829KCoreConfigSkeleton::ItemRect::ItemRect(const QString &_group, const QString &_key,
815 QRect &reference, 830​ QRect &reference,
816 const QRect &defaultValue) 831​ const QRect &defaultValue)
817 : KConfigSkeletonGenericItem<QRect>(_group, _key, reference, defaultValue) 832​ : KConfigSkeletonGenericItem<QRect>(_group, _key, reference, defaultValue)
818{ 833​{
819} 834​}
820 835​
821void KCoreConfigSkeleton::ItemRect::readConfig(KConfig *config) 836​void KCoreConfigSkeleton::ItemRect::readConfig(KConfig *config)
822{ 837​{
823 KConfigGroup cg(config, mGroup); 838​ KConfigGroup cg = configGroup(config);
824 mReference = cg.readEntry(mKey, mDefault); 839​ mReference = cg.readEntry(mKey, mDefault);
825 mLoadedValue = mReference; 840​ mLoadedValue = mReference;
826 841​
827 readImmutability(cg); 842​ readImmutability(cg);
828} 843​}
829 844​
830void KCoreConfigSkeleton::ItemRect::setProperty(const QVariant &p) 845​void KCoreConfigSkeleton::ItemRect::setProperty(const QVariant &p)
831{ 846​{
Show All 14 Lines860KCoreConfigSkeleton::ItemPoint::ItemPoint(const QString &_group, const QString &_key,
846 QPoint &reference, 861​ QPoint &reference,
847 const QPoint &defaultValue) 862​ const QPoint &defaultValue)
848 : KConfigSkeletonGenericItem<QPoint>(_group, _key, reference, defaultValue) 863​ : KConfigSkeletonGenericItem<QPoint>(_group, _key, reference, defaultValue)
849{ 864​{
850} 865​}
851 866​
852void KCoreConfigSkeleton::ItemPoint::readConfig(KConfig *config) 867​void KCoreConfigSkeleton::ItemPoint::readConfig(KConfig *config)
853{ 868​{
854 KConfigGroup cg(config, mGroup); 869​ KConfigGroup cg = configGroup(config);
855 mReference = cg.readEntry(mKey, mDefault); 870​ mReference = cg.readEntry(mKey, mDefault);
856 mLoadedValue = mReference; 871​ mLoadedValue = mReference;
857 872​
858 readImmutability(cg); 873​ readImmutability(cg);
859} 874​}
860 875​
861void KCoreConfigSkeleton::ItemPoint::setProperty(const QVariant &p) 876​void KCoreConfigSkeleton::ItemPoint::setProperty(const QVariant &p)
862{ 877​{
Show All 14 Lines891KCoreConfigSkeleton::ItemSize::ItemSize(const QString &_group, const QString &_key,
877 QSize &reference, 892​ QSize &reference,
878 const QSize &defaultValue) 893​ const QSize &defaultValue)
879 : KConfigSkeletonGenericItem<QSize>(_group, _key, reference, defaultValue) 894​ : KConfigSkeletonGenericItem<QSize>(_group, _key, reference, defaultValue)
880{ 895​{
881} 896​}
882 897​
883void KCoreConfigSkeleton::ItemSize::readConfig(KConfig *config) 898​void KCoreConfigSkeleton::ItemSize::readConfig(KConfig *config)
884{ 899​{
885 KConfigGroup cg(config, mGroup); 900​ KConfigGroup cg = configGroup(config);
886 mReference = cg.readEntry(mKey, mDefault); 901​ mReference = cg.readEntry(mKey, mDefault);
887 mLoadedValue = mReference; 902​ mLoadedValue = mReference;
888 903​
889 readImmutability(cg); 904​ readImmutability(cg);
890} 905​}
891 906​
892void KCoreConfigSkeleton::ItemSize::setProperty(const QVariant &p) 907​void KCoreConfigSkeleton::ItemSize::setProperty(const QVariant &p)
893{ 908​{
Show All 14 Lines922KCoreConfigSkeleton::ItemDateTime::ItemDateTime(const QString &_group, const QString &_key,
908 QDateTime &reference, 923​ QDateTime &reference,
909 const QDateTime &defaultValue) 924​ const QDateTime &defaultValue)
910 : KConfigSkeletonGenericItem<QDateTime>(_group, _key, reference, defaultValue) 925​ : KConfigSkeletonGenericItem<QDateTime>(_group, _key, reference, defaultValue)
911{ 926​{
912} 927​}
913 928​
914void KCoreConfigSkeleton::ItemDateTime::readConfig(KConfig *config) 929​void KCoreConfigSkeleton::ItemDateTime::readConfig(KConfig *config)
915{ 930​{
916 KConfigGroup cg(config, mGroup); 931​ KConfigGroup cg = configGroup(config);
917 mReference = cg.readEntry(mKey, mDefault); 932​ mReference = cg.readEntry(mKey, mDefault);
918 mLoadedValue = mReference; 933​ mLoadedValue = mReference;
919 934​
920 readImmutability(cg); 935​ readImmutability(cg);
921} 936​}
922 937​
923void KCoreConfigSkeleton::ItemDateTime::setProperty(const QVariant &p) 938​void KCoreConfigSkeleton::ItemDateTime::setProperty(const QVariant &p)
924{ 939​{
Show All 14 Lines953KCoreConfigSkeleton::ItemStringList::ItemStringList(const QString &_group, const QString &_key,
939 QStringList &reference, 954​ QStringList &reference,
940 const QStringList &defaultValue) 955​ const QStringList &defaultValue)
941 : KConfigSkeletonGenericItem<QStringList>(_group, _key, reference, defaultValue) 956​ : KConfigSkeletonGenericItem<QStringList>(_group, _key, reference, defaultValue)
942{ 957​{
943} 958​}
944 959​
945void KCoreConfigSkeleton::ItemStringList::readConfig(KConfig *config) 960​void KCoreConfigSkeleton::ItemStringList::readConfig(KConfig *config)
946{ 961​{
947 KConfigGroup cg(config, mGroup); 962​ KConfigGroup cg = configGroup(config);
948 if (!cg.hasKey(mKey)) { 963​ if (!cg.hasKey(mKey)) {
949 mReference = mDefault; 964​ mReference = mDefault;
950 } else { 965​ } else {
951 mReference = cg.readEntry(mKey, mDefault); 966​ mReference = cg.readEntry(mKey, mDefault);
952 } 967​ }
953 mLoadedValue = mReference; 968​ mLoadedValue = mReference;
954 969​
955 readImmutability(cg); 970​ readImmutability(cg);
Show All 18 Lines988KCoreConfigSkeleton::ItemPathList::ItemPathList(const QString &_group, const QString &_key,
974 QStringList &reference, 989​ QStringList &reference,
975 const QStringList &defaultValue) 990​ const QStringList &defaultValue)
976 : ItemStringList(_group, _key, reference, defaultValue) 991​ : ItemStringList(_group, _key, reference, defaultValue)
977{ 992​{
978} 993​}
979 994​
980void KCoreConfigSkeleton::ItemPathList::readConfig(KConfig *config) 995​void KCoreConfigSkeleton::ItemPathList::readConfig(KConfig *config)
981{ 996​{
982 KConfigGroup cg(config, mGroup); 997​ KConfigGroup cg = configGroup(config);
983 if (!cg.hasKey(mKey)) { 998​ if (!cg.hasKey(mKey)) {
984 mReference = mDefault; 999​ mReference = mDefault;
985 } else { 1000​ } else {
986 mReference = cg.readPathEntry(mKey, QStringList()); 1001​ mReference = cg.readPathEntry(mKey, QStringList());
987 } 1002​ }
988 mLoadedValue = mReference; 1003​ mLoadedValue = mReference;
989 1004​
990 readImmutability(cg); 1005​ readImmutability(cg);
991} 1006​}
992 1007​
993void KCoreConfigSkeleton::ItemPathList::writeConfig(KConfig *config) 1008​void KCoreConfigSkeleton::ItemPathList::writeConfig(KConfig *config)
994{ 1009​{
995 if (mReference != mLoadedValue) { // WABA: Is this test needed? 1010​ if (mReference != mLoadedValue) { // WABA: Is this test needed?
996 KConfigGroup cg(config, mGroup); 1011​ KConfigGroup cg = configGroup(config);
997 if ((mDefault == mReference) && !cg.hasDefault(mKey)) { 1012​ if ((mDefault == mReference) && !cg.hasDefault(mKey)) {
998 cg.revertToDefault(mKey, writeFlags()); 1013​ cg.revertToDefault(mKey, writeFlags());
999 } else { 1014​ } else {
1000 QStringList sl = mReference; 1015​ QStringList sl = mReference;
1001 cg.writePathEntry(mKey, sl, writeFlags()); 1016​ cg.writePathEntry(mKey, sl, writeFlags());
1002 } 1017​ }
1003 mLoadedValue = mReference; 1018​ mLoadedValue = mReference;
1004 } 1019​ }
1005} 1020​}
1006 1021​
1007KCoreConfigSkeleton::ItemUrlList::ItemUrlList(const QString &_group, const QString &_key, 1022​KCoreConfigSkeleton::ItemUrlList::ItemUrlList(const QString &_group, const QString &_key,
1008 QList<QUrl> &reference, 1023​ QList<QUrl> &reference,
1009 const QList<QUrl> &defaultValue) 1024​ const QList<QUrl> &defaultValue)
1010 : KConfigSkeletonGenericItem<QList<QUrl> >(_group, _key, reference, defaultValue) 1025​ : KConfigSkeletonGenericItem<QList<QUrl> >(_group, _key, reference, defaultValue)
1011{ 1026​{
1012} 1027​}
1013 1028​
1014void KCoreConfigSkeleton::ItemUrlList::readConfig(KConfig *config) 1029​void KCoreConfigSkeleton::ItemUrlList::readConfig(KConfig *config)
1015{ 1030​{
1016 KConfigGroup cg(config, mGroup); 1031​ KConfigGroup cg = configGroup(config);
1017 if (!cg.hasKey(mKey)) { 1032​ if (!cg.hasKey(mKey)) {
1018 mReference = mDefault; 1033​ mReference = mDefault;
1019 } else { 1034​ } else {
1020 QStringList strList; 1035​ QStringList strList;
1021 for (const QUrl &url : qAsConst(mDefault)) { 1036​ for (const QUrl &url : qAsConst(mDefault)) {
1022 strList.append(url.toString()); 1037​ strList.append(url.toString());
1023 } 1038​ }
1024 mReference.clear(); 1039​ mReference.clear();
1025 const QStringList readList = cg.readEntry<QStringList>(mKey, strList); 1040​ const QStringList readList = cg.readEntry<QStringList>(mKey, strList);
1026 for (const QString &str : readList) { 1041​ for (const QString &str : readList) {
1027 mReference.append(QUrl(str)); 1042​ mReference.append(QUrl(str));
1028 } 1043​ }
1029 } 1044​ }
1030 mLoadedValue = mReference; 1045​ mLoadedValue = mReference;
1031 1046​
1032 readImmutability(cg); 1047​ readImmutability(cg);
1033} 1048​}
1034 1049​
1035void KCoreConfigSkeleton::ItemUrlList::writeConfig(KConfig *config) 1050​void KCoreConfigSkeleton::ItemUrlList::writeConfig(KConfig *config)
1036{ 1051​{
1037 if (mReference != mLoadedValue) { // WABA: Is this test needed? 1052​ if (mReference != mLoadedValue) { // WABA: Is this test needed?
1038 KConfigGroup cg(config, mGroup); 1053​ KConfigGroup cg = configGroup(config);
1039 if ((mDefault == mReference) && !cg.hasDefault(mKey)) { 1054​ if ((mDefault == mReference) && !cg.hasDefault(mKey)) {
1040 cg.revertToDefault(mKey, writeFlags()); 1055​ cg.revertToDefault(mKey, writeFlags());
1041 } else { 1056​ } else {
1042 QStringList strList; 1057​ QStringList strList;
1043 for (const QUrl &url : qAsConst(mReference)) { 1058​ for (const QUrl &url : qAsConst(mReference)) {
1044 strList.append(url.toString()); 1059​ strList.append(url.toString());
1045 } 1060​ }
1046 cg.writeEntry<QStringList>(mKey, strList, writeFlags()); 1061​ cg.writeEntry<QStringList>(mKey, strList, writeFlags());
Show All 21 Lines1082KCoreConfigSkeleton::ItemIntList::ItemIntList(const QString &_group, const QString &_key,
1068 QList<int> &reference, 1083​ QList<int> &reference,
1069 const QList<int> &defaultValue) 1084​ const QList<int> &defaultValue)
1070 : KConfigSkeletonGenericItem<QList<int> >(_group, _key, reference, defaultValue) 1085​ : KConfigSkeletonGenericItem<QList<int> >(_group, _key, reference, defaultValue)
1071{ 1086​{
1072} 1087​}
1073 1088​
1074void KCoreConfigSkeleton::ItemIntList::readConfig(KConfig *config) 1089​void KCoreConfigSkeleton::ItemIntList::readConfig(KConfig *config)
1075{ 1090​{
1076 KConfigGroup cg(config, mGroup); 1091​ KConfigGroup cg = configGroup(config);
1077 if (!cg.hasKey(mKey)) { 1092​ if (!cg.hasKey(mKey)) {
1078 mReference = mDefault; 1093​ mReference = mDefault;
1079 } else { 1094​ } else {
1080 mReference = cg.readEntry(mKey, mDefault); 1095​ mReference = cg.readEntry(mKey, mDefault);
1081 } 1096​ }
1082 mLoadedValue = mReference; 1097​ mLoadedValue = mReference;
1083 1098​
1084 readImmutability(cg); 1099​ readImmutability(cg);
▲ Show 20 Lines • Show All 452 Lines • ▼ Show 20 Line(s)1551{
1537 return mItem->property(); 1552​ return mItem->property();
1538} 1553​}
1539 1554​
1540void KConfigCompilerSignallingItem::readConfig(KConfig* c) 1555​void KConfigCompilerSignallingItem::readConfig(KConfig* c)
1541{ 1556​{
1542 QVariant oldValue = mItem->property(); 1557​ QVariant oldValue = mItem->property();
1543 mItem->readConfig(c); 1558​ mItem->readConfig(c);
1544 //readConfig() changes mIsImmutable, update it here as well 1559​ //readConfig() changes mIsImmutable, update it here as well
1545 KConfigGroup cg(c, mGroup ); 1560​ KConfigGroup cg = configGroup(c);
1546 readImmutability(cg); 1561​ readImmutability(cg);
1547 if (!mItem->isEqual(oldValue)) { 1562​ if (!mItem->isEqual(oldValue)) {
1548 invokeNotifyFunction(); 1563​ invokeNotifyFunction();
1549 } 1564​ }
1550} 1565​}
1551 1566​
1552void KConfigCompilerSignallingItem::readDefault(KConfig* c) 1567​void KConfigCompilerSignallingItem::readDefault(KConfig* c)
1553{ 1568​{
1554 mItem->readDefault(c); 1569​ mItem->readDefault(c);
1555 //readDefault() changes mIsImmutable, update it here as well 1570​ //readDefault() changes mIsImmutable, update it here as well
1556 KConfigGroup cg(c, mGroup ); 1571​ KConfigGroup cg = configGroup(c);
1557 readImmutability(cg); 1572​ readImmutability(cg);
1558} 1573​}
1559 1574​
1560void KConfigCompilerSignallingItem::writeConfig(KConfig* c) 1575​void KConfigCompilerSignallingItem::writeConfig(KConfig* c)
1561{ 1576​{
1562 mItem->writeConfig(c); 1577​ mItem->writeConfig(c);
1563} 1578​}
1564 1579​
Show All 27 Lines
1592{ 1607​{
1593 mItem->setWriteFlags(flags); 1608​ mItem->setWriteFlags(flags);
1594} 1609​}
1595 1610​
1596KConfigBase::WriteConfigFlags KConfigCompilerSignallingItem::writeFlags() const 1611​KConfigBase::WriteConfigFlags KConfigCompilerSignallingItem::writeFlags() const
1597{ 1612​{
1598 return mItem->writeFlags(); 1613​ return mItem->writeFlags();
1599} 1614​}
1615​
1616​void KConfigCompilerSignallingItem::setGroup(const KConfigGroup& cg)
ervinUnsubmitted
Done

Space before & not after

ervin: Space before & not after
1617​{
1618​ mItem->setGroup(cg);
1619​}
1620​
1621​KConfigGroup KConfigCompilerSignallingItem::configGroup(KConfig* config) const
ervinUnsubmitted
Done

Space before * not after

ervin: Space before * not after
1622​{
1623​ return mItem->configGroup(config);
1624​}