tdeconfigbase.h

/*
   This file is part of the KDE libraries
   Copyright (c) 1999 Preston Brown <pbrown@kde.org>
   Copyright (c) 1997 Matthias Kalle Dalheimer <kalle@kde.org>
   Copyright (c) 2001 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 _TDECONFIGBASE_H
#define _TDECONFIGBASE_H
 
#include <tqobject.h>
#include <tqcolor.h>
#include <tqfont.h>
#include <tqdatetime.h>
#include <tqstrlist.h>
#include <tqstringlist.h>
#include <tqvariant.h>
#include <tqmap.h>
 
#include "tdeconfigdata.h"
#include "tdelibs_export.h"
 
class TDEConfigBackEnd;
class TDEConfigBasePrivate;
class TDEConfigGroup;

class TDECORE_EXPORT TDEConfigBase : public TQObject
{
  TQ_OBJECT
  
 
  friend class TDEConfigBackEnd;
  friend class TDEConfigINIBackEnd;
  friend class TDEConfigGroup;
 
public:
  TDEConfigBase();

  virtual ~TDEConfigBase();

  void setGroup( const TQString& group );

  void setDesktopGroup();

  TQString group() const;

  bool hasGroup(const TQString &group) const;

  virtual TQStringList groupList() const = 0;

  TQString locale() const;

   TQString readEntry(const TQString& pKey,
                     const TQString& aDefault = TQString::null ) const;

   TQString readEntry(const char *pKey,
                     const TQString& aDefault = TQString::null ) const;

  TQVariant readPropertyEntry( const TQString& pKey, TQVariant::Type ) const;

  TQVariant readPropertyEntry( const char *pKey, TQVariant::Type ) const;

  TQVariant readPropertyEntry( const TQString& pKey,
                              const TQVariant &aDefault) const;

  TQVariant readPropertyEntry( const char *pKey,
                              const TQVariant &aDefault) const;

  int readListEntry( const TQString& pKey, TQStrList &list, char sep = ',' ) const;

  int readListEntry( const char *pKey, TQStrList &list, char sep = ',' ) const;

  TQStringList readListEntry( const TQString& pKey, char sep = ',' ) const;

  TQStringList readListEntry( const char *pKey, char sep = ',' ) const;

  TQStringList readListEntry( const char* pKey, const TQStringList& aDefault, 
          char sep = ',' ) const;

  TQValueList<int> readIntListEntry( const TQString& pKey ) const;

  TQValueList<int> readIntListEntry( const char *pKey ) const;

  TQString readPathEntry( const TQString& pKey, const TQString & aDefault = TQString::null ) const;

  TQString readPathEntry( const char *pKey, const TQString & aDefault = TQString::null ) const;

  TQStringList readPathListEntry( const TQString& pKey, char sep = ',' ) const;

  TQStringList readPathListEntry( const char *pKey, char sep = ',' ) const;
 

  int readNumEntry( const TQString& pKey, int nDefault = 0 ) const;

  int readNumEntry( const char *pKey, int nDefault = 0 ) const;

  unsigned int readUnsignedNumEntry( const TQString& pKey, unsigned int nDefault = 0 ) const;

  unsigned int readUnsignedNumEntry( const char *pKey, unsigned int nDefault = 0 ) const;
 

  long readLongNumEntry( const TQString& pKey, long nDefault = 0 ) const;

  long readLongNumEntry( const char *pKey, long nDefault = 0 ) const;

  unsigned long readUnsignedLongNumEntry( const TQString& pKey, unsigned long nDefault = 0 ) const;

  unsigned long readUnsignedLongNumEntry( const char *pKey, unsigned long nDefault = 0 ) const;

  TQ_INT64 readNum64Entry( const TQString& pKey, TQ_INT64 nDefault = 0 ) const;

  TQ_INT64 readNum64Entry( const char *pKey, TQ_INT64 nDefault = 0 ) const;

  TQ_UINT64 readUnsignedNum64Entry( const TQString& pKey, TQ_UINT64 nDefault = 0 ) const;

  TQ_UINT64 readUnsignedNum64Entry( const char *pKey, TQ_UINT64 nDefault = 0 ) const;

  double readDoubleNumEntry( const TQString& pKey, double nDefault = 0.0 ) const;

  double readDoubleNumEntry( const char *pKey, double nDefault = 0.0 ) const;

  TQFont readFontEntry( const TQString& pKey, const TQFont* pDefault = 0L ) const;

  TQFont readFontEntry( const char *pKey, const TQFont* pDefault = 0L ) const;

  bool readBoolEntry( const TQString& pKey, bool bDefault = false ) const;

  bool readBoolEntry( const char *pKey, bool bDefault = false ) const;

  TQRect readRectEntry( const TQString& pKey, const TQRect* pDefault = 0L ) const;

  TQRect readRectEntry( const char *pKey, const TQRect* pDefault = 0L ) const;

  TQPoint readPointEntry( const TQString& pKey, const TQPoint* pDefault = 0L ) const;

  TQPoint readPointEntry( const char *pKey, const TQPoint* pDefault = 0L ) const;

  TQSize readSizeEntry( const TQString& pKey, const TQSize* pDefault = 0L ) const;

  TQSize readSizeEntry( const char *pKey, const TQSize* pDefault = 0L ) const;
 

  TQColor readColorEntry( const TQString& pKey, const TQColor* pDefault = 0L ) const;

  TQColor readColorEntry( const char *pKey, const TQColor* pDefault = 0L ) const;

  TQDateTime readDateTimeEntry( const TQString& pKey, const TQDateTime* pDefault = 0L ) const;

  TQDateTime readDateTimeEntry( const char *pKey, const TQDateTime* pDefault = 0L ) const;

   TQString readEntryUntranslated( const TQString& pKey,
                     const TQString& aDefault = TQString::null ) const;

   TQString readEntryUntranslated( const char *pKey,
                     const TQString& aDefault = TQString::null ) const;

  void writeEntry( const TQString& pKey, const TQString& pValue,
                      bool bPersistent = true, bool bGlobal = false,
                      bool bNLS = false );

  void writeEntry( const char *pKey, const TQString& pValue,
                      bool bPersistent = true, bool bGlobal = false,
                      bool bNLS = false );

  void writeEntry( const TQString& pKey, const TQVariant& rValue,
                    bool bPersistent = true, bool bGlobal = false,
                    bool bNLS = false );
  void writeEntry( const char *pKey, const TQVariant& rValue,
                    bool bPersistent = true, bool bGlobal = false,
                    bool bNLS = false );

  void writeEntry( const TQString& pKey, const TQStrList &rValue,
           char sep = ',', bool bPersistent = true, bool bGlobal = false, bool bNLS = false );
  void writeEntry( const char *pKey, const TQStrList &rValue,
           char sep = ',', bool bPersistent = true, bool bGlobal = false, bool bNLS = false );

  void writeEntry( const TQString& pKey, const TQStringList &rValue,
           char sep = ',', bool bPersistent = true, bool bGlobal = false, bool bNLS = false );
  void writeEntry( const char *pKey, const TQStringList &rValue,
           char sep = ',', bool bPersistent = true, bool bGlobal = false, bool bNLS = false );
 

  void writeEntry( const TQString& pKey, const TQValueList<int>& rValue,
           bool bPersistent = true, bool bGlobal = false, bool bNLS = false );
  void writeEntry( const char *pKey, const TQValueList<int>& rValue,
           bool bPersistent = true, bool bGlobal = false, bool bNLS = false );

  void writeEntry( const TQString& pKey, const char *pValue,
                      bool bPersistent = true, bool bGlobal = false,
                      bool bNLS = false )
    { writeEntry(pKey, TQString::fromLatin1(pValue), bPersistent, bGlobal, bNLS); }

  void writeEntry( const char *pKey, const char *pValue,
                      bool bPersistent = true, bool bGlobal = false,
                      bool bNLS = false )
    { writeEntry(pKey, TQString::fromLatin1(pValue), bPersistent, bGlobal, bNLS); }

  void writeEntry( const TQString& pKey, int nValue,
                      bool bPersistent = true, bool bGlobal = false,
                      bool bNLS = false );
  void writeEntry( const char *pKey, int nValue,
                      bool bPersistent = true, bool bGlobal = false,
                      bool bNLS = false );

  void writeEntry( const TQString& pKey, unsigned int nValue,
                      bool bPersistent = true, bool bGlobal = false,
                      bool bNLS = false );
  void writeEntry( const char *pKey, unsigned int nValue,
                      bool bPersistent = true, bool bGlobal = false,
                      bool bNLS = false );

  void writeEntry( const TQString& pKey, long nValue,
                      bool bPersistent = true, bool bGlobal = false,
                      bool bNLS = false );
  void writeEntry( const char *pKey, long nValue,
                      bool bPersistent = true, bool bGlobal = false,
                      bool bNLS = false );

  void writeEntry( const TQString& pKey, unsigned long nValue,
                      bool bPersistent = true, bool bGlobal = false,
                      bool bNLS = false );
  void writeEntry( const char *pKey, unsigned long nValue,
                      bool bPersistent = true, bool bGlobal = false,
                      bool bNLS = false );

  void writeEntry( const TQString& pKey, TQ_INT64 nValue,
                      bool bPersistent = true, bool bGlobal = false,
                      bool bNLS = false );
  void writeEntry( const char *pKey, TQ_INT64 nValue,
                      bool bPersistent = true, bool bGlobal = false,
                      bool bNLS = false );

  void writeEntry( const TQString& pKey, TQ_UINT64 nValue,
                      bool bPersistent = true, bool bGlobal = false,
                      bool bNLS = false );
  void writeEntry( const char *pKey, TQ_UINT64 nValue,
                      bool bPersistent = true, bool bGlobal = false,
                      bool bNLS = false );

  void writeEntry( const TQString& pKey, double nValue,
                      bool bPersistent = true, bool bGlobal = false,
                      char format = 'g', int precision = 6,
                      bool bNLS = false );
  void writeEntry( const char *pKey, double nValue,
                      bool bPersistent = true, bool bGlobal = false,
                      char format = 'g', int precision = 6,
                      bool bNLS = false );

  void writeEntry( const TQString& pKey, bool bValue,
                      bool bPersistent = true, bool bGlobal = false,
                      bool bNLS = false );
  void writeEntry( const char *pKey, bool bValue,
                      bool bPersistent = true, bool bGlobal = false,
                      bool bNLS = false );

  void writeEntry( const TQString& pKey, const TQFont& rFont,
                      bool bPersistent = true, bool bGlobal = false,
                      bool bNLS = false );
  void writeEntry( const char *pKey, const TQFont& rFont,
                      bool bPersistent = true, bool bGlobal = false,
                      bool bNLS = false );

  void writeEntry( const TQString& pKey, const TQColor& rColor,
                   bool bPersistent = true, bool bGlobal = false,
                   bool bNLS = false );
  void writeEntry( const char *pKey, const TQColor& rColor,
                   bool bPersistent = true, bool bGlobal = false,
                   bool bNLS = false );

  void writeEntry( const TQString& pKey, const TQDateTime& rDateTime,
                   bool bPersistent = true, bool bGlobal = false,
                   bool bNLS = false );
  void writeEntry( const char *pKey, const TQDateTime& rDateTime,
                   bool bPersistent = true, bool bGlobal = false,
                   bool bNLS = false );
 

  void writeEntry( const TQString& pKey, const TQRect& rValue,
                   bool bPersistent = true, bool bGlobal = false,
                   bool bNLS = false );
  void writeEntry( const char *pKey, const TQRect& rValue,
                   bool bPersistent = true, bool bGlobal = false,
                   bool bNLS = false );

  void writeEntry( const TQString& pKey, const TQPoint& rValue,
                   bool bPersistent = true, bool bGlobal = false,
                   bool bNLS = false );
  void writeEntry( const char *pKey, const TQPoint& rValue,
                   bool bPersistent = true, bool bGlobal = false,
                   bool bNLS = false );

  void writeEntry( const TQString& pKey, const TQSize& rValue,
                   bool bPersistent = true, bool bGlobal = false,
                   bool bNLS = false );
  void writeEntry( const char *pKey, const TQSize& rValue,
                   bool bPersistent = true, bool bGlobal = false,
                   bool bNLS = false );

  void writePathEntry( const TQString& pKey, const TQString & path,
                       bool bPersistent = true, bool bGlobal = false,
                       bool bNLS = false );
  void writePathEntry( const char *pKey, const TQString & path,
                       bool bPersistent = true, bool bGlobal = false,
                       bool bNLS = false );

  void writePathEntry( const char *pKey, const TQString & path,
                       bool bPersistent, bool bGlobal,
                       bool bNLS, bool expand );

  void writePathEntry( const TQString& pKey, const TQStringList &rValue,
           char sep = ',', bool bPersistent = true, bool bGlobal = false, bool bNLS = false );
  void writePathEntry( const char *pKey, const TQStringList &rValue,
           char sep = ',', bool bPersistent = true, bool bGlobal = false, bool bNLS = false );
 

   void deleteEntry( const TQString& pKey,
                   bool bNLS = false, bool bGlobal = false);
   void deleteEntry( const char *pKey,
                   bool bNLS = false, bool bGlobal = false);

  bool deleteGroup( const TQString& group, bool bDeep = true, bool bGlobal = false );
 

  void setDollarExpansion( bool _bExpand = true ) { bExpand = _bExpand; }

  bool isDollarExpansion() const { return bExpand; }

  virtual void rollback( bool bDeep = true );

  virtual void sync();

  bool isDirty() const { return bDirty; }

  virtual void setReadOnly(bool _ro) { bReadOnly = _ro; }

  bool isReadOnly() const { return bReadOnly; }

  bool hasKey( const TQString& key ) const;

  virtual TQMap<TQString, TQString> entryMap(const TQString &group) const = 0;

  virtual void reparseConfiguration() = 0;

  bool isImmutable() const;

  bool groupIsImmutable(const TQString &group) const;

  bool entryIsImmutable(const TQString &key) const;

  enum ConfigState { NoAccess, ReadOnly, ReadWrite };

  ConfigState getConfigState() const;

  bool checkConfigFilesWritable(bool warnUser);

  void setReadDefaults(bool b);

  bool readDefaults() const;

  void revertToDefault(const TQString &key);

  bool hasDefault(const TQString &key) const;
 
protected:
  void setLocale();

  virtual void setDirty(bool _bDirty = true) { bDirty = _bDirty; }

  virtual void parseConfigFiles();

  virtual KEntryMap internalEntryMap( const TQString& pGroup ) const = 0;

  virtual KEntryMap internalEntryMap() const = 0;

  virtual void putData(const KEntryKey &_key, const KEntry &_data, bool _checkGroup = true) = 0;

  virtual KEntry lookupData(const KEntryKey &_key) const = 0;
 
  virtual bool internalHasGroup(const TQCString &group) const = 0;

  TDEConfigBackEnd *backEnd;
public:
  void setGroup( const TQCString &pGroup );
  void setGroup( const char *pGroup );
  bool hasGroup(const TQCString &_pGroup) const;
  bool hasGroup(const char *_pGroup) const;
  bool hasKey( const char *pKey ) const;
 
protected:
  TQCString readEntryUtf8( const char *pKey) const;
  bool hasTranslatedKey( const char *pKey ) const;

  TQCString mGroup;

  TQCString aLocaleString;

  bool bDirty;
 
  bool bLocaleInitialized;
  bool bReadOnly;           // currently only used by KSimpleConfig
  mutable bool bExpand;     // whether dollar expansion is used
 
protected:
  virtual void virtual_hook( int id, void* data );
private:
  class TDEConfigBasePrivate;
  TDEConfigBasePrivate *d;
 
  void writeEntry( const char *pKey, const TQString &rValue,
    bool bPersistent, bool bGlobal, bool bNLS, bool bExpand );
  void writeEntry( const char *pKey, const TQStringList &rValue,
    char sep, bool bPersistent, bool bGlobal, bool bNLS, bool bExpand );
 
};
 
class TDEConfigGroupSaverPrivate;

 
class TDECORE_EXPORT TDEConfigGroupSaver // KDE4 remove
{
public:
  TDEConfigGroupSaver( TDEConfigBase* config, TQString group )
      /* KDE 4 : make the second parameter const TQString & */
      : _config(config), _oldgroup(config->group())
        { _config->setGroup( group ); }
 
  TDEConfigGroupSaver( TDEConfigBase* config, const char *group )
      : _config(config), _oldgroup(config->group())
        { _config->setGroup( group ); }
 
  TDEConfigGroupSaver( TDEConfigBase* config, const TQCString &group )
      : _config(config), _oldgroup(config->group())
        { _config->setGroup( group ); }
 
  ~TDEConfigGroupSaver() { _config->setGroup( _oldgroup ); }
 
    TDEConfigBase* config() { return _config; };
 
private:
  TDEConfigBase* _config;
  TQString _oldgroup;
 
  TDEConfigGroupSaver(const TDEConfigGroupSaver&);
  TDEConfigGroupSaver& operator=(const TDEConfigGroupSaver&);
 
  TDEConfigGroupSaverPrivate *d;
};
 
class TDEConfigGroupPrivate;

class TDECORE_EXPORT TDEConfigGroup: public TDEConfigBase
{
public:
   TDEConfigGroup(TDEConfigBase *master, const TQCString &group);
   TDEConfigGroup(TDEConfigBase *master, const TQString &group);
   TDEConfigGroup(TDEConfigBase *master, const char * group);

   void deleteGroup(bool bGlobal = false);

  bool groupIsImmutable() const;
 
   // The following functions are reimplemented:
   virtual void setDirty(bool _bDirty);
   virtual void putData(const KEntryKey &_key, const KEntry &_data, bool _checkGroup = true);
   virtual KEntry lookupData(const KEntryKey &_key) const;
   virtual void sync();
 
private:
   // Hide the following members:
   void setGroup() { }
   void setDesktopGroup() { }
   void group() { }
   void hasGroup() { }
   void setReadOnly(bool) { }
   void isDirty() { }
 
   // The following members are not used.
   virtual TQStringList groupList() const { return TQStringList(); }
   virtual void rollback(bool) { }
   virtual void reparseConfiguration() { }
   virtual TQMap<TQString, TQString> entryMap(const TQString &) const
    { return TQMap<TQString,TQString>(); }
   virtual KEntryMap internalEntryMap( const TQString&) const
    { return KEntryMap(); }
   virtual KEntryMap internalEntryMap() const
    { return KEntryMap(); }
   virtual bool internalHasGroup(const TQCString &) const
    { return false; }
 
   void getConfigState() { }
 
   TDEConfigBase *mMaster;
protected:
   virtual void virtual_hook( int id, void* data );
private:
   TDEConfigGroupPrivate* d;
};
 
#endif