Copy the KDE 3.5 branch to branches/trinity for new KDE 3.5 features.

BUG:215923


git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/kdelibs@1054174 283d02a7-25f6-0310-bc7c-ecb5cbfe19da

1 files changed, 1869 insertions, 0 deletions

diff --git a/kdecore/kconfigbase.cpp b/kdecore/kconfigbase.cpp
new file mode 100644
index 000000000..05156e969
--- /dev/null
+++ b/kdecore/kconfigbase.cpp
@@ -0,0 +1,1869 @@
+// -*- c-basic-offset: 2 -*-
+/*
+   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>
+
+   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.
+*/
+
+#include <stdlib.h>
+#include <string.h>
+
+#include <qfile.h>
+#include <qdir.h>
+#include <qtextstream.h>
+
+#include <kapplication.h>
+#include <kglobal.h>
+#include <klocale.h>
+#include <kcharsets.h>
+
+#include "kconfigbase.h"
+#include "kconfigbackend.h"
+#include "kdebug.h"
+#include "kstandarddirs.h"
+#include "kstringhandler.h"
+
+class KConfigBase::KConfigBasePrivate
+{
+public:
+     KConfigBasePrivate() : readDefaults(false) { };
+
+public:
+     bool readDefaults;
+};
+
+KConfigBase::KConfigBase()
+  : backEnd(0L), bDirty(false), bLocaleInitialized(false),
+    bReadOnly(false), bExpand(false), d(0)
+{
+    setGroup(QString::null);
+}
+
+KConfigBase::~KConfigBase()
+{
+    delete d;
+}
+
+void KConfigBase::setLocale()
+{
+  bLocaleInitialized = true;
+
+  if (KGlobal::locale())
+    aLocaleString = KGlobal::locale()->language().utf8();
+  else
+    aLocaleString = KLocale::defaultLanguage().utf8();
+  if (backEnd)
+     backEnd->setLocaleString(aLocaleString);
+}
+
+QString KConfigBase::locale() const
+{
+  return QString::fromUtf8(aLocaleString);
+}
+
+void KConfigBase::setGroup( const QString& group )
+{
+  if ( group.isEmpty() )
+    mGroup = "<default>";
+  else
+    mGroup = group.utf8();
+}
+
+void KConfigBase::setGroup( const char *pGroup )
+{
+  setGroup(QCString(pGroup));
+}
+
+void KConfigBase::setGroup( const QCString &group )
+{
+  if ( group.isEmpty() )
+    mGroup = "<default>";
+  else
+    mGroup = group;
+}
+
+QString KConfigBase::group() const {
+  return QString::fromUtf8(mGroup);
+}
+
+void KConfigBase::setDesktopGroup()
+{
+  mGroup = "Desktop Entry";
+}
+
+bool KConfigBase::hasKey(const QString &key) const
+{
+   return hasKey(key.utf8().data());
+}
+
+bool KConfigBase::hasKey(const char *pKey) const
+{
+  KEntryKey aEntryKey(mGroup, 0);
+  aEntryKey.c_key = pKey;
+  aEntryKey.bDefault = readDefaults();
+
+  if (!locale().isNull()) {
+    // try the localized key first
+    aEntryKey.bLocal = true;
+    KEntry entry = lookupData(aEntryKey);
+    if (!entry.mValue.isNull())
+       return true;
+    aEntryKey.bLocal = false;
+  }
+
+  // try the non-localized version
+  KEntry entry = lookupData(aEntryKey);
+  return !entry.mValue.isNull();
+}
+
+bool KConfigBase::hasGroup(const QString &group) const
+{
+  return internalHasGroup( group.utf8());
+}
+
+bool KConfigBase::hasGroup(const char *_pGroup) const
+{
+  return internalHasGroup( QCString(_pGroup));
+}
+
+bool KConfigBase::hasGroup(const QCString &_pGroup) const
+{
+  return internalHasGroup( _pGroup);
+}
+
+bool KConfigBase::isImmutable() const
+{
+  return (getConfigState() != ReadWrite);
+}
+
+bool KConfigBase::groupIsImmutable(const QString &group) const
+{
+  if (getConfigState() != ReadWrite)
+     return true;
+
+  KEntryKey groupKey(group.utf8(), 0);
+  KEntry entry = lookupData(groupKey);
+  return entry.bImmutable;
+}
+
+bool KConfigBase::entryIsImmutable(const QString &key) const
+{
+  if (getConfigState() != ReadWrite)
+     return true;
+
+  KEntryKey entryKey(mGroup, 0);
+  KEntry aEntryData = lookupData(entryKey); // Group
+  if (aEntryData.bImmutable)
+    return true;
+
+  QCString utf8_key = key.utf8();
+  entryKey.c_key = utf8_key.data();
+  aEntryData = lookupData(entryKey); // Normal entry
+  if (aEntryData.bImmutable)
+    return true;
+
+  entryKey.bLocal = true;
+  aEntryData = lookupData(entryKey); // Localized entry
+  return aEntryData.bImmutable;
+}
+
+
+QString KConfigBase::readEntryUntranslated( const QString& pKey,
+                                const QString& aDefault ) const
+{
+   return KConfigBase::readEntryUntranslated(pKey.utf8().data(), aDefault);
+}
+
+
+QString KConfigBase::readEntryUntranslated( const char *pKey,
+                                const QString& aDefault ) const
+{
+   QCString result = readEntryUtf8(pKey);
+   if (result.isNull())
+      return aDefault;
+   return QString::fromUtf8(result);
+}
+
+
+QString KConfigBase::readEntry( const QString& pKey,
+                                const QString& aDefault ) const
+{
+   return KConfigBase::readEntry(pKey.utf8().data(), aDefault);
+}
+
+QString KConfigBase::readEntry( const char *pKey,
+                                const QString& aDefault ) const
+{
+  // we need to access _locale instead of the method locale()
+  // because calling locale() will create a locale object if it
+  // doesn't exist, which requires KConfig, which will create a infinite
+  // loop, and nobody likes those.
+  if (!bLocaleInitialized && KGlobal::_locale) {
+    // get around const'ness.
+    KConfigBase *that = const_cast<KConfigBase *>(this);
+    that->setLocale();
+  }
+
+  QString aValue;
+
+  bool expand = false;
+  // construct a localized version of the key
+  // try the localized key first
+  KEntry aEntryData;
+  KEntryKey entryKey(mGroup, 0);
+  entryKey.c_key = pKey;
+  entryKey.bDefault = readDefaults();
+  entryKey.bLocal = true;
+  aEntryData = lookupData(entryKey);
+  if (!aEntryData.mValue.isNull()) {
+    // for GNOME .desktop
+    aValue = KStringHandler::from8Bit( aEntryData.mValue.data() );
+    expand = aEntryData.bExpand;
+  } else {
+    entryKey.bLocal = false;
+    aEntryData = lookupData(entryKey);
+    if (!aEntryData.mValue.isNull()) {
+      aValue = QString::fromUtf8(aEntryData.mValue.data());
+      if (aValue.isNull())
+      {
+        static const QString &emptyString = KGlobal::staticQString("");
+        aValue = emptyString;
+      }
+      expand = aEntryData.bExpand;
+    } else {
+      aValue = aDefault;
+    }
+  }
+
+  // only do dollar expansion if so desired
+  if( expand || bExpand )
+    {
+      // check for environment variables and make necessary translations
+      int nDollarPos = aValue.find( '$' );
+
+      while( nDollarPos != -1 && nDollarPos+1 < static_cast<int>(aValue.length())) {
+        // there is at least one $
+        if( (aValue)[nDollarPos+1] == '(' ) {
+          uint nEndPos = nDollarPos+1;
+          // the next character is no $
+          while ( (nEndPos <= aValue.length()) && (aValue[nEndPos]!=')') )
+              nEndPos++;
+          nEndPos++;
+          QString cmd = aValue.mid( nDollarPos+2, nEndPos-nDollarPos-3 );
+
+          QString result;
+          FILE *fs = popen(QFile::encodeName(cmd).data(), "r");
+          if (fs)
+          {
+             {
+             QTextStream ts(fs, IO_ReadOnly);
+             result = ts.read().stripWhiteSpace();
+             }
+             pclose(fs);
+          }
+          aValue.replace( nDollarPos, nEndPos-nDollarPos, result );
+        } else if( (aValue)[nDollarPos+1] != '$' ) {
+          uint nEndPos = nDollarPos+1;
+          // the next character is no $
+          QString aVarName;
+          if (aValue[nEndPos]=='{')
+          {
+            while ( (nEndPos <= aValue.length()) && (aValue[nEndPos]!='}') )
+                nEndPos++;
+            nEndPos++;
+            aVarName = aValue.mid( nDollarPos+2, nEndPos-nDollarPos-3 );
+          }
+          else
+          {
+            while ( nEndPos <= aValue.length() && (aValue[nEndPos].isNumber()
+                    || aValue[nEndPos].isLetter() || aValue[nEndPos]=='_' )  )
+                nEndPos++;
+            aVarName = aValue.mid( nDollarPos+1, nEndPos-nDollarPos-1 );
+          }
+          const char* pEnv = 0;
+          if (!aVarName.isEmpty())
+               pEnv = getenv( aVarName.ascii() );
+          if( pEnv ) {
+	    // !!! Sergey A. Sukiyazov <corwin@micom.don.ru> !!!
+	    // A environment variables may contain values in 8bit
+	    // locale cpecified encoding or in UTF8 encoding.
+	    aValue.replace( nDollarPos, nEndPos-nDollarPos, KStringHandler::from8Bit( pEnv ) );
+          } else
+            aValue.remove( nDollarPos, nEndPos-nDollarPos );
+        } else {
+          // remove one of the dollar signs
+          aValue.remove( nDollarPos, 1 );
+          nDollarPos++;
+        }
+        nDollarPos = aValue.find( '$', nDollarPos );
+      }
+    }
+
+  return aValue;
+}
+
+QCString KConfigBase::readEntryUtf8( const char *pKey) const
+{
+  // We don't try the localized key
+  KEntryKey entryKey(mGroup, 0);
+  entryKey.bDefault = readDefaults();
+  entryKey.c_key = pKey;
+  KEntry aEntryData = lookupData(entryKey);
+  if (aEntryData.bExpand)
+  {
+     // We need to do fancy, take the slow route.
+     return readEntry(pKey, QString::null).utf8();
+  }
+  return aEntryData.mValue;
+}
+
+QVariant KConfigBase::readPropertyEntry( const QString& pKey,
+                                          QVariant::Type type ) const
+{
+  return readPropertyEntry(pKey.utf8().data(), type);
+}
+
+QVariant KConfigBase::readPropertyEntry( const char *pKey,
+                                          QVariant::Type type ) const
+{
+  QVariant va;
+  if ( !hasKey( pKey ) ) return va;
+  (void)va.cast(type);
+  return readPropertyEntry(pKey, va);
+}
+
+QVariant KConfigBase::readPropertyEntry( const QString& pKey,
+                                         const QVariant &aDefault ) const
+{
+  return readPropertyEntry(pKey.utf8().data(), aDefault);
+}
+
+QVariant KConfigBase::readPropertyEntry( const char *pKey,
+                                         const QVariant &aDefault ) const
+{
+  if ( !hasKey( pKey ) ) return aDefault;
+
+  QVariant tmp = aDefault;
+
+  switch( aDefault.type() )
+  {
+      case QVariant::Invalid:
+          return QVariant();
+      case QVariant::String:
+          return QVariant( readEntry( pKey, aDefault.toString() ) );
+      case QVariant::StringList:
+          return QVariant( readListEntry( pKey ) );
+      case QVariant::List: {
+          QStringList strList = readListEntry( pKey );
+          QStringList::ConstIterator it = strList.begin();
+          QStringList::ConstIterator end = strList.end();
+          QValueList<QVariant> list;
+
+          for (; it != end; ++it ) {
+              tmp = *it;
+              list.append( tmp );
+          }
+          return QVariant( list );
+      }
+      case QVariant::Font:
+          return QVariant( readFontEntry( pKey, &tmp.asFont() ) );
+      case QVariant::Point:
+          return QVariant( readPointEntry( pKey, &tmp.asPoint() ) );
+      case QVariant::Rect:
+          return QVariant( readRectEntry( pKey, &tmp.asRect() ) );
+      case QVariant::Size:
+          return QVariant( readSizeEntry( pKey, &tmp.asSize() ) );
+      case QVariant::Color:
+          return QVariant( readColorEntry( pKey, &tmp.asColor() ) );
+      case QVariant::Int:
+          return QVariant( readNumEntry( pKey, aDefault.toInt() ) );
+      case QVariant::UInt:
+          return QVariant( readUnsignedNumEntry( pKey, aDefault.toUInt() ) );
+      case QVariant::LongLong:
+          return QVariant( readNum64Entry( pKey, aDefault.toLongLong() ) );
+      case QVariant::ULongLong:
+          return QVariant( readUnsignedNum64Entry( pKey, aDefault.toULongLong() ) );
+      case QVariant::Bool:
+          return QVariant( readBoolEntry( pKey, aDefault.toBool() ), 0 );
+      case QVariant::Double:
+          return QVariant( readDoubleNumEntry( pKey, aDefault.toDouble() ) );
+      case QVariant::DateTime:
+          return QVariant( readDateTimeEntry( pKey, &tmp.asDateTime() ) );
+      case QVariant::Date:
+          return QVariant(readDateTimeEntry( pKey, &tmp.asDateTime() ).date());
+
+      case QVariant::Pixmap:
+      case QVariant::Image:
+      case QVariant::Brush:
+      case QVariant::Palette:
+      case QVariant::ColorGroup:
+      case QVariant::Map:
+      case QVariant::IconSet:
+      case QVariant::CString:
+      case QVariant::PointArray:
+      case QVariant::Region:
+      case QVariant::Bitmap:
+      case QVariant::Cursor:
+      case QVariant::SizePolicy:
+      case QVariant::Time:
+      case QVariant::ByteArray:
+      case QVariant::BitArray:
+      case QVariant::KeySequence:
+      case QVariant::Pen:
+          break;
+  }
+
+  Q_ASSERT( 0 );
+  return QVariant();
+}
+
+int KConfigBase::readListEntry( const QString& pKey,
+                                QStrList &list, char sep ) const
+{
+  return readListEntry(pKey.utf8().data(), list, sep);
+}
+
+int KConfigBase::readListEntry( const char *pKey,
+                                QStrList &list, char sep ) const
+{
+  if( !hasKey( pKey ) )
+    return 0;
+
+  QCString str_list = readEntryUtf8( pKey );
+  if (str_list.isEmpty())
+    return 0;
+
+  list.clear();
+  QCString value = "";
+  int len = str_list.length();
+
+  for (int i = 0; i < len; i++) {
+    if (str_list[i] != sep && str_list[i] != '\\') {
+      value += str_list[i];
+      continue;
+    }
+    if (str_list[i] == '\\') {
+      i++;
+      if ( i < len )
+        value += str_list[i];
+      continue;
+    }
+    // if we fell through to here, we are at a separator.  Append
+    // contents of value to the list
+    // !!! Sergey A. Sukiyazov <corwin@micom.don.ru> !!!
+    // A QStrList may contain values in 8bit locale cpecified
+    // encoding
+    list.append( value );
+    value.truncate(0);
+  }
+
+  if ( str_list[len-1] != sep || ( len > 1 && str_list[len-2] == '\\' ) )
+    list.append( value );
+  return list.count();
+}
+
+QStringList KConfigBase::readListEntry( const QString& pKey, char sep ) const
+{
+  return readListEntry(pKey.utf8().data(), sep);
+}
+
+QStringList KConfigBase::readListEntry( const char *pKey, char sep ) const
+{
+  static const QString& emptyString = KGlobal::staticQString("");
+
+  QStringList list;
+  if( !hasKey( pKey ) )
+    return list;
+  QString str_list = readEntry( pKey );
+  if( str_list.isEmpty() )
+    return list;
+  QString value(emptyString);
+  int len = str_list.length();
+ // obviously too big, but faster than letting each += resize the string.
+  value.reserve( len );
+  for( int i = 0; i < len; i++ )
+    {
+      if( str_list[i] != sep && str_list[i] != '\\' )
+        {
+          value += str_list[i];
+          continue;
+        }
+      if( str_list[i] == '\\' )
+        {
+          i++;
+          if ( i < len )
+            value += str_list[i];
+          continue;
+        }
+      QString finalvalue( value );
+      finalvalue.squeeze();
+      list.append( finalvalue );
+      value.truncate( 0 );
+    }
+  if ( str_list[len-1] != sep || ( len > 1 && str_list[len-2] == '\\' ) )
+  {
+    value.squeeze();
+    list.append( value );
+  }
+  return list;
+}
+
+QStringList KConfigBase::readListEntry( const char* pKey, const QStringList& aDefault,
+		char sep ) const
+{
+	if ( !hasKey( pKey ) )
+		return aDefault;
+	else
+		return readListEntry( pKey, sep );
+}
+
+QValueList<int> KConfigBase::readIntListEntry( const QString& pKey ) const
+{
+  return readIntListEntry(pKey.utf8().data());
+}
+
+QValueList<int> KConfigBase::readIntListEntry( const char *pKey ) const
+{
+  QStringList strlist = readListEntry(pKey);
+  QValueList<int> list;
+  QStringList::ConstIterator end(strlist.end());
+  for (QStringList::ConstIterator it = strlist.begin(); it != end; ++it)
+    // I do not check if the toInt failed because I consider the number of items
+    // more important than their value
+    list << (*it).toInt();
+
+  return list;
+}
+
+QString KConfigBase::readPathEntry( const QString& pKey, const QString& pDefault ) const
+{
+  return readPathEntry(pKey.utf8().data(), pDefault);
+}
+
+QString KConfigBase::readPathEntry( const char *pKey, const QString& pDefault ) const
+{
+  const bool bExpandSave = bExpand;
+  bExpand = true;
+  QString aValue = readEntry( pKey, pDefault );
+  bExpand = bExpandSave;
+  return aValue;
+}
+
+QStringList KConfigBase::readPathListEntry( const QString& pKey, char sep ) const
+{
+  return readPathListEntry(pKey.utf8().data(), sep);
+}
+
+QStringList KConfigBase::readPathListEntry( const char *pKey, char sep ) const
+{
+  const bool bExpandSave = bExpand;
+  bExpand = true;
+  QStringList aValue = readListEntry( pKey, sep );
+  bExpand = bExpandSave;
+  return aValue;
+}
+
+int KConfigBase::readNumEntry( const QString& pKey, int nDefault) const
+{
+  return readNumEntry(pKey.utf8().data(), nDefault);
+}
+
+int KConfigBase::readNumEntry( const char *pKey, int nDefault) const
+{
+  QCString aValue = readEntryUtf8( pKey );
+  if( aValue.isNull() )
+    return nDefault;
+  else if( aValue == "true" || aValue == "on" || aValue == "yes" )
+    return 1;
+  else
+    {
+      bool ok;
+      int rc = aValue.toInt( &ok );
+      return( ok ? rc : nDefault );
+    }
+}
+
+
+unsigned int KConfigBase::readUnsignedNumEntry( const QString& pKey, unsigned int nDefault) const
+{
+  return readUnsignedNumEntry(pKey.utf8().data(), nDefault);
+}
+
+unsigned int KConfigBase::readUnsignedNumEntry( const char *pKey, unsigned int nDefault) const
+{
+  QCString aValue = readEntryUtf8( pKey );
+  if( aValue.isNull() )
+    return nDefault;
+  else
+    {
+      bool ok;
+      unsigned int rc = aValue.toUInt( &ok );
+      return( ok ? rc : nDefault );
+    }
+}
+
+
+long KConfigBase::readLongNumEntry( const QString& pKey, long nDefault) const
+{
+  return readLongNumEntry(pKey.utf8().data(), nDefault);
+}
+
+long KConfigBase::readLongNumEntry( const char *pKey, long nDefault) const
+{
+  QCString aValue = readEntryUtf8( pKey );
+  if( aValue.isNull() )
+    return nDefault;
+  else
+    {
+      bool ok;
+      long rc = aValue.toLong( &ok );
+      return( ok ? rc : nDefault );
+    }
+}
+
+
+unsigned long KConfigBase::readUnsignedLongNumEntry( const QString& pKey, unsigned long nDefault) const
+{
+  return readUnsignedLongNumEntry(pKey.utf8().data(), nDefault);
+}
+
+unsigned long KConfigBase::readUnsignedLongNumEntry( const char *pKey, unsigned long nDefault) const
+{
+  QCString aValue = readEntryUtf8( pKey );
+  if( aValue.isNull() )
+    return nDefault;
+  else
+    {
+      bool ok;
+      unsigned long rc = aValue.toULong( &ok );
+      return( ok ? rc : nDefault );
+    }
+}
+
+Q_INT64 KConfigBase::readNum64Entry( const QString& pKey, Q_INT64 nDefault) const
+{
+  return readNum64Entry(pKey.utf8().data(), nDefault);
+}
+
+Q_INT64 KConfigBase::readNum64Entry( const char *pKey, Q_INT64 nDefault) const
+{
+  // Note that QCString::toLongLong() is missing, we muse use a QString instead.
+  QString aValue = readEntry( pKey );
+  if( aValue.isNull() )
+    return nDefault;
+  else
+    {
+      bool ok;
+      Q_INT64 rc = aValue.toLongLong( &ok );
+      return( ok ? rc : nDefault );
+    }
+}
+
+
+Q_UINT64 KConfigBase::readUnsignedNum64Entry( const QString& pKey, Q_UINT64 nDefault) const
+{
+  return readUnsignedNum64Entry(pKey.utf8().data(), nDefault);
+}
+
+Q_UINT64 KConfigBase::readUnsignedNum64Entry( const char *pKey, Q_UINT64 nDefault) const
+{
+  // Note that QCString::toULongLong() is missing, we muse use a QString instead.
+  QString aValue = readEntry( pKey );
+  if( aValue.isNull() )
+    return nDefault;
+  else
+    {
+      bool ok;
+      Q_UINT64 rc = aValue.toULongLong( &ok );
+      return( ok ? rc : nDefault );
+    }
+}
+
+double KConfigBase::readDoubleNumEntry( const QString& pKey, double nDefault) const
+{
+  return readDoubleNumEntry(pKey.utf8().data(), nDefault);
+}
+
+double KConfigBase::readDoubleNumEntry( const char *pKey, double nDefault) const
+{
+  QCString aValue = readEntryUtf8( pKey );
+  if( aValue.isNull() )
+    return nDefault;
+  else
+    {
+      bool ok;
+      double rc = aValue.toDouble( &ok );
+      return( ok ? rc : nDefault );
+    }
+}
+
+
+bool KConfigBase::readBoolEntry( const QString& pKey, bool bDefault ) const
+{
+   return readBoolEntry(pKey.utf8().data(), bDefault);
+}
+
+bool KConfigBase::readBoolEntry( const char *pKey, bool bDefault ) const
+{
+  QCString aValue = readEntryUtf8( pKey );
+
+  if( aValue.isNull() )
+    return bDefault;
+  else
+    {
+      if( aValue == "true" || aValue == "on" || aValue == "yes" || aValue == "1" )
+        return true;
+      else
+        {
+          bool bOK;
+          int val = aValue.toInt( &bOK );
+          if( bOK && val != 0 )
+            return true;
+          else
+            return false;
+        }
+    }
+}
+
+QFont KConfigBase::readFontEntry( const QString& pKey, const QFont* pDefault ) const
+{
+  return readFontEntry(pKey.utf8().data(), pDefault);
+}
+
+QFont KConfigBase::readFontEntry( const char *pKey, const QFont* pDefault ) const
+{
+  QFont aRetFont;
+
+  QString aValue = readEntry( pKey );
+  if( !aValue.isNull() ) {
+    if ( aValue.contains( ',' ) > 5 ) {
+      // KDE3 and upwards entry
+      if ( !aRetFont.fromString( aValue ) && pDefault )
+        aRetFont = *pDefault;
+    }
+    else {
+      // backward compatibility with older font formats
+      // ### remove KDE 3.1 ?
+      // find first part (font family)
+      int nIndex = aValue.find( ',' );
+      if( nIndex == -1 ){
+        if( pDefault )
+          aRetFont = *pDefault;
+        return aRetFont;
+      }
+      aRetFont.setFamily( aValue.left( nIndex ) );
+
+      // find second part (point size)
+      int nOldIndex = nIndex;
+      nIndex = aValue.find( ',', nOldIndex+1 );
+      if( nIndex == -1 ){
+        if( pDefault )
+          aRetFont = *pDefault;
+        return aRetFont;
+      }
+
+      aRetFont.setPointSize( aValue.mid( nOldIndex+1,
+                                         nIndex-nOldIndex-1 ).toInt() );
+
+      // find third part (style hint)
+      nOldIndex = nIndex;
+      nIndex = aValue.find( ',', nOldIndex+1 );
+
+      if( nIndex == -1 ){
+        if( pDefault )
+          aRetFont = *pDefault;
+        return aRetFont;
+      }
+
+      aRetFont.setStyleHint( (QFont::StyleHint)aValue.mid( nOldIndex+1, nIndex-nOldIndex-1 ).toUInt() );
+
+      // find fourth part (char set)
+      nOldIndex = nIndex;
+      nIndex = aValue.find( ',', nOldIndex+1 );
+
+      if( nIndex == -1 ){
+        if( pDefault )
+          aRetFont = *pDefault;
+        return aRetFont;
+      }
+
+      QString chStr=aValue.mid( nOldIndex+1,
+                                nIndex-nOldIndex-1 );
+      // find fifth part (weight)
+      nOldIndex = nIndex;
+      nIndex = aValue.find( ',', nOldIndex+1 );
+
+      if( nIndex == -1 ){
+        if( pDefault )
+          aRetFont = *pDefault;
+        return aRetFont;
+      }
+
+      aRetFont.setWeight( aValue.mid( nOldIndex+1,
+                                      nIndex-nOldIndex-1 ).toUInt() );
+
+      // find sixth part (font bits)
+      uint nFontBits = aValue.right( aValue.length()-nIndex-1 ).toUInt();
+
+      aRetFont.setItalic( nFontBits & 0x01 );
+      aRetFont.setUnderline( nFontBits & 0x02 );
+      aRetFont.setStrikeOut( nFontBits & 0x04 );
+      aRetFont.setFixedPitch( nFontBits & 0x08 );
+      aRetFont.setRawMode( nFontBits & 0x20 );
+    }
+  }
+  else
+    {
+      if( pDefault )
+        aRetFont = *pDefault;
+    }
+
+  return aRetFont;
+}
+
+
+QRect KConfigBase::readRectEntry( const QString& pKey, const QRect* pDefault ) const
+{
+  return readRectEntry(pKey.utf8().data(), pDefault);
+}
+
+QRect KConfigBase::readRectEntry( const char *pKey, const QRect* pDefault ) const
+{
+  QCString aValue = readEntryUtf8(pKey);
+
+  if (!aValue.isEmpty())
+  {
+    int left, top, width, height;
+
+    if (sscanf(aValue.data(), "%d,%d,%d,%d", &left, &top, &width, &height) == 4)
+    {
+       return QRect(left, top, width, height);
+    }
+  }
+  if (pDefault)
+    return *pDefault;
+  return QRect();
+}
+
+
+QPoint KConfigBase::readPointEntry( const QString& pKey,
+                                    const QPoint* pDefault ) const
+{
+  return readPointEntry(pKey.utf8().data(), pDefault);
+}
+
+QPoint KConfigBase::readPointEntry( const char *pKey,
+                                    const QPoint* pDefault ) const
+{
+  QCString aValue = readEntryUtf8(pKey);
+
+  if (!aValue.isEmpty())
+  {
+    int x,y;
+
+    if (sscanf(aValue.data(), "%d,%d", &x, &y) == 2)
+    {
+       return QPoint(x,y);
+    }
+  }
+  if (pDefault)
+    return *pDefault;
+  return QPoint();
+}
+
+QSize KConfigBase::readSizeEntry( const QString& pKey,
+                                  const QSize* pDefault ) const
+{
+  return readSizeEntry(pKey.utf8().data(), pDefault);
+}
+
+QSize KConfigBase::readSizeEntry( const char *pKey,
+                                  const QSize* pDefault ) const
+{
+  QCString aValue = readEntryUtf8(pKey);
+
+  if (!aValue.isEmpty())
+  {
+    int width,height;
+
+    if (sscanf(aValue.data(), "%d,%d", &width, &height) == 2)
+    {
+       return QSize(width, height);
+    }
+  }
+  if (pDefault)
+    return *pDefault;
+  return QSize();
+}
+
+
+QColor KConfigBase::readColorEntry( const QString& pKey,
+                                    const QColor* pDefault ) const
+{
+  return readColorEntry(pKey.utf8().data(), pDefault);
+}
+
+QColor KConfigBase::readColorEntry( const char *pKey,
+                                    const QColor* pDefault ) const
+{
+  QColor aRetColor;
+  int nRed = 0, nGreen = 0, nBlue = 0;
+
+  QString aValue = readEntry( pKey );
+  if( !aValue.isEmpty() )
+    {
+      if ( aValue.at(0) == '#' )
+        {
+          aRetColor.setNamedColor(aValue);
+        }
+      else
+        {
+
+          bool bOK;
+
+          // find first part (red)
+          int nIndex = aValue.find( ',' );
+
+          if( nIndex == -1 ){
+            // return a sensible default -- Bernd
+            if( pDefault )
+              aRetColor = *pDefault;
+            return aRetColor;
+          }
+
+          nRed = aValue.left( nIndex ).toInt( &bOK );
+
+          // find second part (green)
+          int nOldIndex = nIndex;
+          nIndex = aValue.find( ',', nOldIndex+1 );
+
+          if( nIndex == -1 ){
+            // return a sensible default -- Bernd
+            if( pDefault )
+              aRetColor = *pDefault;
+            return aRetColor;
+          }
+          nGreen = aValue.mid( nOldIndex+1,
+                               nIndex-nOldIndex-1 ).toInt( &bOK );
+
+          // find third part (blue)
+          nBlue = aValue.right( aValue.length()-nIndex-1 ).toInt( &bOK );
+
+          aRetColor.setRgb( nRed, nGreen, nBlue );
+        }
+    }
+  else {
+
+    if( pDefault )
+      aRetColor = *pDefault;
+  }
+
+  return aRetColor;
+}
+
+
+QDateTime KConfigBase::readDateTimeEntry( const QString& pKey,
+                                          const QDateTime* pDefault ) const
+{
+  return readDateTimeEntry(pKey.utf8().data(), pDefault);
+}
+
+// ### currentDateTime() as fallback ? (Harri)
+QDateTime KConfigBase::readDateTimeEntry( const char *pKey,
+                                          const QDateTime* pDefault ) const
+{
+  if( !hasKey( pKey ) )
+    {
+      if( pDefault )
+        return *pDefault;
+      else
+        return QDateTime::currentDateTime();
+    }
+
+  QStrList list;
+  int count = readListEntry( pKey, list, ',' );
+  if( count == 6 ) {
+    QDate date( atoi( list.at( 0 ) ), atoi( list.at( 1 ) ),
+                atoi( list.at( 2 ) ) );
+    QTime time( atoi( list.at( 3 ) ), atoi( list.at( 4 ) ),
+                atoi( list.at( 5 ) ) );
+
+    return QDateTime( date, time );
+  }
+
+  return QDateTime::currentDateTime();
+}
+
+void KConfigBase::writeEntry( const QString& pKey, const QString& value,
+                                 bool bPersistent,
+                                 bool bGlobal,
+                                 bool bNLS )
+{
+   writeEntry(pKey.utf8().data(), value, bPersistent,  bGlobal, bNLS);
+}
+
+void KConfigBase::writeEntry( const char *pKey, const QString& value,
+                                 bool bPersistent,
+                                 bool bGlobal,
+                                 bool bNLS )
+{
+   writeEntry(pKey, value, bPersistent,  bGlobal, bNLS, false);
+}
+
+void KConfigBase::writeEntry( const char *pKey, const QString& value,
+                                 bool bPersistent,
+                                 bool bGlobal,
+                                 bool bNLS,
+                                 bool bExpand )
+{
+  // the KConfig object is dirty now
+  // set this before any IO takes place so that if any derivative
+  // classes do caching, they won't try and flush the cache out
+  // from under us before we read. A race condition is still
+  // possible but minimized.
+  if( bPersistent )
+    setDirty(true);
+
+  if (!bLocaleInitialized && KGlobal::locale())
+    setLocale();
+
+  KEntryKey entryKey(mGroup, pKey);
+  entryKey.bLocal = bNLS;
+
+  KEntry aEntryData;
+  aEntryData.mValue = value.utf8();  // set new value
+  aEntryData.bGlobal = bGlobal;
+  aEntryData.bNLS = bNLS;
+  aEntryData.bExpand = bExpand;
+
+  if (bPersistent)
+    aEntryData.bDirty = true;
+
+  // rewrite the new value
+  putData(entryKey, aEntryData, true);
+}
+
+void KConfigBase::writePathEntry( const QString& pKey, const QString & path,
+                                  bool bPersistent, bool bGlobal,
+                                  bool bNLS)
+{
+   writePathEntry(pKey.utf8().data(), path, bPersistent, bGlobal, bNLS);
+}
+
+
+static bool cleanHomeDirPath( QString &path, const QString &homeDir )
+{
+#ifdef Q_WS_WIN //safer
+   if (!QDir::convertSeparators(path).startsWith(QDir::convertSeparators(homeDir)))
+        return false;
+#else
+   if (!path.startsWith(homeDir))
+        return false;
+#endif
+
+   unsigned int len = homeDir.length();
+   // replace by "$HOME" if possible
+   if (len && (path.length() == len || path[len] == '/')) {
+        path.replace(0, len, QString::fromLatin1("$HOME"));
+        return true;
+   } else
+        return false;
+}
+
+static QString translatePath( QString path )
+{
+   if (path.isEmpty())
+       return path;
+
+   // only "our" $HOME should be interpreted
+   path.replace('$', "$$");
+
+   bool startsWithFile = path.startsWith("file:", false);
+
+   // return original path, if it refers to another type of URL (e.g. http:/), or
+   // if the path is already relative to another directory
+   if (!startsWithFile && path[0] != '/' ||
+        startsWithFile && path[5] != '/')
+	return path;
+
+   if (startsWithFile)
+        path.remove(0,5); // strip leading "file:/" off the string
+
+   // keep only one single '/' at the beginning - needed for cleanHomeDirPath()
+   while (path[0] == '/' && path[1] == '/')
+	path.remove(0,1);
+
+   // we can not use KGlobal::dirs()->relativeLocation("home", path) here,
+   // since it would not recognize paths without a trailing '/'.
+   // All of the 3 following functions to return the user's home directory
+   // can return different paths. We have to test all them.
+   QString homeDir0 = QFile::decodeName(getenv("HOME"));
+   QString homeDir1 = QDir::homeDirPath();
+   QString homeDir2 = QDir(homeDir1).canonicalPath();
+   if (cleanHomeDirPath(path, homeDir0) ||
+       cleanHomeDirPath(path, homeDir1) ||
+       cleanHomeDirPath(path, homeDir2) ) {
+     // kdDebug() << "Path was replaced\n";
+   }
+
+   if (startsWithFile)
+      path.prepend( "file://" );
+
+   return path;
+}
+
+void KConfigBase::writePathEntry( const char *pKey, const QString & path,
+                                  bool bPersistent, bool bGlobal,
+                                  bool bNLS)
+{
+   writeEntry(pKey, translatePath(path), bPersistent, bGlobal, bNLS, true);
+}
+
+void KConfigBase::writePathEntry ( const QString& pKey, const QStringList &list,
+                               char sep , bool bPersistent,
+                               bool bGlobal, bool bNLS )
+{
+  writePathEntry(pKey.utf8().data(), list, sep, bPersistent, bGlobal, bNLS);
+}
+
+void KConfigBase::writePathEntry ( const char *pKey, const QStringList &list,
+                               char sep , bool bPersistent,
+                               bool bGlobal, bool bNLS )
+{
+  if( list.isEmpty() )
+    {
+      writeEntry( pKey, QString::fromLatin1(""), bPersistent );
+      return;
+    }
+  QStringList new_list;
+  QStringList::ConstIterator it = list.begin();
+  for( ; it != list.end(); ++it )
+    {
+      QString value = *it;
+      new_list.append( translatePath(value) );
+    }
+  writeEntry( pKey, new_list, sep, bPersistent, bGlobal, bNLS, true );
+}
+
+void KConfigBase::deleteEntry( const QString& pKey,
+                                 bool bNLS,
+                                 bool bGlobal)
+{
+   deleteEntry(pKey.utf8().data(), bNLS, bGlobal);
+}
+
+void KConfigBase::deleteEntry( const char *pKey,
+                                 bool bNLS,
+                                 bool bGlobal)
+{
+  // the KConfig object is dirty now
+  // set this before any IO takes place so that if any derivative
+  // classes do caching, they won't try and flush the cache out
+  // from under us before we read. A race condition is still
+  // possible but minimized.
+  setDirty(true);
+
+  if (!bLocaleInitialized && KGlobal::locale())
+    setLocale();
+
+  KEntryKey entryKey(mGroup, pKey);
+  KEntry aEntryData;
+
+  aEntryData.bGlobal = bGlobal;
+  aEntryData.bNLS = bNLS;
+  aEntryData.bDirty = true;
+  aEntryData.bDeleted = true;
+
+  // rewrite the new value
+  putData(entryKey, aEntryData, true);
+}
+
+bool KConfigBase::deleteGroup( const QString& group, bool bDeep, bool bGlobal )
+{
+  KEntryMap aEntryMap = internalEntryMap(group);
+
+  if (!bDeep) {
+    // Check if it empty
+    return aEntryMap.isEmpty();
+  }
+
+  bool dirty = false;
+  bool checkGroup = true;
+  // we want to remove all entries in the group
+  KEntryMapIterator aIt;
+  for (aIt = aEntryMap.begin(); aIt != aEntryMap.end(); ++aIt)
+  {
+    if (!aIt.key().mKey.isEmpty() && !aIt.key().bDefault && !(*aIt).bDeleted)
+    {
+      (*aIt).bDeleted = true;
+      (*aIt).bDirty = true;
+      (*aIt).bGlobal = bGlobal;
+      (*aIt).mValue = 0;
+      putData(aIt.key(), *aIt, checkGroup);
+      checkGroup = false;
+      dirty = true;
+    }
+  }
+  if (dirty)
+     setDirty(true);
+  return true;
+}
+
+void KConfigBase::writeEntry ( const QString& pKey, const QVariant &prop,
+                               bool bPersistent,
+                               bool bGlobal, bool bNLS )
+{
+  writeEntry(pKey.utf8().data(), prop, bPersistent, bGlobal, bNLS);
+}
+
+void KConfigBase::writeEntry ( const char *pKey, const QVariant &prop,
+                               bool bPersistent,
+                               bool bGlobal, bool bNLS )
+{
+  switch( prop.type() )
+    {
+    case QVariant::Invalid:
+      writeEntry( pKey, "", bPersistent, bGlobal, bNLS );
+      return;
+    case QVariant::String:
+      writeEntry( pKey, prop.toString(), bPersistent, bGlobal, bNLS );
+      return;
+    case QVariant::StringList:
+      writeEntry( pKey, prop.toStringList(), ',', bPersistent, bGlobal, bNLS );
+      return;
+    case QVariant::List: {
+        QValueList<QVariant> list = prop.toList();
+        QValueList<QVariant>::ConstIterator it = list.begin();
+        QValueList<QVariant>::ConstIterator end = list.end();
+        QStringList strList;
+
+        for (; it != end; ++it )
+            strList.append( (*it).toString() );
+
+        writeEntry( pKey, strList, ',', bPersistent, bGlobal, bNLS );
+
+        return;
+    }
+    case QVariant::Font:
+      writeEntry( pKey, prop.toFont(), bPersistent, bGlobal, bNLS );
+      return;
+    case QVariant::Point:
+      writeEntry( pKey, prop.toPoint(), bPersistent, bGlobal, bNLS );
+      return;
+    case QVariant::Rect:
+      writeEntry( pKey, prop.toRect(), bPersistent, bGlobal, bNLS );
+      return;
+    case QVariant::Size:
+      writeEntry( pKey, prop.toSize(), bPersistent, bGlobal, bNLS );
+      return;
+    case QVariant::Color:
+      writeEntry( pKey, prop.toColor(), bPersistent, bGlobal, bNLS );
+      return;
+    case QVariant::Int:
+      writeEntry( pKey, prop.toInt(), bPersistent, bGlobal, bNLS );
+      return;
+    case QVariant::UInt:
+      writeEntry( pKey, prop.toUInt(), bPersistent, bGlobal, bNLS );
+      return;
+    case QVariant::LongLong:
+      writeEntry( pKey, prop.toLongLong(), bPersistent, bGlobal, bNLS );
+      return;
+    case QVariant::ULongLong:
+      writeEntry( pKey, prop.toULongLong(), bPersistent, bGlobal, bNLS );
+      return;
+    case QVariant::Bool:
+      writeEntry( pKey, prop.toBool(), bPersistent, bGlobal, bNLS );
+      return;
+    case QVariant::Double:
+      writeEntry( pKey, prop.toDouble(), bPersistent, bGlobal, 'g', 6, bNLS );
+      return;
+    case QVariant::DateTime:
+      writeEntry( pKey, prop.toDateTime(), bPersistent, bGlobal, bNLS);
+      return;
+    case QVariant::Date:
+      writeEntry( pKey, QDateTime(prop.toDate()), bPersistent, bGlobal, bNLS);
+      return;
+
+    case QVariant::Pixmap:
+    case QVariant::Image:
+    case QVariant::Brush:
+    case QVariant::Palette:
+    case QVariant::ColorGroup:
+    case QVariant::Map:
+    case QVariant::IconSet:
+    case QVariant::CString:
+    case QVariant::PointArray:
+    case QVariant::Region:
+    case QVariant::Bitmap:
+    case QVariant::Cursor:
+    case QVariant::SizePolicy:
+    case QVariant::Time:
+    case QVariant::ByteArray:
+    case QVariant::BitArray:
+    case QVariant::KeySequence:
+    case QVariant::Pen:
+        break;
+    }
+
+  Q_ASSERT( 0 );
+}
+
+void KConfigBase::writeEntry ( const QString& pKey, const QStrList &list,
+                               char sep , bool bPersistent,
+                               bool bGlobal, bool bNLS )
+{
+  writeEntry(pKey.utf8().data(), list, sep, bPersistent, bGlobal, bNLS);
+}
+
+void KConfigBase::writeEntry ( const char *pKey, const QStrList &list,
+                               char sep , bool bPersistent,
+                               bool bGlobal, bool bNLS )
+{
+  if( list.isEmpty() )
+    {
+      writeEntry( pKey, QString::fromLatin1(""), bPersistent );
+      return;
+    }
+  QString str_list;
+  QStrListIterator it( list );
+  for( ; it.current(); ++it )
+    {
+      uint i;
+      QString value;
+      // !!! Sergey A. Sukiyazov <corwin@micom.don.ru> !!!
+      // A QStrList may contain values in 8bit locale cpecified
+      // encoding or in UTF8 encoding.
+      value = KStringHandler::from8Bit(it.current());
+      uint strLengh(value.length());
+      for( i = 0; i < strLengh; i++ )
+        {
+          if( value[i] == sep || value[i] == '\\' )
+            str_list += '\\';
+          str_list += value[i];
+        }
+      str_list += sep;
+    }
+  if( str_list.at(str_list.length() - 1) == sep )
+    str_list.truncate( str_list.length() -1 );
+  writeEntry( pKey, str_list, bPersistent, bGlobal, bNLS );
+}
+
+void KConfigBase::writeEntry ( const QString& pKey, const QStringList &list,
+                               char sep , bool bPersistent,
+                               bool bGlobal, bool bNLS )
+{
+  writeEntry(pKey.utf8().data(), list, sep, bPersistent, bGlobal, bNLS);
+}
+
+void KConfigBase::writeEntry ( const char *pKey, const QStringList &list,
+                               char sep , bool bPersistent,
+                               bool bGlobal, bool bNLS )
+{
+  writeEntry(pKey, list, sep, bPersistent, bGlobal, bNLS, false);
+}
+
+void KConfigBase::writeEntry ( const char *pKey, const QStringList &list,
+                               char sep, bool bPersistent,
+                               bool bGlobal, bool bNLS, bool bExpand )
+{
+  if( list.isEmpty() )
+    {
+      writeEntry( pKey, QString::fromLatin1(""), bPersistent );
+      return;
+    }
+  QString str_list;
+  str_list.reserve( 4096 );
+  QStringList::ConstIterator it = list.begin();
+  for( ; it != list.end(); ++it )
+    {
+      QString value = *it;
+      uint i;
+      uint strLength(value.length());
+      for( i = 0; i < strLength; i++ )
+        {
+          if( value[i] == sep || value[i] == '\\' )
+            str_list += '\\';
+          str_list += value[i];
+        }
+      str_list += sep;
+    }
+  if( str_list.at(str_list.length() - 1) == sep )
+    str_list.truncate( str_list.length() -1 );
+  writeEntry( pKey, str_list, bPersistent, bGlobal, bNLS, bExpand );
+}
+
+void KConfigBase::writeEntry ( const QString& pKey, const QValueList<int> &list,
+                               bool bPersistent, bool bGlobal, bool bNLS )
+{
+  writeEntry(pKey.utf8().data(), list, bPersistent, bGlobal, bNLS);
+}
+
+void KConfigBase::writeEntry ( const char *pKey, const QValueList<int> &list,
+                               bool bPersistent, bool bGlobal, bool bNLS )
+{
+    QStringList strlist;
+    QValueList<int>::ConstIterator end = list.end();
+    for (QValueList<int>::ConstIterator it = list.begin(); it != end; it++)
+        strlist << QString::number(*it);
+    writeEntry(pKey, strlist, ',', bPersistent, bGlobal, bNLS );
+}
+
+void KConfigBase::writeEntry( const QString& pKey, int nValue,
+                                 bool bPersistent, bool bGlobal,
+                                 bool bNLS )
+{
+  writeEntry( pKey, QString::number(nValue), bPersistent, bGlobal, bNLS );
+}
+
+void KConfigBase::writeEntry( const char *pKey, int nValue,
+                                 bool bPersistent, bool bGlobal,
+                                 bool bNLS )
+{
+  writeEntry( pKey, QString::number(nValue), bPersistent, bGlobal, bNLS );
+}
+
+
+void KConfigBase::writeEntry( const QString& pKey, unsigned int nValue,
+                                 bool bPersistent, bool bGlobal,
+                                 bool bNLS )
+{
+  writeEntry( pKey, QString::number(nValue), bPersistent, bGlobal, bNLS );
+}
+
+void KConfigBase::writeEntry( const char *pKey, unsigned int nValue,
+                                 bool bPersistent, bool bGlobal,
+                                 bool bNLS )
+{
+  writeEntry( pKey, QString::number(nValue), bPersistent, bGlobal, bNLS );
+}
+
+
+void KConfigBase::writeEntry( const QString& pKey, long nValue,
+                                 bool bPersistent, bool bGlobal,
+                                 bool bNLS )
+{
+  writeEntry( pKey, QString::number(nValue), bPersistent, bGlobal, bNLS );
+}
+
+void KConfigBase::writeEntry( const char *pKey, long nValue,
+                                 bool bPersistent, bool bGlobal,
+                                 bool bNLS )
+{
+  writeEntry( pKey, QString::number(nValue), bPersistent, bGlobal, bNLS );
+}
+
+
+void KConfigBase::writeEntry( const QString& pKey, unsigned long nValue,
+                                 bool bPersistent, bool bGlobal,
+                                 bool bNLS )
+{
+  writeEntry( pKey, QString::number(nValue), bPersistent, bGlobal, bNLS );
+}
+
+void KConfigBase::writeEntry( const char *pKey, unsigned long nValue,
+                                 bool bPersistent, bool bGlobal,
+                                 bool bNLS )
+{
+  writeEntry( pKey, QString::number(nValue), bPersistent, bGlobal, bNLS );
+}
+
+void KConfigBase::writeEntry( const QString& pKey, Q_INT64 nValue,
+                                 bool bPersistent, bool bGlobal,
+                                 bool bNLS )
+{
+  writeEntry( pKey, QString::number(nValue), bPersistent, bGlobal, bNLS );
+}
+
+void KConfigBase::writeEntry( const char *pKey, Q_INT64 nValue,
+                                 bool bPersistent, bool bGlobal,
+                                 bool bNLS )
+{
+  writeEntry( pKey, QString::number(nValue), bPersistent, bGlobal, bNLS );
+}
+
+
+void KConfigBase::writeEntry( const QString& pKey, Q_UINT64 nValue,
+                                 bool bPersistent, bool bGlobal,
+                                 bool bNLS )
+{
+  writeEntry( pKey, QString::number(nValue), bPersistent, bGlobal, bNLS );
+}
+
+void KConfigBase::writeEntry( const char *pKey, Q_UINT64 nValue,
+                                 bool bPersistent, bool bGlobal,
+                                 bool bNLS )
+{
+  writeEntry( pKey, QString::number(nValue), bPersistent, bGlobal, bNLS );
+}
+
+void KConfigBase::writeEntry( const QString& pKey, double nValue,
+                                 bool bPersistent, bool bGlobal,
+                                 char format, int precision,
+                                 bool bNLS )
+{
+  writeEntry( pKey, QString::number(nValue, format, precision),
+                     bPersistent, bGlobal, bNLS );
+}
+
+void KConfigBase::writeEntry( const char *pKey, double nValue,
+                                 bool bPersistent, bool bGlobal,
+                                 char format, int precision,
+                                 bool bNLS )
+{
+  writeEntry( pKey, QString::number(nValue, format, precision),
+                     bPersistent, bGlobal, bNLS );
+}
+
+
+void KConfigBase::writeEntry( const QString& pKey, bool bValue,
+                                 bool bPersistent,
+                                 bool bGlobal,
+                                 bool bNLS )
+{
+  writeEntry(pKey.utf8().data(), bValue, bPersistent, bGlobal, bNLS);
+}
+
+void KConfigBase::writeEntry( const char *pKey, bool bValue,
+                                 bool bPersistent,
+                                 bool bGlobal,
+                                 bool bNLS )
+{
+  QString aValue;
+
+  if( bValue )
+    aValue = "true";
+  else
+    aValue = "false";
+
+  writeEntry( pKey, aValue, bPersistent, bGlobal, bNLS );
+}
+
+
+void KConfigBase::writeEntry( const QString& pKey, const QFont& rFont,
+                                 bool bPersistent, bool bGlobal,
+                                 bool bNLS )
+{
+  writeEntry(pKey.utf8().data(), rFont, bPersistent, bGlobal, bNLS);
+}
+
+void KConfigBase::writeEntry( const char *pKey, const QFont& rFont,
+                                 bool bPersistent, bool bGlobal,
+                                 bool bNLS )
+{
+  writeEntry( pKey, rFont.toString(), bPersistent, bGlobal, bNLS );
+}
+
+
+void KConfigBase::writeEntry( const QString& pKey, const QRect& rRect,
+                              bool bPersistent, bool bGlobal,
+                              bool bNLS )
+{
+  writeEntry(pKey.utf8().data(), rRect, bPersistent, bGlobal, bNLS);
+}
+
+void KConfigBase::writeEntry( const char *pKey, const QRect& rRect,
+                              bool bPersistent, bool bGlobal,
+                              bool bNLS )
+{
+  QStrList list;
+  QCString tempstr;
+  list.insert( 0, tempstr.setNum( rRect.left() ) );
+  list.insert( 1, tempstr.setNum( rRect.top() ) );
+  list.insert( 2, tempstr.setNum( rRect.width() ) );
+  list.insert( 3, tempstr.setNum( rRect.height() ) );
+
+  writeEntry( pKey, list, ',', bPersistent, bGlobal, bNLS );
+}
+
+
+void KConfigBase::writeEntry( const QString& pKey, const QPoint& rPoint,
+                              bool bPersistent, bool bGlobal,
+                              bool bNLS )
+{
+  writeEntry(pKey.utf8().data(), rPoint, bPersistent, bGlobal, bNLS);
+}
+
+void KConfigBase::writeEntry( const char *pKey, const QPoint& rPoint,
+                              bool bPersistent, bool bGlobal,
+                              bool bNLS )
+{
+  QStrList list;
+  QCString tempstr;
+  list.insert( 0, tempstr.setNum( rPoint.x() ) );
+  list.insert( 1, tempstr.setNum( rPoint.y() ) );
+
+  writeEntry( pKey, list, ',', bPersistent, bGlobal, bNLS );
+}
+
+
+void KConfigBase::writeEntry( const QString& pKey, const QSize& rSize,
+                              bool bPersistent, bool bGlobal,
+                              bool bNLS )
+{
+  writeEntry(pKey.utf8().data(), rSize, bPersistent, bGlobal, bNLS);
+}
+
+void KConfigBase::writeEntry( const char *pKey, const QSize& rSize,
+                              bool bPersistent, bool bGlobal,
+                              bool bNLS )
+{
+  QStrList list;
+  QCString tempstr;
+  list.insert( 0, tempstr.setNum( rSize.width() ) );
+  list.insert( 1, tempstr.setNum( rSize.height() ) );
+
+  writeEntry( pKey, list, ',', bPersistent, bGlobal, bNLS );
+}
+
+void KConfigBase::writeEntry( const QString& pKey, const QColor& rColor,
+                              bool bPersistent,
+                              bool bGlobal,
+                              bool bNLS  )
+{
+  writeEntry( pKey.utf8().data(), rColor, bPersistent, bGlobal, bNLS);
+}
+
+void KConfigBase::writeEntry( const char *pKey, const QColor& rColor,
+                              bool bPersistent,
+                              bool bGlobal,
+                              bool bNLS  )
+{
+  QString aValue;
+  if (rColor.isValid())
+      aValue.sprintf( "%d,%d,%d", rColor.red(), rColor.green(), rColor.blue() );
+  else
+      aValue = "invalid";
+
+  writeEntry( pKey, aValue, bPersistent, bGlobal, bNLS );
+}
+
+void KConfigBase::writeEntry( const QString& pKey, const QDateTime& rDateTime,
+                              bool bPersistent, bool bGlobal,
+                              bool bNLS )
+{
+  writeEntry(pKey.utf8().data(), rDateTime, bPersistent, bGlobal, bNLS);
+}
+
+void KConfigBase::writeEntry( const char *pKey, const QDateTime& rDateTime,
+                              bool bPersistent, bool bGlobal,
+                              bool bNLS )
+{
+  QStrList list;
+  QCString tempstr;
+
+  QTime time = rDateTime.time();
+  QDate date = rDateTime.date();
+
+  list.insert( 0, tempstr.setNum( date.year() ) );
+  list.insert( 1, tempstr.setNum( date.month() ) );
+  list.insert( 2, tempstr.setNum( date.day() ) );
+
+  list.insert( 3, tempstr.setNum( time.hour() ) );
+  list.insert( 4, tempstr.setNum( time.minute() ) );
+  list.insert( 5, tempstr.setNum( time.second() ) );
+
+  writeEntry( pKey, list, ',', bPersistent, bGlobal, bNLS );
+}
+
+void KConfigBase::parseConfigFiles()
+{
+  if (!bLocaleInitialized && KGlobal::_locale) {
+    setLocale();
+  }
+  if (backEnd)
+  {
+     backEnd->parseConfigFiles();
+     bReadOnly = (backEnd->getConfigState() == ReadOnly);
+  }
+}
+
+void KConfigBase::sync()
+{
+  if (isReadOnly())
+    return;
+
+  if (backEnd)
+     backEnd->sync();
+  if (bDirty)
+    rollback();
+}
+
+KConfigBase::ConfigState KConfigBase::getConfigState() const {
+    if (backEnd)
+       return backEnd->getConfigState();
+    return ReadOnly;
+}
+
+void KConfigBase::rollback( bool /*bDeep = true*/ )
+{
+  bDirty = false;
+}
+
+
+void KConfigBase::setReadDefaults(bool b)
+{
+  if (!d)
+  {
+     if (!b) return;
+     d = new KConfigBasePrivate();
+  }
+
+  d->readDefaults = b;
+}
+
+bool KConfigBase::readDefaults() const
+{
+  return (d && d->readDefaults);
+}
+
+void KConfigBase::revertToDefault(const QString &key)
+{
+  setDirty(true);
+
+  KEntryKey aEntryKey(mGroup, key.utf8());
+  aEntryKey.bDefault = true;
+
+  if (!locale().isNull()) {
+    // try the localized key first
+    aEntryKey.bLocal = true;
+    KEntry entry = lookupData(aEntryKey);
+    if (entry.mValue.isNull())
+        entry.bDeleted = true;
+
+    entry.bDirty = true;
+    putData(aEntryKey, entry, true); // Revert
+    aEntryKey.bLocal = false;
+  }
+
+  // try the non-localized version
+  KEntry entry = lookupData(aEntryKey);
+  if (entry.mValue.isNull())
+     entry.bDeleted = true;
+  entry.bDirty = true;
+  putData(aEntryKey, entry, true); // Revert
+}
+
+bool KConfigBase::hasDefault(const QString &key) const
+{
+  KEntryKey aEntryKey(mGroup, key.utf8());
+  aEntryKey.bDefault = true;
+
+  if (!locale().isNull()) {
+    // try the localized key first
+    aEntryKey.bLocal = true;
+    KEntry entry = lookupData(aEntryKey);
+    if (!entry.mValue.isNull())
+        return true;
+
+    aEntryKey.bLocal = false;
+  }
+
+  // try the non-localized version
+  KEntry entry = lookupData(aEntryKey);
+  if (!entry.mValue.isNull())
+     return true;
+
+  return false;
+}
+
+
+
+KConfigGroup::KConfigGroup(KConfigBase *master, const QString &group)
+{
+  mMaster = master;
+  backEnd = mMaster->backEnd; // Needed for getConfigState()
+  bLocaleInitialized = true;
+  bReadOnly = mMaster->bReadOnly;
+  bExpand = false;
+  bDirty = false; // Not used
+  mGroup = group.utf8();
+  aLocaleString = mMaster->aLocaleString;
+  setReadDefaults(mMaster->readDefaults());
+}
+
+KConfigGroup::KConfigGroup(KConfigBase *master, const QCString &group)
+{
+  mMaster = master;
+  backEnd = mMaster->backEnd; // Needed for getConfigState()
+  bLocaleInitialized = true;
+  bReadOnly = mMaster->bReadOnly;
+  bExpand = false;
+  bDirty = false; // Not used
+  mGroup = group;
+  aLocaleString = mMaster->aLocaleString;
+  setReadDefaults(mMaster->readDefaults());
+}
+
+KConfigGroup::KConfigGroup(KConfigBase *master, const char * group)
+{
+  mMaster = master;
+  backEnd = mMaster->backEnd; // Needed for getConfigState()
+  bLocaleInitialized = true;
+  bReadOnly = mMaster->bReadOnly;
+  bExpand = false;
+  bDirty = false; // Not used
+  mGroup = group;
+  aLocaleString = mMaster->aLocaleString;
+  setReadDefaults(mMaster->readDefaults());
+}
+
+void KConfigGroup::deleteGroup(bool bGlobal)
+{
+  mMaster->deleteGroup(KConfigBase::group(), true, bGlobal);
+}
+
+bool KConfigGroup::groupIsImmutable() const
+{
+    return mMaster->groupIsImmutable(KConfigBase::group());
+}
+
+void KConfigGroup::setDirty(bool _bDirty)
+{
+  mMaster->setDirty(_bDirty);
+}
+
+void KConfigGroup::putData(const KEntryKey &_key, const KEntry &_data, bool _checkGroup)
+{
+  mMaster->putData(_key, _data, _checkGroup);
+}
+
+KEntry KConfigGroup::lookupData(const KEntryKey &_key) const
+{
+  return mMaster->lookupData(_key);
+}
+
+void KConfigGroup::sync()
+{
+  mMaster->sync();
+}
+
+void KConfigBase::virtual_hook( int, void* )
+{ /*BASE::virtual_hook( id, data );*/ }
+
+void KConfigGroup::virtual_hook( int id, void* data )
+{ KConfigBase::virtual_hook( id, data ); }
+
+bool KConfigBase::checkConfigFilesWritable(bool warnUser)
+{
+  if (backEnd)
+    return backEnd->checkConfigFilesWritable(warnUser);
+  else
+    return false;
+}
+
+#include "kconfigbase.moc"