File indexing completed on 2024-05-12 15:34:12

 /*
     This file is part of KDE.
 
     SPDX-FileCopyrightText: 2001, 2002, 2003 Cornelius Schumacher <schumacher@kde.org>
     SPDX-FileCopyrightText: 2003 Waldo Bastian <bastian@kde.org>
 
     SPDX-License-Identifier: LGPL-2.0-or-later
 */
 
 #ifndef KCORECONFIGSKELETON_H
 #define KCORECONFIGSKELETON_H
 
 #include <kconfigcore_export.h>
 
 #include <kconfiggroup.h>
 #include <ksharedconfig.h>
 
 #include <QDate>
 #include <QHash>
 #include <QRect>
 #include <QStringList>
 #include <QUrl>
 #include <QVariant>
 
 class KCoreConfigSkeletonPrivate;
 
 class KConfigSkeletonItemPrivate;
 /**
  * \class KConfigSkeletonItem kcoreconfigskeleton.h <KCoreConfigSkeleton>
  *
  * @short Class for storing a preferences setting
  * @author Cornelius Schumacher
  * @see KCoreConfigSkeleton
  *
  * This class represents one preferences setting as used by @ref KCoreConfigSkeleton.
  * Subclasses of KConfigSkeletonItem implement storage functions for a certain type of
  * setting. Normally you don't have to use this class directly. Use the special
  * addItem() functions of KCoreConfigSkeleton instead. If you subclass this class you will
  * have to register instances with the function KCoreConfigSkeleton::addItem().
  */
 class KCONFIGCORE_EXPORT KConfigSkeletonItem
 {
     Q_DECLARE_PRIVATE(KConfigSkeletonItem)
 public:
     typedef QList<KConfigSkeletonItem *> List;
     typedef QHash<QString, KConfigSkeletonItem *> Dict;
     typedef QHash<QString, KConfigSkeletonItem *>::Iterator DictIterator;
 
     /**
      * Constructor.
      *
      * @param _group Config file group.
      * @param _key Config file key.
      */
     KConfigSkeletonItem(const QString &_group, const QString &_key);
 
     /**
      * Destructor.
      */
     virtual ~KConfigSkeletonItem();
 
     /**
      * Set config file group.
      */
     void setGroup(const QString &_group);
 
     /**
      * Return name of config file group.
      */
     QString group() const;
 
     /**
      * Set config file group but giving the KConfigGroup.
      * Allow the item to be in nested groups.
      * @since 5.68
      */
     void setGroup(const KConfigGroup &cg);
 
     /**
      * Return a KConfigGroup, the one provided by setGroup(const KConfigGroup&) if it's valid,
      * or make one from @p config and item's group.
      * @see setGroup(const QString &_group)
      * @see setGroup(KConfigGroup cg)
      * @since 5.68
      */
     KConfigGroup configGroup(KConfig *config) const;
 
     /**
      * Set config file key.
      */
     void setKey(const QString &_key);
 
     /**
      * Return config file key.
      */
     QString key() const;
 
     /**
      * Set internal name of entry.
      */
     void setName(const QString &_name);
 
     /**
      * Return internal name of entry.
      */
     QString name() const;
 
     /**
      * Set label providing a translated one-line description of the item.
      */
     void setLabel(const QString &l);
 
     /**
      * Return the label of the item.
      * @see setLabel()
      */
     QString label() const;
 
     /**
      * Set ToolTip description of item.
      * @since 4.2
      */
     void setToolTip(const QString &t);
 
     /**
      * Return ToolTip description of item.
      * @see setToolTip()
      * @since 4.2
      */
     QString toolTip() const;
 
     /**
      * Set WhatsThis description of item.
      */
     void setWhatsThis(const QString &w);
 
     /**
      * Return WhatsThis description of item.
      * @see setWhatsThis()
      */
     QString whatsThis() const;
 
     /**
      * The write flags to be used when writing configuration.
      * @since 5.58
      */
     void setWriteFlags(KConfigBase::WriteConfigFlags flags);
 
     /**
      * Return write flags to be used when writing configuration.
      * They should be passed to every call of KConfigGroup::writeEntry() and KConfigGroup::revertToDefault().
      * @since 5.58
      */
     KConfigBase::WriteConfigFlags writeFlags() const;
 
     /**
      * This function is called by @ref KCoreConfigSkeleton to read the value for this setting
      * from a config file.
      */
     virtual void readConfig(KConfig *) = 0;
 
     /**
      * This function is called by @ref KCoreConfigSkeleton to write the value of this setting
      * to a config file.
      * Make sure to pass writeFlags() to every call of KConfigGroup::writeEntry() and KConfigGroup::revertToDefault().
      */
     virtual void writeConfig(KConfig *) = 0;
 
     /**
      * Read global default value.
      */
     virtual void readDefault(KConfig *) = 0;
 
     /**
      * Set item to @p p
      */
     virtual void setProperty(const QVariant &p) = 0;
 
     /**
      * Check whether the item is equal to @p p.
      *
      * Use this function to compare items that use custom types,
      * because QVariant::operator== will not work for those.
      *
      * @param p QVariant to compare to
      * @return @c true if the item is equal to @p p, @c false otherwise
      */
     virtual bool isEqual(const QVariant &p) const = 0;
 
     /**
      * Return item as property
      */
     virtual QVariant property() const = 0;
 
     /**
      * Return minimum value of item or invalid if not specified
      */
     virtual QVariant minValue() const;
 
     /**
      * Return maximum value of item or invalid if not specified
      */
     virtual QVariant maxValue() const;
 
     /**
      * Sets the current value to the default value.
      */
     virtual void setDefault() = 0;
 
     /**
      * Exchanges the current value with the default value
      * Used by KCoreConfigSkeleton::useDefaults(bool);
      */
     virtual void swapDefault() = 0;
 
     /**
      * Return if the entry can be modified.
      */
     bool isImmutable() const;
 
     /**
      * Indicates if the item is set to its default value.
      *
      * @since 5.64
      */
     bool isDefault() const;
 
     /**
      * Indicates if the item has a different value than the
      * previously loaded value.
      *
      * @since 5.64
      */
     bool isSaveNeeded() const;
 
     /**
      * Returns the default value
      * @since 5.74
      */
     QVariant getDefault() const;
 
 protected:
     KCONFIGCORE_NO_EXPORT explicit KConfigSkeletonItem(KConfigSkeletonItemPrivate &dd, const QString &_group, const QString &_key);
 
     /**
      * Sets mIsImmutable to @c true if mKey in config is immutable.
      * @param group KConfigGroup to check if mKey is immutable in
      */
     void readImmutability(const KConfigGroup &group);
 
     QString mGroup; ///< The group name for this item
     QString mKey; ///< The config key for this item
     QString mName; ///< The name of this item
 
     // HACK: Necessary to avoid introducing new virtuals in KConfigSkeletonItem
     // KF6: Use proper pure virtuals in KConfigSkeletonItem
     void setIsDefaultImpl(const std::function<bool()> &impl);
     void setIsSaveNeededImpl(const std::function<bool()> &impl);
     void setGetDefaultImpl(const std::function<QVariant()> &impl);
 
     KConfigSkeletonItemPrivate *const d_ptr;
 };
 
 class KPropertySkeletonItemPrivate;
 
 /**
  * \class KPropertySkeletonItem kcoreconfigskeleton.h <KCoreConfigSkeleton>
  *
  * @short Class for proxying a QObject property as a preferences setting
  * @author Kevin Ottens
  * @see KConfigSkeletonItem
  *
  * This class represents one preferences setting as used by @ref KCoreConfigSkeleton.
  * Unlike other @ref KConfigSkeletonItem subclasses, this one won't store the preference
  * in KConfig but will use a QObject property as storage.
  * You will have to register instances of this class with the function KCoreConfigSkeleton::addItem().
  *
  * @since 5.65
  */
 class KCONFIGCORE_EXPORT KPropertySkeletonItem : public KConfigSkeletonItem
 {
     Q_DECLARE_PRIVATE(KPropertySkeletonItem)
 public:
     /**
      * Constructor
      *
      * @param object The QObject instance which we'll manage the property of
      * @param propertyName The name of the property in @p object which we'll manage
      * @param defaultValue The default value of the property
      */
     KPropertySkeletonItem(QObject *object, const QByteArray &propertyName, const QVariant &defaultValue);
 
     /** @copydoc KConfigSkeletonItem::property() */
     QVariant property() const override;
     /** @copydoc KConfigSkeletonItem::setProperty(const QVariant &) */
     void setProperty(const QVariant &p) override;
     /** @copydoc KConfigSkeletonItem::isEqual(const QVariant &) */
     bool isEqual(const QVariant &p) const override;
 
     /** @copydoc KConfigSkeletonItem::readConfig(KConfig *) */
     void readConfig(KConfig *) override;
     /** @copydoc KConfigSkeletonItem::writeConfig(KConfig *) */
     void writeConfig(KConfig *) override;
 
     /** @copydoc KConfigSkeletonItem::readDefault(KConfig *) */
     void readDefault(KConfig *) override;
     /** @copydoc KConfigSkeletonItem::setDefault() */
     void setDefault() override;
     /** @copydoc KConfigSkeletonItem::swapDefault() */
     void swapDefault() override;
 
     /**
      * Set a notify function, it will be invoked when the value of the property changes.
      * @since 5.68
      */
     void setNotifyFunction(const std::function<void()> &impl);
 };
 
 /**
  * \class KConfigSkeletonGenericItem kcoreconfigskeleton.h <KCoreConfigSkeleton>
  *
  * @short Base class for storing a preferences setting of type @p T.
  */
 template<typename T>
 class KConfigSkeletonGenericItem : public KConfigSkeletonItem
 {
 public:
     /**
      * @copydoc KConfigSkeletonItem(const QString&, const QString&)
      * @param reference The initial value to hold in the item
      * @param defaultValue The default value for the item
      */
     KConfigSkeletonGenericItem(const QString &_group, const QString &_key, T &reference, T defaultValue)
         : KConfigSkeletonItem(_group, _key)
         , mReference(reference)
         , mDefault(defaultValue)
         , mLoadedValue(defaultValue)
     {
         setIsDefaultImpl([this] {
             return mReference == mDefault;
         });
         setIsSaveNeededImpl([this] {
             return mReference != mLoadedValue;
         });
         setGetDefaultImpl([this] {
             return QVariant::fromValue(mDefault);
         });
     }
 
     /**
      * Set value of this KConfigSkeletonItem.
      */
     void setValue(const T &v)
     {
         mReference = v;
     }
 
     /**
      * Return value of this KConfigSkeletonItem.
      */
     T &value()
     {
         return mReference;
     }
 
     /**
      * Return const value of this KConfigSkeletonItem.
      */
     const T &value() const
     {
         return mReference;
     }
 
     /**
      * Set default value for this item.
      */
     virtual void setDefaultValue(const T &v)
     {
         mDefault = v;
     }
 
     /**
      * Set the value for this item to the default value
      */
     void setDefault() override
     {
         mReference = mDefault;
     }
 
     /** @copydoc KConfigSkeletonItem::writeConfig(KConfig *) */
     void writeConfig(KConfig *config) override
     {
         if (mReference != mLoadedValue) { // Is this needed?
             KConfigGroup cg = configGroup(config);
             if ((mDefault == mReference) && !cg.hasDefault(mKey)) {
                 cg.revertToDefault(mKey, writeFlags());
             } else {
                 cg.writeEntry(mKey, mReference, writeFlags());
             }
             mLoadedValue = mReference;
         }
     }
 
     /** @copydoc KConfigSkeletonItem::readDefault(KConfig*) */
     void readDefault(KConfig *config) override
     {
         config->setReadDefaults(true);
         readConfig(config);
         config->setReadDefaults(false);
         mDefault = mReference;
     }
 
     /** @copydoc KConfigSkeletonItem::swapDefault() */
     void swapDefault() override
     {
         T tmp = mReference;
         mReference = mDefault;
         mDefault = tmp;
     }
 
 protected:
     T &mReference; ///< Stores the value for this item
     T mDefault; ///< The default value for this item
     T mLoadedValue;
 };
 
 /**
  * \class KConfigCompilerSignallingItem kcoreconfigskeleton.h <KCoreConfigSkeleton>
  *
  * @author Alex Richardson
  *
  * This class wraps a @ref KConfigSkeletonItem and invokes a function whenever the value changes.
  * That function must take one quint64 parameter. Whenever the property value of the wrapped KConfigSkeletonItem
  * changes this function will be invoked with the stored user data passed in the constructor.
  * It does not call a function with the new value since this class is designed solely for the \ref kconfig_compiler generated
  * code and is therefore probably not suited for any other usecases.
  *
  * @see KConfigSkeletonItem
  */
 class KCONFIGCORE_EXPORT KConfigCompilerSignallingItem : public KConfigSkeletonItem
 {
 public:
     typedef void (QObject::*NotifyFunction)(quint64 arg);
     /**
      * Constructor.
      *
      * @param item the KConfigSkeletonItem to wrap
      * @param targetFunction the method to invoke whenever the value of @p item changes
      * @param object The object on which the method is invoked.
      * @param userData This data will be passed to @p targetFunction on every property change
      */
     KConfigCompilerSignallingItem(KConfigSkeletonItem *item, QObject *object, NotifyFunction targetFunction, quint64 userData);
     ~KConfigCompilerSignallingItem() override;
 
     void readConfig(KConfig *) override;
     void writeConfig(KConfig *) override;
     void readDefault(KConfig *) override;
     void setProperty(const QVariant &p) override;
     bool isEqual(const QVariant &p) const override;
     QVariant property() const override;
     QVariant minValue() const override;
     QVariant maxValue() const override;
     void setDefault() override;
     void swapDefault() override;
     // KF6 TODO - fix this
     // Ideally we would do this in an overload of KConfigSkeletonItem, but
     // given we can't, I've shadowed the method. This isn't pretty, but given
     // the docs say it should generally only be used from auto generated code,
     // should be fine.
     void setWriteFlags(KConfigBase::WriteConfigFlags flags);
     KConfigBase::WriteConfigFlags writeFlags() const;
     void setGroup(const KConfigGroup &cg);
     KConfigGroup configGroup(KConfig *config) const;
     // END TODO
 
 private:
     inline void invokeNotifyFunction()
     {
         // call the pointer to member function using the strange ->* operator
         (mObject->*mTargetFunction)(mUserData);
     }
 
 private:
     QScopedPointer<KConfigSkeletonItem> mItem;
     NotifyFunction mTargetFunction;
     QObject *mObject;
     quint64 mUserData;
 };
 
 /**
  * \class KCoreConfigSkeleton kcoreconfigskeleton.h <KCoreConfigSkeleton>
  *
  * @short Class for handling preferences settings for an application.
  * @author Cornelius Schumacher
  *
  * This class provides an interface to preferences settings. Preferences items
  * can be registered by the addItem() function corresponding to the data type of
  * the setting. KCoreConfigSkeleton then handles reading and writing of config files and
  * setting of default values.
  *
  * Normally you will subclass KCoreConfigSkeleton, add data members for the preferences
  * settings and register the members in the constructor of the subclass.
  *
  * Example:
  * \code
  * class MyPrefs : public KCoreConfigSkeleton
  * {
  *   public:
  *     MyPrefs()
  *     {
  *       setCurrentGroup("MyGroup");
  *       addItemBool("MySetting1", mMyBool, false);
  *       addItemPoint("MySetting2", mMyPoint, QPoint(100, 200));
  *
  *       setCurrentGroup("MyOtherGroup");
  *       addItemDouble("MySetting3", mMyDouble, 3.14);
  *     }
  *
  *     bool mMyBool;
  *     QPoint mMyPoint;
  *     double mMyDouble;
  * }
  * \endcode
  *
  * It might be convenient in many cases to make this subclass of KCoreConfigSkeleton a
  * singleton for global access from all over the application without passing
  * references to the KCoreConfigSkeleton object around.
  *
  * You can write the data to the configuration file by calling @ref save()
  * and read the data from the configuration file by calling @ref readConfig().
  * If you want to watch for config changes, use @ref configChanged() signal.
  *
  * If you have items, which are not covered by the existing addItem() functions
  * you can add customized code for reading, writing and default setting by
  * implementing the functions @ref usrUseDefaults(), @ref usrRead() and
  * @ref usrSave().
  *
  * Internally preferences settings are stored in instances of subclasses of
  * @ref KConfigSkeletonItem. You can also add KConfigSkeletonItem subclasses
  * for your own types and call the generic @ref addItem() to register them.
  *
  * In many cases you don't have to write the specific KCoreConfigSkeleton
  * subclasses yourself, but you can use \ref kconfig_compiler to automatically
  * generate the C++ code from an XML description of the configuration options.
  *
  * Use KConfigSkeleton if you need GUI types as well.
  *
  * @see KConfigSkeletonItem
  */
 class KCONFIGCORE_EXPORT KCoreConfigSkeleton : public QObject
 {
     Q_OBJECT
 public:
     /**
      * Class for handling a string preferences item.
      */
     class KCONFIGCORE_EXPORT ItemString : public KConfigSkeletonGenericItem<QString>
     {
     public:
         /** The type of string that is held in this item */
         enum Type {
             Normal, ///< A normal string
             Password, ///< A password string
             Path, ///< A path to a file or directory
         };
 
         /**
          * @copydoc KConfigSkeletonGenericItem::KConfigSkeletonGenericItem
          * @param type The type of string held by the item
          */
         ItemString(const QString &_group,
                    const QString &_key,
                    QString &reference,
                    const QString &defaultValue = QLatin1String(""), // NOT QString() !!
                    Type type = Normal);
 
         /** @copydoc KConfigSkeletonItem::writeConfig(KConfig*) */
         void writeConfig(KConfig *config) override;
 
         /** @copydoc KConfigSkeletonItem::readConfig(KConfig*) */
         void readConfig(KConfig *config) override;
 
         /** @copydoc KConfigSkeletonItem::setProperty(const QVariant&) */
         void setProperty(const QVariant &p) override;
 
         /** @copydoc KConfigSkeletonItem::isEqual(const QVariant &) const */
         bool isEqual(const QVariant &p) const override;
 
         /** @copydoc KConfigSkeletonItem::property() const */
         QVariant property() const override;
 
     private:
         Type mType;
     };
 
     /**
      * Class for handling a password preferences item.
      */
     class KCONFIGCORE_EXPORT ItemPassword : public ItemString
     {
     public:
         /** @copydoc KConfigSkeletonGenericItem::KConfigSkeletonGenericItem */
         ItemPassword(const QString &_group, const QString &_key, QString &reference,
                      const QString &defaultValue = QLatin1String("")); // NOT QString() !!
     };
 
     /**
      * Class for handling a path preferences item.
      */
     class KCONFIGCORE_EXPORT ItemPath : public ItemString
     {
     public:
         /** @copydoc KConfigSkeletonGenericItem::KConfigSkeletonGenericItem */
         ItemPath(const QString &_group, const QString &_key, QString &reference, const QString &defaultValue = QString());
     };
 
     /**
      * Class for handling a url preferences item.
      */
     class KCONFIGCORE_EXPORT ItemUrl : public KConfigSkeletonGenericItem<QUrl>
     {
     public:
         /** @copydoc KConfigSkeletonGenericItem::KConfigSkeletonGenericItem */
         ItemUrl(const QString &_group, const QString &_key, QUrl &reference, const QUrl &defaultValue = QUrl());
 
         /** @copydoc KConfigSkeletonItem::writeConfig(KConfig*) */
         void writeConfig(KConfig *config) override;
 
         /** @copydoc KConfigSkeletonItem::readConfig(KConfig*) */
         void readConfig(KConfig *config) override;
 
         /** @copydoc KConfigSkeletonItem::setProperty(const QVariant&) */
         void setProperty(const QVariant &p) override;
 
         /** @copydoc KConfigSkeletonItem::isEqual(const QVariant &) const */
         bool isEqual(const QVariant &p) const override;
 
         /** @copydoc KConfigSkeletonItem::property() const */
         QVariant property() const override;
     };
 
     /**
      * Class for handling a QVariant preferences item.
      */
     class KCONFIGCORE_EXPORT ItemProperty : public KConfigSkeletonGenericItem<QVariant>
     {
     public:
         /** @copydoc KConfigSkeletonGenericItem::KConfigSkeletonGenericItem */
         ItemProperty(const QString &_group, const QString &_key, QVariant &reference, const QVariant &defaultValue = QVariant());
 
         void readConfig(KConfig *config) override;
         void setProperty(const QVariant &p) override;
 
         /** @copydoc KConfigSkeletonItem::isEqual(const QVariant &) const */
         bool isEqual(const QVariant &p) const override;
 
         /** @copydoc KConfigSkeletonItem::property() const */
         QVariant property() const override;
     };
 
     /**
      * Class for handling a bool preferences item.
      */
     class KCONFIGCORE_EXPORT ItemBool : public KConfigSkeletonGenericItem<bool>
     {
     public:
         /** @copydoc KConfigSkeletonGenericItem::KConfigSkeletonGenericItem */
         ItemBool(const QString &_group, const QString &_key, bool &reference, bool defaultValue = true);
 
         /** @copydoc KConfigSkeletonItem::readConfig(KConfig*) */
         void readConfig(KConfig *config) override;
 
         /** @copydoc KConfigSkeletonItem::setProperty(const QVariant&) */
         void setProperty(const QVariant &p) override;
 
         /** @copydoc KConfigSkeletonItem::isEqual(const QVariant &) const */
         bool isEqual(const QVariant &p) const override;
 
         /** @copydoc KConfigSkeletonItem::property() const */
         QVariant property() const override;
     };
 
     /**
      * Class for handling a 32-bit integer preferences item.
      */
     class KCONFIGCORE_EXPORT ItemInt : public KConfigSkeletonGenericItem<qint32>
     {
     public:
         /** @copydoc KConfigSkeletonGenericItem::KConfigSkeletonGenericItem */
         ItemInt(const QString &_group, const QString &_key, qint32 &reference, qint32 defaultValue = 0);
 
         /** @copydoc KConfigSkeletonItem::readConfig(KConfig*) */
         void readConfig(KConfig *config) override;
 
         /** @copydoc KConfigSkeletonItem::setProperty(const QVariant&) */
         void setProperty(const QVariant &p) override;
 
         /** @copydoc KConfigSkeletonItem::isEqual(const QVariant &) const */
         bool isEqual(const QVariant &p) const override;
 
         /** @copydoc KConfigSkeletonItem::property() */
         QVariant property() const override;
 
         /** Get the minimum value that is allowed to be stored in this item */
         QVariant minValue() const override;
 
         /** Get the maximum value this is allowed to be stored in this item */
         QVariant maxValue() const override;
 
         /**
          * Set the minimum value for the item.
          * @see minValue()
          */
         void setMinValue(qint32);
 
         /**
          * Set the maximum value for the item.
          * @see maxValue
          */
         void setMaxValue(qint32);
 
     private:
         bool mHasMin : 1;
         bool mHasMax : 1;
         qint32 mMin;
         qint32 mMax;
     };
 
     /**
      * Class for handling a 64-bit integer preferences item.
      */
     class KCONFIGCORE_EXPORT ItemLongLong : public KConfigSkeletonGenericItem<qint64>
     {
     public:
         /** @copydoc KConfigSkeletonGenericItem::KConfigSkeletonGenericItem */
         ItemLongLong(const QString &_group, const QString &_key, qint64 &reference, qint64 defaultValue = 0);
 
         /** @copydoc KConfigSkeletonItem::readConfig(KConfig*) */
         void readConfig(KConfig *config) override;
 
         /** @copydoc KConfigSkeletonItem::setProperty(const QVariant&) */
         void setProperty(const QVariant &p) override;
 
         /** @copydoc KConfigSkeletonItem::isEqual(const QVariant &) const */
         bool isEqual(const QVariant &p) const override;
 
         /** @copydoc KConfigSkeletonItem::property() */
         QVariant property() const override;
 
         /** @copydoc ItemInt::minValue() */
         QVariant minValue() const override;
 
         /** @copydoc ItemInt::maxValue() */
         QVariant maxValue() const override;
 
         /** @copydoc ItemInt::setMinValue(qint32) */
         void setMinValue(qint64);
 
         /** @copydoc ItemInt::setMaxValue(qint32) */
         void setMaxValue(qint64);
 
     private:
         bool mHasMin : 1;
         bool mHasMax : 1;
         qint64 mMin;
         qint64 mMax;
     };
 #if KCONFIGCORE_ENABLE_DEPRECATED_SINCE(5, 0)
     typedef KCONFIGCORE_DEPRECATED_VERSION(5, 0, "Use ItemLongLong") ItemLongLong ItemInt64;
 #endif
 
     /**
      * Class for handling enums.
      */
     class KCONFIGCORE_EXPORT ItemEnum : public ItemInt
     {
     public:
         struct Choice {
             QString name;
             QString label;
             QString toolTip;
             QString whatsThis;
         };
 
         /**
          * @copydoc KConfigSkeletonGenericItem::KConfigSkeletonGenericItem
          * @param choices The list of enums that can be stored in this item
          */
         ItemEnum(const QString &_group, const QString &_key, qint32 &reference, const QList<Choice> &choices, qint32 defaultValue = 0);
 
         QList<Choice> choices() const;
 
         /** @copydoc KConfigSkeletonItem::readConfig(KConfig*) */
         void readConfig(KConfig *config) override;
 
         /** @copydoc KConfigSkeletonItem::writeConfig(KConfig*) */
         void writeConfig(KConfig *config) override;
 
 #if KCONFIGCORE_ENABLE_DEPRECATED_SINCE(5, 103)
         // Source compatibility with 4.x
         typedef KCONFIGCORE_DEPRECATED_VERSION_BELATED(5, 103, 5, 0, "Use Choice") Choice Choice2;
         /**
          * @deprecated since 5.0, use choices() const.
          */
         KCONFIGCORE_DEPRECATED_VERSION_BELATED(5, 103, 5, 0, "Use choices().")
         QList<Choice> choices2() const;
 #endif
 
         /**
          * Returns the value for for the choice with the given @p name
          */
         QString valueForChoice(const QString &name) const;
 
         /**
          * Stores a choice value for @p name
          */
         void setValueForChoice(const QString &name, const QString &valueForChoice);
 
     private:
         QList<Choice> mChoices;
     };
 
     /**
      * Class for handling an unsigned 32-bit integer preferences item.
      */
     class KCONFIGCORE_EXPORT ItemUInt : public KConfigSkeletonGenericItem<quint32>
     {
     public:
         /** @copydoc KConfigSkeletonGenericItem::KConfigSkeletonGenericItem */
         ItemUInt(const QString &_group, const QString &_key, quint32 &reference, quint32 defaultValue = 0);
 
         /** @copydoc KConfigSkeletonItem::readConfig(KConfig*) */
         void readConfig(KConfig *config) override;
 
         /** @copydoc KConfigSkeletonItem::setProperty(const QVariant&) */
         void setProperty(const QVariant &p) override;
 
         /** @copydoc KConfigSkeletonItem::isEqual(const QVariant &) const */
         bool isEqual(const QVariant &p) const override;
 
         /** @copydoc KConfigSkeletonItem::property() */
         QVariant property() const override;
 
         /** @copydoc ItemInt::minValue() */
         QVariant minValue() const override;
 
         /** @copydoc ItemInt::maxValue() */
         QVariant maxValue() const override;
 
         /** @copydoc ItemInt::setMinValue(qint32) */
         void setMinValue(quint32);
 
         /** @copydoc ItemInt::setMaxValue(qint32) */
         void setMaxValue(quint32);
 
     private:
         bool mHasMin : 1;
         bool mHasMax : 1;
         quint32 mMin;
         quint32 mMax;
     };
 
     /**
      * Class for handling unsigned 64-bit integer preferences item.
      */
     class KCONFIGCORE_EXPORT ItemULongLong : public KConfigSkeletonGenericItem<quint64>
     {
     public:
         /** @copydoc KConfigSkeletonGenericItem::KConfigSkeletonGenericItem */
         ItemULongLong(const QString &_group, const QString &_key, quint64 &reference, quint64 defaultValue = 0);
 
         /** @copydoc KConfigSkeletonItem::readConfig(KConfig*) */
         void readConfig(KConfig *config) override;
 
         /** @copydoc KConfigSkeletonItem::setProperty(const QVariant&) */
         void setProperty(const QVariant &p) override;
 
         /** @copydoc KConfigSkeletonItem::isEqual(const QVariant &) const */
         bool isEqual(const QVariant &p) const override;
 
         /** @copydoc KConfigSkeletonItem::property() */
         QVariant property() const override;
 
         /** @copydoc ItemInt::minValue() */
         QVariant minValue() const override;
 
         /** @copydoc ItemInt::maxValue() */
         QVariant maxValue() const override;
 
         /** @copydoc ItemInt::setMinValue(qint32) */
         void setMinValue(quint64);
 
         /** @copydoc ItemInt::setMaxValue(qint32) */
         void setMaxValue(quint64);
 
     private:
         bool mHasMin : 1;
         bool mHasMax : 1;
         quint64 mMin;
         quint64 mMax;
     };
 #if KCONFIGCORE_ENABLE_DEPRECATED_SINCE(5, 0)
     typedef KCONFIGCORE_DEPRECATED_VERSION(5, 0, "Use ItemULongLong") ItemULongLong ItemUInt64;
 #endif
 
     /**
      * Class for handling a floating point preference item.
      */
     class KCONFIGCORE_EXPORT ItemDouble : public KConfigSkeletonGenericItem<double>
     {
     public:
         /** @copydoc KConfigSkeletonGenericItem::KConfigSkeletonGenericItem */
         ItemDouble(const QString &_group, const QString &_key, double &reference, double defaultValue = 0);
 
         /** @copydoc KConfigSkeletonItem::readConfig(KConfig*) */
         void readConfig(KConfig *config) override;
 
         /** @copydoc KConfigSkeletonItem::setProperty(const QVariant&) */
         void setProperty(const QVariant &p) override;
 
         /** @copydoc KConfigSkeletonItem::isEqual(const QVariant &) const */
         bool isEqual(const QVariant &p) const override;
 
         /** @copydoc KConfigSkeletonItem::property() */
         QVariant property() const override;
 
         /** @copydoc ItemInt::minValue() */
         QVariant minValue() const override;
 
         /** @copydoc ItemInt::maxValue() */
         QVariant maxValue() const override;
 
         /** @copydoc ItemInt::setMinValue() */
         void setMinValue(double);
 
         /** @copydoc ItemInt::setMaxValue() */
         void setMaxValue(double);
 
     private:
         bool mHasMin : 1;
         bool mHasMax : 1;
         double mMin;
         double mMax;
     };
 
     /**
      * Class for handling a QRect preferences item.
      */
     class KCONFIGCORE_EXPORT ItemRect : public KConfigSkeletonGenericItem<QRect>
     {
     public:
         /** @copydoc KConfigSkeletonGenericItem::KConfigSkeletonGenericItem */
         ItemRect(const QString &_group, const QString &_key, QRect &reference, const QRect &defaultValue = QRect());
 
         /** @copydoc KConfigSkeletonItem::readConfig(KConfig*) */
         void readConfig(KConfig *config) override;
 
         /** @copydoc KConfigSkeletonItem::setProperty(const QVariant&) */
         void setProperty(const QVariant &p) override;
 
         /** @copydoc KConfigSkeletonItem::isEqual(const QVariant &) const */
         bool isEqual(const QVariant &p) const override;
 
         /** @copydoc KConfigSkeletonItem::property() */
         QVariant property() const override;
     };
 
     /**
      * Class for handling a QPoint preferences item.
      */
     class KCONFIGCORE_EXPORT ItemPoint : public KConfigSkeletonGenericItem<QPoint>
     {
     public:
         /** @copydoc KConfigSkeletonGenericItem::KConfigSkeletonGenericItem */
         ItemPoint(const QString &_group, const QString &_key, QPoint &reference, const QPoint &defaultValue = QPoint());
 
         /** @copydoc KConfigSkeletonItem::readConfig(KConfig*) */
         void readConfig(KConfig *config) override;
 
         /** @copydoc KConfigSkeletonItem::setProperty(const QVariant&) */
         void setProperty(const QVariant &p) override;
 
         /** @copydoc KConfigSkeletonItem::isEqual(const QVariant &) const */
         bool isEqual(const QVariant &p) const override;
 
         /** @copydoc KConfigSkeletonItem::property() */
         QVariant property() const override;
     };
 
     /**
      * Class for handling a QSize preferences item.
      */
     class KCONFIGCORE_EXPORT ItemSize : public KConfigSkeletonGenericItem<QSize>
     {
     public:
         /** @copydoc KConfigSkeletonGenericItem::KConfigSkeletonGenericItem */
         ItemSize(const QString &_group, const QString &_key, QSize &reference, const QSize &defaultValue = QSize());
 
         /** @copydoc KConfigSkeletonItem::readConfig(KConfig*) */
         void readConfig(KConfig *config) override;
 
         /** @copydoc KConfigSkeletonItem::setProperty(const QVariant&) */
         void setProperty(const QVariant &p) override;
 
         /** @copydoc KConfigSkeletonItem::isEqual(const QVariant &) const */
         bool isEqual(const QVariant &p) const override;
 
         /** @copydoc KConfigSkeletonItem::property() */
         QVariant property() const override;
     };
 
     /**
      * Class for handling a QDateTime preferences item.
      */
     class KCONFIGCORE_EXPORT ItemDateTime : public KConfigSkeletonGenericItem<QDateTime>
     {
     public:
         /** @copydoc KConfigSkeletonGenericItem::KConfigSkeletonGenericItem */
         ItemDateTime(const QString &_group, const QString &_key, QDateTime &reference, const QDateTime &defaultValue = QDateTime());
 
         /** @copydoc KConfigSkeletonItem::readConfig(KConfig*) */
         void readConfig(KConfig *config) override;
 
         /** @copydoc KConfigSkeletonItem::setProperty(const QVariant&) */
         void setProperty(const QVariant &p) override;
 
         /** @copydoc KConfigSkeletonItem::isEqual(const QVariant &) const */
         bool isEqual(const QVariant &p) const override;
 
         /** @copydoc KConfigSkeletonItem::property() */
         QVariant property() const override;
     };
 
     /**
      * Class for handling a string list preferences item.
      */
     class KCONFIGCORE_EXPORT ItemStringList : public KConfigSkeletonGenericItem<QStringList>
     {
     public:
         /** @copydoc KConfigSkeletonGenericItem::KConfigSkeletonGenericItem */
         ItemStringList(const QString &_group, const QString &_key, QStringList &reference, const QStringList &defaultValue = QStringList());
 
         /** @copydoc KConfigSkeletonItem::readConfig(KConfig*) */
         void readConfig(KConfig *config) override;
 
         /** @copydoc KConfigSkeletonItem::setProperty(const QVariant&) */
         void setProperty(const QVariant &p) override;
 
         /** @copydoc KConfigSkeletonItem::isEqual(const QVariant &) const */
         bool isEqual(const QVariant &p) const override;
 
         /** @copydoc KConfigSkeletonItem::property() */
         QVariant property() const override;
     };
 
     /**
      * Class for handling a path list preferences item.
      */
     class KCONFIGCORE_EXPORT ItemPathList : public ItemStringList
     {
     public:
         /** @copydoc KConfigSkeletonGenericItem::KConfigSkeletonGenericItem */
         ItemPathList(const QString &_group, const QString &_key, QStringList &reference, const QStringList &defaultValue = QStringList());
 
         /** @copydoc KConfigSkeletonItem::readConfig */
         void readConfig(KConfig *config) override;
         /** @copydoc KConfigSkeletonItem::writeConfig */
         void writeConfig(KConfig *config) override;
     };
 
     /**
      * Class for handling a url list preferences item.
      */
     class KCONFIGCORE_EXPORT ItemUrlList : public KConfigSkeletonGenericItem<QList<QUrl>>
     {
     public:
         /** @copydoc KConfigSkeletonGenericItem::KConfigSkeletonGenericItem */
         ItemUrlList(const QString &_group, const QString &_key, QList<QUrl> &reference, const QList<QUrl> &defaultValue = QList<QUrl>());
 
         /** @copydoc KConfigSkeletonItem::readConfig(KConfig*) */
         void readConfig(KConfig *config) override;
 
         /** @copydoc KConfigSkeletonItem::writeConfig(KConfig*) */
         void writeConfig(KConfig *config) override;
 
         /** @copydoc KConfigSkeletonItem::setProperty(const QVariant&) */
         void setProperty(const QVariant &p) override;
 
         /** @copydoc KConfigSkeletonItem::isEqual(const QVariant &) const */
         bool isEqual(const QVariant &p) const override;
 
         /** @copydoc KConfigSkeletonItem::property() */
         QVariant property() const override;
     };
 
     /**
      * Class for handling an integer list preferences item.
      */
     class KCONFIGCORE_EXPORT ItemIntList : public KConfigSkeletonGenericItem<QList<int>>
     {
     public:
         /** @copydoc KConfigSkeletonGenericItem::KConfigSkeletonGenericItem */
         ItemIntList(const QString &_group, const QString &_key, QList<int> &reference, const QList<int> &defaultValue = QList<int>());
 
         /** @copydoc KConfigSkeletonItem::readConfig(KConfig*) */
         void readConfig(KConfig *config) override;
 
         /** @copydoc KConfigSkeletonItem::setProperty(const QVariant&) */
         void setProperty(const QVariant &p) override;
 
         /** @copydoc KConfigSkeletonItem::isEqual(const QVariant &) const */
         bool isEqual(const QVariant &p) const override;
 
         /** @copydoc KConfigSkeletonItem::property() */
         QVariant property() const override;
     };
 
 public:
     /**
      * Constructor.
      *
      * @param configname name of config file. If no name is given, the default
      *                   config file as returned by KSharedConfig::openConfig() is used
      * @param parent the parent object (see QObject documentation)
      */
     explicit KCoreConfigSkeleton(const QString &configname = QString(), QObject *parent = nullptr);
 
     /**
      * Constructor.
      *
      * @param config configuration object to use
      * @param parent the parent object (see QObject documentation)
      */
     explicit KCoreConfigSkeleton(KSharedConfig::Ptr config, QObject *parent = nullptr);
 
     /**
      * Destructor
      */
     ~KCoreConfigSkeleton() override;
 
     /**
      * Set all registered items to their default values.
      * This method calls usrSetDefaults() after setting the defaults for the
      * registered items. You can override usrSetDefaults() in derived classes
      * if you have special requirements.
      * If you need more fine-grained control of setting the default values of
      * the registered items you can override setDefaults() in a derived class.
      */
     virtual void setDefaults();
 
     /**
      * Read preferences from config file. All registered items are set to the
      * values read from disk.
      * This method calls usrRead() after reading the settings of the
      * registered items from the KConfig. You can override usrRead()
      * in derived classes if you have special requirements.
      */
     void load();
 
 #if KCONFIGCORE_ENABLE_DEPRECATED_SINCE(5, 0)
     /**
      * @deprecated since 5.0, call load() instead (to reload from disk) or just read()
      * if the underlying KConfig object is already up-to-date.
      */
     KCONFIGCORE_DEPRECATED_VERSION(5, 0, "Use KCoreConfigSkeleton::load() or KCoreConfigSkeleton::read()")
     void readConfig()
     {
         load();
     }
 #endif
 
     /**
      * Read preferences from the KConfig object.
      * This method assumes that the KConfig object was previously loaded,
      * i.e. it uses the in-memory values from KConfig without reloading from disk.
      *
      * This method calls usrRead() after reading the settings of the
      * registered items from the KConfig. You can override usrRead()
      * in derived classes if you have special requirements.
      * @since 5.0
      */
     void read();
 
     /**
      * Indicates if all the registered items are set to their default value.
      *
      * @since 5.64
      */
     bool isDefaults() const;
 
     /**
      * Indicates if any registered item has a different value than the
      * previously loaded value.
      *
      * @since 5.64
      */
     bool isSaveNeeded() const;
 
     /**
      * Set the config file group for subsequent addItem() calls. It is valid
      * until setCurrentGroup() is called with a new argument. Call this before
      * you add any items. The default value is "No Group".
      */
     void setCurrentGroup(const QString &group);
 
     /**
      * Returns the current group used for addItem() calls.
      */
     QString currentGroup() const;
 
     /**
      * Register a custom @ref KConfigSkeletonItem @p item with a given @p name.
      *
      * If @p name is a null string, take the name from KConfigSkeletonItem::key().
      *
      * @note All names must be unique but multiple entries can have
      * the same key if they reside in different groups.
      *
      * KCoreConfigSkeleton takes ownership of @p item.
      */
     void addItem(KConfigSkeletonItem *item, const QString &name = QString());
 
     /**
      * Register an item of type QString.
      *
      * @param name Name used to identify this setting. Names must be unique.
      * @param reference Pointer to the variable, which is set by readConfig()
      * calls and read by save() calls.
      * @param defaultValue Default value, which is used when the config file
      * does not yet contain the key of this item.
      * @param key Key used in config file. If @p key is a null string, @p name is used as key.
      * @return The created item
      */
     ItemString *addItemString(const QString &name,
                               QString &reference,
                               const QString &defaultValue = QLatin1String(""), // NOT QString() !!
                               const QString &key = QString());
 
     /**
      * Register a password item of type QString. The string value is written
      * encrypted to the config file.
      *
      * @note The current encryption scheme is very weak.
      *
      * @param name Name used to identify this setting. Names must be unique.
      * @param reference Pointer to the variable, which is set by readConfig()
      * calls and read by save() calls.
      * @param defaultValue Default value, which is used when the config file
      * does not yet contain the key of this item.
      * @param key Key used in config file. If @p key is a null string, @p name is used as key.
      * @return The created item
      */
     ItemPassword *addItemPassword(const QString &name, QString &reference, const QString &defaultValue = QLatin1String(""), const QString &key = QString());
 
     /**
      * Register a path item of type QString. The string value is interpreted
      * as a path. This means, dollar expansion is activated for this value, so
      * that e.g. @c $HOME gets expanded.
      *
      * @param name Name used to identify this setting. Names must be unique.
      * @param reference Pointer to the variable, which is set by readConfig()
      * calls and read by save() calls.
      * @param defaultValue Default value, which is used when the config file
      * does not yet contain the key of this item.
      * @param key Key used in config file. If @p key is a null string, @p name is used as key.
      * @return The created item
      */
     ItemPath *addItemPath(const QString &name, QString &reference, const QString &defaultValue = QLatin1String(""), const QString &key = QString());
 
     /**
      * Register a property item of type QVariant.
      *
      * @note The following QVariant types are allowed:
      * String, StringList, Font, Point, Rect, Size,
      * Color, Int, UInt, Bool, Double, DateTime and Date.
      *
      * @param name Name used to identify this setting. Names must be unique.
      * @param reference Pointer to the variable, which is set by readConfig()
      * calls and read by save() calls.
      * @param defaultValue Default value, which is used when the config file
      * does not yet contain the key of this item.
      * @param key Key used in config file. If @p key is a null string, @p name is used as key.
      * @return The created item
      */
     ItemProperty *addItemProperty(const QString &name, QVariant &reference, const QVariant &defaultValue = QVariant(), const QString &key = QString());
     /**
      * Register an item of type @c bool.
      *
      * @param name Name used to identify this setting. Names must be unique.
      * @param reference Pointer to the variable, which is set by readConfig()
      * calls and read by save() calls.
      * @param defaultValue Default value, which is used when the config file
      * does not yet contain the key of this item.
      * @param key Key used in config file. If @p key is a null string, @p name is used as key.
      * @return The created item
      */
     ItemBool *addItemBool(const QString &name, bool &reference, bool defaultValue = false, const QString &key = QString());
 
     /**
      * Register an item of type @c qint32.
      *
      * @param name Name used to identify this setting. Names must be unique.
      * @param reference Pointer to the variable, which is set by readConfig()
      * calls and read by save() calls.
      * @param defaultValue Default value, which is used when the config file
      * does not yet contain the key of this item.
      * @param key Key used in config file. If @p key is a null string, @p name is used as key.
      * @return The created item
      */
     ItemInt *addItemInt(const QString &name, qint32 &reference, qint32 defaultValue = 0, const QString &key = QString());
 
     /**
      * Register an item of type @c quint32.
      *
      * @param name Name used to identify this setting. Names must be unique.
      * @param reference Pointer to the variable, which is set by readConfig()
      * calls and read by save() calls.
      * @param defaultValue Default value, which is used when the config file
      * does not yet contain the key of this item.
      * @param key Key used in config file. If @p key is a null string, @p name is used as key.
      * @return The created item
      */
     ItemUInt *addItemUInt(const QString &name, quint32 &reference, quint32 defaultValue = 0, const QString &key = QString());
 
     /**
      * Register an item of type @c qint64.
      *
      * @param name Name used to identify this setting. Names must be unique.
      * @param reference Pointer to the variable, which is set by readConfig()
      * calls and read by save() calls.
      * @param defaultValue Default value, which is used when the config file
      * does not yet contain the key of this item.
      * @param key Key used in config file. If @p key is a null string, @p name is used as key.
      * @return The created item
      */
     ItemLongLong *addItemLongLong(const QString &name, qint64 &reference, qint64 defaultValue = 0, const QString &key = QString());
 
 #if KCONFIGCORE_ENABLE_DEPRECATED_SINCE(5, 0)
     /**
      * @deprecated Since 5.0, use addItemLongLong().
      */
     KCONFIGCORE_DEPRECATED_VERSION(5, 0, "Use KCoreConfigSkeleton::addItemLongLong(...)")
     ItemLongLong *addItemInt64(const QString &name, qint64 &reference, qint64 defaultValue = 0, const QString &key = QString());
 #endif
 
     /**
      * Register an item of type @c quint64.
      *
      * @param name Name used to identify this setting. Names must be unique.
      * @param reference Pointer to the variable, which is set by readConfig()
      * calls and read by save() calls.
      * @param defaultValue Default value, which is used when the config file
      * does not yet contain the key of this item.
      * @param key Key used in config file. If @p key is a null string, @p name is used as key.
      * @return The created item
      */
     ItemULongLong *addItemULongLong(const QString &name, quint64 &reference, quint64 defaultValue = 0, const QString &key = QString());
 
 #if KCONFIGCORE_ENABLE_DEPRECATED_SINCE(5, 0)
     /**
      * @deprecated Since 5.0, use addItemULongLong().
      */
     KCONFIGCORE_DEPRECATED_VERSION(5, 0, "Use KCoreConfigSkeleton::addItemULongLong(...)")
     ItemULongLong *addItemUInt64(const QString &name, quint64 &reference, quint64 defaultValue = 0, const QString &key = QString());
 #endif
 
     /**
      * Register an item of type @c double.
      *
      * @param name Name used to identify this setting. Names must be unique.
      * @param reference Pointer to the variable, which is set by readConfig()
      * calls and read by save() calls.
      * @param defaultValue Default value, which is used when the config file
      * does not yet contain the key of this item.
      * @param key Key used in config file. If @p key is a null string, @p name is used as key.
      * @return The created item
      */
     ItemDouble *addItemDouble(const QString &name, double &reference, double defaultValue = 0.0, const QString &key = QString());
 
     /**
      * Register an item of type QRect.
      *
      * @param name Name used to identify this setting. Names must be unique.
      * @param reference Pointer to the variable, which is set by readConfig()
      * calls and read by save() calls.
      * @param defaultValue Default value, which is used when the config file
      * does not yet contain the key of this item.
      * @param key Key used in config file. If @p key is a null string, @p name is used as key.
      * @return The created item
      */
     ItemRect *addItemRect(const QString &name, QRect &reference, const QRect &defaultValue = QRect(), const QString &key = QString());
 
     /**
      * Register an item of type QPoint.
      *
      * @param name Name used to identify this setting. Names must be unique.
      * @param reference Pointer to the variable, which is set by readConfig()
      * calls and read by save() calls.
      * @param defaultValue Default value, which is used when the config file
      * does not yet contain the key of this item.
      * @param key Key used in config file. If @p key is a null string, @p name is used as key.
      * @return The created item
      */
     ItemPoint *addItemPoint(const QString &name, QPoint &reference, const QPoint &defaultValue = QPoint(), const QString &key = QString());
 
     /**
      * Register an item of type QSize.
      *
      * @param name Name used to identify this setting. Names must be unique.
      * @param reference Pointer to the variable, which is set by readConfig()
      * calls and read by save() calls.
      * @param defaultValue Default value, which is used when the config file
      * does not yet contain the key of this item.
      * @param key Key used in config file. If @p key is a null string, @p name is used as key.
      * @return The created item
      */
     ItemSize *addItemSize(const QString &name, QSize &reference, const QSize &defaultValue = QSize(), const QString &key = QString());
 
     /**
      * Register an item of type QDateTime.
      *
      * @param name Name used to identify this setting. Names must be unique.
      * @param reference Pointer to the variable, which is set by readConfig()
      * calls and read by save() calls.
      * @param defaultValue Default value, which is used when the config file
      * does not yet contain the key of this item.
      * @param key Key used in config file. If @p key is a null string, @p name is used as key.
      * @return The created item
      */
     ItemDateTime *addItemDateTime(const QString &name, QDateTime &reference, const QDateTime &defaultValue = QDateTime(), const QString &key = QString());
 
     /**
      * Register an item of type QStringList.
      *
      * @param name Name used to identify this setting. Names must be unique.
      * @param reference Pointer to the variable, which is set by readConfig()
      * calls and read by save() calls.
      * @param defaultValue Default value, which is used when the config file
      * does not yet contain the key of this item.
      * @param key Key used in config file. If @p key is a null string, @p name is used as key.
      * @return The created item
      */
     ItemStringList *
     addItemStringList(const QString &name, QStringList &reference, const QStringList &defaultValue = QStringList(), const QString &key = QString());
 
     /**
      * Register an item of type QList<int>.
      *
      * @param name Name used to identify this setting. Names must be unique.
      * @param reference Pointer to the variable, which is set by readConfig()
      * calls and read by save() calls.
      * @param defaultValue Default value, which is used when the config file
      * does not yet contain the key of this item.
      * @param key Key used in config file. If @p key is a null string, @p name is used as key.
      * @return The created item
      */
     ItemIntList *addItemIntList(const QString &name, QList<int> &reference, const QList<int> &defaultValue = QList<int>(), const QString &key = QString());
 
     /**
      * Return the @ref KConfig object used for reading and writing the settings.
      */
     KConfig *config();
 
     /**
      * Return the @ref KConfig object used for reading and writing the settings.
      */
     const KConfig *config() const;
 
     /**
      * Return the @ref KConfig object used for reading and writing the settings.
      * @since 5.0
      */
     KSharedConfig::Ptr sharedConfig() const;
 
     /**
      * Set the @ref KSharedConfig object used for reading and writing the settings.
      */
     void setSharedConfig(KSharedConfig::Ptr pConfig);
 
     /**
      * Return list of items managed by this KCoreConfigSkeleton object.
      */
     KConfigSkeletonItem::List items() const;
 
     /**
      * Removes and deletes an item by name
      * @param name the name of the item to remove
      */
     void removeItem(const QString &name);
 
     /**
      * Removes and deletes all items
      */
     void clearItems();
 
     /**
      * Return whether a certain item is immutable
      * @since 4.4
      */
     Q_INVOKABLE bool isImmutable(const QString &name) const;
 
     /**
      * Lookup item by name
      * @since 4.4
      */
     KConfigSkeletonItem *findItem(const QString &name) const;
 
     /**
      * Specify whether this object should reflect the actual values or the
      * default values.
      * This method is implemented by usrUseDefaults(), which can be overridden
      * in derived classes if you have special requirements and can call
      * usrUseDefaults() directly.
      * If you don't have control whether useDefaults() or usrUseDefaults() is
      * called override useDefaults() directly.
      * @param b @c true to make this object reflect the default values,
      *          @c false to make it reflect the actual values.
      * @return The state prior to this call
      */
     virtual bool useDefaults(bool b);
 
 public Q_SLOTS:
     /**
      * Write preferences to config file. The values of all registered items are
      * written to disk.
      * This method calls usrSave() after writing the settings from the
      * registered items to the KConfig. You can override usrSave()
      * in derived classes if you have special requirements.
      */
     bool save();
 
 #if KCONFIGCORE_ENABLE_DEPRECATED_SINCE(5, 0)
     /**
      * @deprecated since 5.0, call save() instead.
      */
     KCONFIGCORE_DEPRECATED_VERSION(5, 0, "Use KCoreConfigSkeleton::save()")
     void writeConfig()
     {
         save();
     }
 #endif
 
 Q_SIGNALS:
     /**
      * This signal is emitted when the configuration change.
      */
     void configChanged();
 
 protected:
     /**
      * Implemented by subclasses that use special defaults.
      * It replaces the default values with the actual values and
      * vice versa.  Called from @ref useDefaults()
      * @param b @c true to make this object reflect the default values,
      *          @c false to make it reflect the actual values.
      * @return The state prior to this call
      */
     virtual bool usrUseDefaults(bool b);
 
     /**
      * Perform the actual setting of default values.
      * Override in derived classes to set special default values.
      * Called from @ref setDefaults()
      */
     virtual void usrSetDefaults();
 
     /**
      * Perform the actual reading of the configuration file.
      * Override in derived classes to read special config values.
      * Called from @ref read()
      */
     virtual void usrRead();
 
     /**
      * Perform the actual writing of the configuration file.
      * Override in derived classes to write special config values.
      * Called from @ref save()
      */
     virtual bool usrSave();
 
 #if KCONFIGCORE_BUILD_DEPRECATED_SINCE(5, 0)
     /**
      * @deprecated since 5.0, override usrRead instead.  This method is still called from usrRead
      * for compatibility.
      */
     KCONFIGCORE_DEPRECATED_VERSION(5, 0, "Override KCoreConfigSkeleton::usrRead()")
     virtual void usrReadConfig();
 #endif
 
 #if KCONFIGCORE_BUILD_DEPRECATED_SINCE(5, 0)
     /**
      * @deprecated since 5.0, override usrSave instead.  This method is still called from usrSave
      * for compatibility.
      */
     KCONFIGCORE_DEPRECATED_VERSION(5, 0, "Override KCoreConfigSkeleton::usrSave()")
     virtual bool usrWriteConfig();
 #endif
 
 private:
     KCoreConfigSkeletonPrivate *const d;
     friend class KConfigSkeleton;
 };
 
 #endif