kcoreconfigskeleton.h

Go to the documentation of this file.

/*
 * This file is part of KDE.
 *
 * Copyright (c) 2001,2002,2003 Cornelius Schumacher <schumacher@kde.org>
 * Copyright (c) 2003 Waldo Bastian <bastian@kde.org>
 *
 * 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 <kdecore_export.h>

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

#include <QtCore/QDate>
#include <QtCore/QHash>
#include <QtCore/QRect>
#include <QtCore/QStringList>
#include <QtCore/QVariant>

  class KConfigSkeletonItemPrivate;
  class KDECORE_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;

    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;

  protected:
    void readImmutability(const KConfigGroup &group);

    QString mGroup; 
    QString mKey; 
    QString mName; 

  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)
    {
    }

    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;
    }

    virtual void setDefault()
    {
      mReference = mDefault;
    }

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

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

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

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

class KDECORE_EXPORT KCoreConfigSkeleton : public QObject
{
  Q_OBJECT
public:
  class KDECORE_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);

    void readConfig(KConfig * config);

    void setProperty(const QVariant & p);

    bool isEqual(const QVariant &p) const;

    QVariant property() const;

  private:
    Type mType;
  };

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

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

    class KDECORE_EXPORT ItemUrl:public KConfigSkeletonGenericItem < KUrl >
    {
    public:

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

        void writeConfig(KConfig * config);

        void readConfig(KConfig * config);

        void setProperty(const QVariant & p);

    bool isEqual(const QVariant &p) const;

        QVariant property() const;
    };

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

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

    bool isEqual(const QVariant &p) const;

    QVariant property() const;
  };


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

    void readConfig(KConfig * config);

    void setProperty(const QVariant & p);

    bool isEqual(const QVariant &p) const;

    QVariant property() const;
  };


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

    void readConfig(KConfig * config);

    void setProperty(const QVariant & p);

    bool isEqual(const QVariant &p) const;

    QVariant property() const;

    QVariant minValue() const;

    QVariant maxValue() const;

    void setMinValue(qint32);

    void setMaxValue(qint32);

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

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

    void readConfig(KConfig * config);

    void setProperty(const QVariant & p);

    bool isEqual(const QVariant &p) const;

    QVariant property() const;

    QVariant minValue() const;

    QVariant maxValue() const;

    void setMinValue(qint64);

    void setMaxValue(qint64);

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

  class KDECORE_EXPORT ItemEnum:public ItemInt
  {
  public:
    //KDE5: remove the old Choice struct, rename Choice2 to Choice
    struct Choice
    {
      QString name;
      QString label;
      QString whatsThis;
    };

    struct Choice2
    {
      QString name;
      QString label;
      QString toolTip;
      QString whatsThis;
    };

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

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

    QList<Choice> choices() const;
    QList<Choice2> choices2() const;

    void readConfig(KConfig * config);

    void writeConfig(KConfig * config);

  private:
    QList<Choice2> mChoices;
  };


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

    void readConfig(KConfig * config);

    void setProperty(const QVariant & p);

    bool isEqual(const QVariant &p) const;

    QVariant property() const;

    QVariant minValue() const;

    QVariant maxValue() const;

    void setMinValue(quint32);

    void setMaxValue(quint32);

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

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

    void readConfig(KConfig * config);

    void setProperty(const QVariant & p);

    bool isEqual(const QVariant &p) const;

    QVariant property() const;

    QVariant minValue() const;

    QVariant maxValue() const;

    void setMinValue(quint64);

    void setMaxValue(quint64);

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

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

    void readConfig(KConfig * config);

    void setProperty(const QVariant & p);

    bool isEqual(const QVariant &p) const;

    QVariant property() const;

    QVariant minValue() const;

    QVariant maxValue() const;

    void setMinValue(double);

    void setMaxValue(double);

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


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

    void readConfig(KConfig * config);

    void setProperty(const QVariant & p);

    bool isEqual(const QVariant &p) const;

    QVariant property() const;
  };


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

    void readConfig(KConfig * config);

    void setProperty(const QVariant & p);

    bool isEqual(const QVariant &p) const;

    QVariant property() const;
  };


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

    void readConfig(KConfig * config);

    void setProperty(const QVariant & p);

    bool isEqual(const QVariant &p) const;

    QVariant property() const;
  };


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

    void readConfig(KConfig * config);

    void setProperty(const QVariant & p);

    bool isEqual(const QVariant &p) const;

    QVariant property() const;
  };


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

    void readConfig(KConfig * config);

    void setProperty(const QVariant & p);

    bool isEqual(const QVariant &p) const;

    QVariant property() const;
  };


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

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

    class KDECORE_EXPORT ItemUrlList:public KConfigSkeletonGenericItem < KUrl::List >
    {
    public:
        ItemUrlList(const QString & _group, const QString & _key,
                     KUrl::List & reference,
                     const KUrl::List & defaultValue = KUrl::List());

        void readConfig(KConfig * config);

        void writeConfig(KConfig * config);

        void setProperty(const QVariant & p);

    bool isEqual(const QVariant &p) const;

        QVariant property() const;
    };

  class KDECORE_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);

    void setProperty(const QVariant & p);

    bool isEqual(const QVariant &p) const;

    QVariant property() const;
  };


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

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

  virtual ~KCoreConfigSkeleton();

  virtual void setDefaults();

  virtual void readConfig();

  virtual void writeConfig();

  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
  KDE_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
  KDE_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;

  void setSharedConfig(KSharedConfig::Ptr pConfig);

  KConfigSkeletonItem::List items() const;

  // KDE5 TODO: Remove this non-const version. Kept only for BC.
  bool isImmutable(const QString & name);

  bool isImmutable(const QString & name) const;

  // KDE5 TODO: Remove this non-const version. Kept only for BC.
  KConfigSkeletonItem * findItem(const QString & name);

  KConfigSkeletonItem * findItem(const QString & name) const;

  virtual bool useDefaults(bool b);

Q_SIGNALS:
  void configChanged();

protected:
  virtual bool usrUseDefaults(bool b);

  virtual void usrSetDefaults();

  virtual void usrReadConfig();

  virtual void usrWriteConfig();

private:
  class Private;
  Private * const d;
  friend class KConfigSkeleton;

};

#endif