kcoreconfigskeleton.h

/*
 * This file is part of KDE.
 *
 * Copyright (c) 2001,2002,2003 Cornelius Schumacher <[email protected]>
 * Copyright (c) 2003 Waldo Bastian <[email protected]>
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public License
 * along with this library; see the file COPYING.LIB.  If not, write to
 * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA 02110-1301, USA.
 */

#ifndef KCORECONFIGSKELETON_H
#define KCORECONFIGSKELETON_H

#include <kconfigcore_export.h>

#include <ksharedconfig.h>
#include <kconfiggroup.h>

#include <QDate>
#include <QHash>
#include <QRect>
#include <QStringList>
#include <QVariant>
#include <QUrl>
class KCoreConfigSkeletonPrivate;

class KConfigSkeletonItemPrivate;
class KCONFIGCORE_EXPORT KConfigSkeletonItem
{
public:
    typedef QList < KConfigSkeletonItem * >List;
    typedef QHash < QString, KConfigSkeletonItem * > Dict;
    typedef QHash < QString, KConfigSkeletonItem * >::Iterator DictIterator;

    KConfigSkeletonItem(const QString &_group, const QString &_key);

    virtual ~KConfigSkeletonItem();

    void setGroup(const QString &_group);

    QString group() const;

    void setKey(const QString &_key);

    QString key() const;

    void setName(const QString &_name);

    QString name() const;

    void setLabel(const QString &l);

    QString label() const;

    void setToolTip(const QString &t);

    QString toolTip() const;

    void setWhatsThis(const QString &w);

    QString whatsThis() const;

    void setWriteFlags(KConfigBase::WriteConfigFlags flags);

    KConfigBase::WriteConfigFlags writeFlags() const;

    virtual void readConfig(KConfig *) = 0;

    virtual void writeConfig(KConfig *) = 0;

    virtual void readDefault(KConfig *) = 0;

    virtual void setProperty(const QVariant &p) = 0;

    virtual bool isEqual(const QVariant &p) const = 0;

    virtual QVariant property() const = 0;

    virtual QVariant minValue() const;

    virtual QVariant maxValue() const;

    virtual void setDefault() = 0;

    virtual void swapDefault() = 0;

    bool isImmutable() const;

    bool isDefault() const;

    bool isSaveNeeded() const;

protected:
    void readImmutability(const KConfigGroup &group);

    QString mGroup; 
    QString mKey; 
    QString mName; 

    // 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);

private:
    KConfigSkeletonItemPrivate *const d;
};

template < typename T > class KConfigSkeletonGenericItem: public KConfigSkeletonItem
{
public:
    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; });
    }

    void setValue(const T &v)
    {
        mReference = v;
    }

    T &value()
    {
        return mReference;
    }

    const T &value() const
    {
        return mReference;
    }

    virtual void setDefaultValue(const T &v)
    {
        mDefault = v;
    }

    void setDefault() override
    {
        mReference = mDefault;
    }

    void writeConfig(KConfig *config) override
    {
        if (mReference != mLoadedValue) { // Is this needed?
            KConfigGroup cg(config, mGroup);
            if ((mDefault == mReference) && !cg.hasDefault(mKey)) {
                cg.revertToDefault(mKey, writeFlags());
            } else {
                cg.writeEntry(mKey, mReference, writeFlags());
            }
            mLoadedValue = mReference;
        }
    }

    void readDefault(KConfig *config) override
    {
        config->setReadDefaults(true);
        readConfig(config);
        config->setReadDefaults(false);
        mDefault = mReference;
    }

    void swapDefault() override
    {
        T tmp = mReference;
        mReference = mDefault;
        mDefault = tmp;
    }

protected:
    T &mReference;  
    T mDefault; 
    T mLoadedValue;
};

class KCONFIGCORE_EXPORT KConfigCompilerSignallingItem : public KConfigSkeletonItem
{
public:
    typedef void (QObject::* NotifyFunction)(quint64 arg);
    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;
    void setDefault() override;
    void swapDefault() override;
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 KCONFIGCORE_EXPORT KCoreConfigSkeleton : public QObject
{
    Q_OBJECT
public:
    class KCONFIGCORE_EXPORT ItemString: public KConfigSkeletonGenericItem < QString >
    {
    public:
        enum Type { Normal, Password, Path };

        ItemString(const QString &_group, const QString &_key,
                   QString &reference,
                   const QString &defaultValue = QLatin1String(""),  // NOT QString() !!
                   Type type = Normal);

        void writeConfig(KConfig *config) override;

        void readConfig(KConfig *config) override;

        void setProperty(const QVariant &p) override;

        bool isEqual(const QVariant &p) const override;

        QVariant property() const override;

    private:
        Type mType;
    };

    class KCONFIGCORE_EXPORT ItemPassword: public ItemString
    {
    public:
        ItemPassword(const QString &_group, const QString &_key,
                     QString &reference,
                     const QString &defaultValue = QLatin1String(""));  // NOT QString() !!
    };

    class KCONFIGCORE_EXPORT ItemPath: public ItemString
    {
    public:
        ItemPath(const QString &_group, const QString &_key,
                 QString &reference,
                 const QString &defaultValue = QString());
    };

    class KCONFIGCORE_EXPORT ItemUrl: public KConfigSkeletonGenericItem < QUrl >
    {
    public:

        ItemUrl(const QString &_group, const QString &_key,
                QUrl &reference,
                const QUrl &defaultValue = QUrl());

        void writeConfig(KConfig *config) override;

        void readConfig(KConfig *config) override;

        void setProperty(const QVariant &p) override;

        bool isEqual(const QVariant &p) const override;

        QVariant property() const override;
    };

    class KCONFIGCORE_EXPORT ItemProperty: public KConfigSkeletonGenericItem < QVariant >
    {
    public:
        ItemProperty(const QString &_group, const QString &_key,
                     QVariant &reference, const QVariant &defaultValue = QVariant());

        void readConfig(KConfig *config) override;
        void setProperty(const QVariant &p) override;

        bool isEqual(const QVariant &p) const override;

        QVariant property() const override;
    };

    class KCONFIGCORE_EXPORT ItemBool: public KConfigSkeletonGenericItem < bool >
    {
    public:
        ItemBool(const QString &_group, const QString &_key, bool &reference,
                 bool defaultValue = true);

        void readConfig(KConfig *config) override;

        void setProperty(const QVariant &p) override;

        bool isEqual(const QVariant &p) const override;

        QVariant property() const override;
    };

    class KCONFIGCORE_EXPORT ItemInt: public KConfigSkeletonGenericItem < qint32 >
    {
    public:
        ItemInt(const QString &_group, const QString &_key, qint32 &reference,
                qint32 defaultValue = 0);

        void readConfig(KConfig *config) 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 setMinValue(qint32);

        void setMaxValue(qint32);

    private:
        bool mHasMin : 1;
        bool mHasMax : 1;
        qint32 mMin;
        qint32 mMax;
    };

    class KCONFIGCORE_EXPORT ItemLongLong: public KConfigSkeletonGenericItem < qint64 >
    {
    public:
        ItemLongLong(const QString &_group, const QString &_key, qint64 &reference,
                     qint64 defaultValue = 0);

        void readConfig(KConfig *config) 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 setMinValue(qint64);

        void setMaxValue(qint64);

    private:
        bool mHasMin : 1;
        bool mHasMax : 1;
        qint64 mMin;
        qint64 mMax;
    };
#ifndef KDE_NO_DEPRECATED
    typedef KCONFIGCORE_DEPRECATED ItemLongLong ItemInt64;
#endif

    class KCONFIGCORE_EXPORT ItemEnum: public ItemInt
    {
    public:
        struct Choice {
            QString name;
            QString label;
            QString toolTip;
            QString whatsThis;
        };

        ItemEnum(const QString &_group, const QString &_key, qint32 &reference,
                 const QList<Choice> &choices, qint32 defaultValue = 0);

        QList<Choice> choices() const;

        void readConfig(KConfig *config) override;

        void writeConfig(KConfig *config) override;

        // Source compatibility with 4.x
        typedef Choice Choice2;
        QList<Choice> choices2() const;

    private:
        QList<Choice> mChoices;
    };

    class KCONFIGCORE_EXPORT ItemUInt: public KConfigSkeletonGenericItem < quint32 >
    {
    public:
        ItemUInt(const QString &_group, const QString &_key,
                 quint32 &reference, quint32 defaultValue = 0);

        void readConfig(KConfig *config) 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 setMinValue(quint32);

        void setMaxValue(quint32);

    private:
        bool mHasMin : 1;
        bool mHasMax : 1;
        quint32 mMin;
        quint32 mMax;
    };

    class KCONFIGCORE_EXPORT ItemULongLong: public KConfigSkeletonGenericItem < quint64 >
    {
    public:
        ItemULongLong(const QString &_group, const QString &_key, quint64 &reference,
                      quint64 defaultValue = 0);

        void readConfig(KConfig *config) 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 setMinValue(quint64);

        void setMaxValue(quint64);

    private:
        bool mHasMin : 1;
        bool mHasMax : 1;
        quint64 mMin;
        quint64 mMax;
    };
#ifndef KDE_NO_DEPRECATED
    typedef KCONFIGCORE_DEPRECATED ItemULongLong ItemUInt64;
#endif

    class KCONFIGCORE_EXPORT ItemDouble: public KConfigSkeletonGenericItem < double >
    {
    public:
        ItemDouble(const QString &_group, const QString &_key,
                   double &reference, double defaultValue = 0);

        void readConfig(KConfig *config) 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 setMinValue(double);

        void setMaxValue(double);

    private:
        bool mHasMin : 1;
        bool mHasMax : 1;
        double mMin;
        double mMax;
    };

    class KCONFIGCORE_EXPORT ItemRect: public KConfigSkeletonGenericItem < QRect >
    {
    public:
        ItemRect(const QString &_group, const QString &_key, QRect &reference,
                 const QRect &defaultValue = QRect());

        void readConfig(KConfig *config) override;

        void setProperty(const QVariant &p) override;

        bool isEqual(const QVariant &p) const override;

        QVariant property() const override;
    };

    class KCONFIGCORE_EXPORT ItemPoint: public KConfigSkeletonGenericItem < QPoint >
    {
    public:
        ItemPoint(const QString &_group, const QString &_key, QPoint &reference,
                  const QPoint &defaultValue = QPoint());

        void readConfig(KConfig *config) override;

        void setProperty(const QVariant &p) override;

        bool isEqual(const QVariant &p) const override;

        QVariant property() const override;
    };

    class KCONFIGCORE_EXPORT ItemSize: public KConfigSkeletonGenericItem < QSize >
    {
    public:
        ItemSize(const QString &_group, const QString &_key, QSize &reference,
                 const QSize &defaultValue = QSize());

        void readConfig(KConfig *config) override;

        void setProperty(const QVariant &p) override;

        bool isEqual(const QVariant &p) const override;

        QVariant property() const override;
    };

    class KCONFIGCORE_EXPORT ItemDateTime: public KConfigSkeletonGenericItem < QDateTime >
    {
    public:
        ItemDateTime(const QString &_group, const QString &_key,
                     QDateTime &reference,
                     const QDateTime &defaultValue = QDateTime());

        void readConfig(KConfig *config) override;

        void setProperty(const QVariant &p) override;

        bool isEqual(const QVariant &p) const override;

        QVariant property() const override;
    };

    class KCONFIGCORE_EXPORT ItemStringList: public KConfigSkeletonGenericItem < QStringList >
    {
    public:
        ItemStringList(const QString &_group, const QString &_key,
                       QStringList &reference,
                       const QStringList &defaultValue = QStringList());

        void readConfig(KConfig *config) override;

        void setProperty(const QVariant &p) override;

        bool isEqual(const QVariant &p) const override;

        QVariant property() const override;
    };

    class KCONFIGCORE_EXPORT ItemPathList: public ItemStringList
    {
    public:
        ItemPathList(const QString &_group, const QString &_key,
                     QStringList &reference,
                     const QStringList &defaultValue = QStringList());

        void readConfig(KConfig *config) override;
        void writeConfig(KConfig *config) override;
    };

    class KCONFIGCORE_EXPORT ItemUrlList: public KConfigSkeletonGenericItem < QList<QUrl> >
    {
    public:
        ItemUrlList(const QString &_group, const QString &_key,
                    QList<QUrl> &reference,
                    const QList<QUrl> &defaultValue = QList<QUrl>());

        void readConfig(KConfig *config) override;

        void writeConfig(KConfig *config) override;

        void setProperty(const QVariant &p) override;

        bool isEqual(const QVariant &p) const override;

        QVariant property() const override;
    };

    class KCONFIGCORE_EXPORT ItemIntList: public KConfigSkeletonGenericItem < QList < int > >
    {
    public:
        ItemIntList(const QString &_group, const QString &_key,
                    QList < int > &reference,
                    const QList < int > &defaultValue = QList < int >());

        void readConfig(KConfig *config) override;

        void setProperty(const QVariant &p) override;

        bool isEqual(const QVariant &p) const override;

        QVariant property() const override;
    };

public:
    explicit KCoreConfigSkeleton(const QString &configname = QString(), QObject *parent = nullptr);

    explicit KCoreConfigSkeleton(KSharedConfig::Ptr config, QObject *parent = nullptr);

    virtual ~KCoreConfigSkeleton();

    virtual void setDefaults();

    void load();

#ifndef KCONFIGCORE_NO_DEPRECATED

    KCONFIGCORE_DEPRECATED void readConfig()
    {
        load();
    }
#endif

    void read();

    bool isDefaults() const;

    bool isSaveNeeded() const;

    void setCurrentGroup(const QString &group);

    QString currentGroup() const;

    void addItem(KConfigSkeletonItem *, const QString &name = QString());

    ItemString *addItemString(const QString &name, QString &reference,
                              const QString &defaultValue = QLatin1String(""),  // NOT QString() !!
                              const QString &key = QString());

    ItemPassword *addItemPassword(const QString &name, QString &reference,
                                  const QString &defaultValue = QLatin1String(""),
                                  const QString &key = QString());

    ItemPath *addItemPath(const QString &name, QString &reference,
                          const QString &defaultValue = QLatin1String(""),
                          const QString &key = QString());

    ItemProperty *addItemProperty(const QString &name, QVariant &reference,
                                  const QVariant &defaultValue = QVariant(),
                                  const QString &key = QString());
    ItemBool *addItemBool(const QString &name, bool &reference,
                          bool defaultValue = false,
                          const QString &key = QString());

    ItemInt *addItemInt(const QString &name, qint32 &reference, qint32 defaultValue = 0,
                        const QString &key = QString());

    ItemUInt *addItemUInt(const QString &name, quint32 &reference,
                          quint32 defaultValue = 0,
                          const QString &key = QString());

    ItemLongLong *addItemLongLong(const QString &name, qint64 &reference,
                                  qint64 defaultValue = 0,
                                  const QString &key = QString());

#ifndef KDE_NO_DEPRECATED
    KCONFIGCORE_DEPRECATED ItemLongLong *addItemInt64(const QString &name, qint64 &reference,
            qint64 defaultValue = 0,
            const QString &key = QString());
#endif

    ItemULongLong *addItemULongLong(const QString &name, quint64 &reference,
                                    quint64 defaultValue = 0,
                                    const QString &key = QString());

#ifndef KDE_NO_DEPRECATED
    KCONFIGCORE_DEPRECATED ItemULongLong *addItemUInt64(const QString &name, quint64 &reference,
            quint64 defaultValue = 0,
            const QString &key = QString());
#endif

    ItemDouble *addItemDouble(const QString &name, double &reference,
                              double defaultValue = 0.0,
                              const QString &key = QString());

    ItemRect *addItemRect(const QString &name, QRect &reference,
                          const QRect &defaultValue = QRect(),
                          const QString &key = QString());

    ItemPoint *addItemPoint(const QString &name, QPoint &reference,
                            const QPoint &defaultValue = QPoint(),
                            const QString &key = QString());

    ItemSize *addItemSize(const QString &name, QSize &reference,
                          const QSize &defaultValue = QSize(),
                          const QString &key = QString());

    ItemDateTime *addItemDateTime(const QString &name, QDateTime &reference,
                                  const QDateTime &defaultValue = QDateTime(),
                                  const QString &key = QString());

    ItemStringList *addItemStringList(const QString &name, QStringList &reference,
                                      const QStringList &defaultValue = QStringList(),
                                      const QString &key = QString());

    ItemIntList *addItemIntList(const QString &name, QList < int > &reference,
                                const QList < int > &defaultValue =
                                    QList < int >(),
                                const QString &key = QString());

    KConfig *config();

    const KConfig *config() const;

    KSharedConfig::Ptr sharedConfig() const;

    void setSharedConfig(KSharedConfig::Ptr pConfig);

    KConfigSkeletonItem::List items() const;

    void removeItem(const QString &name);

    void clearItems();

    Q_INVOKABLE bool isImmutable(const QString &name) const;

    KConfigSkeletonItem *findItem(const QString &name) const;

    virtual bool useDefaults(bool b);

public Q_SLOTS:
    bool save();

#ifndef KCONFIGCORE_NO_DEPRECATED

    KCONFIGCORE_DEPRECATED void writeConfig()
    {
        save();
    }
#endif

Q_SIGNALS:
    void configChanged();

protected:
    virtual bool usrUseDefaults(bool b);

    virtual void usrSetDefaults();

    virtual void usrRead();

    virtual bool usrSave();

    KCONFIGCORE_DEPRECATED virtual void usrReadConfig();

    KCONFIGCORE_DEPRECATED virtual bool usrWriteConfig();

private:
    KCoreConfigSkeletonPrivate *const d;
    friend class KConfigSkeleton;

};

#endif