Index: kdecore/kernel/kautostart.cpp
===================================================================
--- kdecore/kernel/kautostart.cpp	(revision 733566)
+++ kdecore/kernel/kautostart.cpp	(working copy)
@@ -137,10 +137,11 @@
     d->df->desktopGroup().writePathEntry( "TryExec", exec );
 }
 
-template <>
-KAutostart::StartPhase KConfigGroup::readEntry(const QByteArray &key, const KAutostart::StartPhase& aDefault) const
+// jstaniek: changed to nonpecialized variant because of msvc.net
+// http://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=100911
+KAutostart::StartPhase readEntry(const KConfigGroup &group, const char* key, const KAutostart::StartPhase& aDefault)
 {
-    const QByteArray data = readEntry(key, QByteArray());
+    const QByteArray data = group.readEntry(key, QByteArray());
 
     if (data.isNull())
         return aDefault;
@@ -157,7 +158,7 @@
 
 KAutostart::StartPhase KAutostart::startPhase() const
 {
-    return d->df->desktopGroup().readEntry("X-KDE-autostart-phase", Applications);
+    return readEntry(d->df->desktopGroup(), "X-KDE-autostart-phase", Applications);
 }
 
 void KAutostart::setStartPhase(KAutostart::StartPhase phase)
Index: kdecore/config/kconfiggroup.h
===================================================================
--- kdecore/config/kconfiggroup.h	(revision 733566)
+++ kdecore/config/kconfiggroup.h	(working copy)
@@ -61,7 +61,6 @@
      * Construct a config group corresponding to @p group in @p master.
      * @p group is the group name encoded in UTF-8.
      */
-    KConfigGroup(KConfigBase *master, const QByteArray &group);
     KConfigGroup(KConfigBase *master, const QString &group);
     KConfigGroup(KConfigBase *master, const char *group);
 
@@ -70,11 +69,9 @@
      * any attempts to write to it.
      */
     KConfigGroup(const KConfigBase *master, const QString &group);
-    KConfigGroup(const KConfigBase *master, const QByteArray &group);
     KConfigGroup(const KConfigBase *master, const char *group);
 
     KConfigGroup(const KSharedConfigPtr &master, const QString& group);
-    KConfigGroup(const KSharedConfigPtr &master, const QByteArray& group);
     KConfigGroup(const KSharedConfigPtr &master, const char* group);
 
     KConfigGroup(const KConfigGroup &);
@@ -124,7 +121,6 @@
      * groups. A subgroup can only change to another subgroup of the parent.
      */
     KDE_DEPRECATED void changeGroup( const QString &group );
-    KDE_DEPRECATED void changeGroup( const QByteArray &group);
     KDE_DEPRECATED void changeGroup( const char *group);
 
     /// @reimp
@@ -162,27 +158,78 @@
      * @return The value for this key, or @p aDefault.
      */
     template <typename T>
-        T readEntry(const QByteArray &key, const T &defaultValue) const
-            { return readListCheck(key, defaultValue); }
+        inline T readEntry(const QString& key, const T& aDefault) const
+            { return readEntry(key.toUtf8().constData(), aDefault); }
     template <typename T>
-        T readEntry(const QString& pKey, const T& aDefault) const
-            { return readEntry(pKey.toUtf8(), aDefault); }
-    template <typename T>
-        T readEntry(const char *key, const T& aDefault) const
-            { return readEntry(QByteArray(key), aDefault); }
+        inline T readEntry(const char *key, const T& aDefault) const
+            { return qvariant_cast<T>(readEntry(key, qVariantFromValue(aDefault))); }
+    template<typename T>
+        inline QList<T> readEntry(const QString& key, const QList<T> &aDefault) const
+            { return readListCheck(key.toUtf8().constData(), aDefault); }
+    template<typename T>
+        inline QList<T> readEntry(const char* key, const QList<T> &aDefault) const
+            { return readListCheck(key, aDefault); }
 
-    QString readEntry(const QByteArray &key, const char * aDefault = 0) const;
+    /**
+     * Reads the value of an entry specified by @p key in the current group.
+     *
+     * @param key The key to search for.
+     * @param aDefault A default value returned if the key was not found.
+     * @return The value for this key. Can be QVariant() if aDefault is null.
+     */
+    QVariant readEntry(const QString& key, const QVariant &aDefault) const;
+    QVariant readEntry(const char* key, const QVariant &aDefault) const;
+
+    /**
+     * Reads the value of an entry specified by @p key in the current group.
+     * If you want to read a path, please use readPathEntry().
+     *
+     * @param key The key to search for.
+     * @param aDefault A default value returned if the key was not found.
+     * @return The value for this key. Can be QString() if aDefault is null.
+     */
+    QString readEntry(const char* key, const QString& aDefault ) const;
+    QString readEntry(const QString& key, const QString& aDefault) const;
+
+    /**
+     * Reads the value of an entry specified by @p key in the current group.
+     *
+     * @param key The key to search for.
+     * @param aDefault A default value returned if the key was not found.
+     * @return The value for this key. Can be QString() if aDefault is null.
+     */
     QString readEntry(const QString &key, const char * aDefault = 0) const;
-    QString readEntry(const char *key, const char * aDefault = 0) const;
+    QString readEntry(const char *key, const char *aDefault = 0 ) const;
 
     /**
+     * Reads a list from the config object.
+     *
+     * @copydoc readEntry(const char*, const QList<T>&) const
+     *
+     * @warning This function doesn't convert the items returned
+     *          to any type. It's actually a list of QVariant::String's. If you
+     *          want the items converted to a specific type use
+     *          readEntry(const char*, const QList<T>&) const
+     */
+    QVariantList readEntry( const QString &key, const QVariantList& aDefault ) const;
+    QVariantList readEntry( const char* key, const QVariantList& aDefault ) const;
+
+    /**
+     * Reads a list of strings from the config object.
+     * @param key The key to search for.
+     * @param aDefault The default value to use if the key does not exist.
+     * @return The list. Contains @p aDefault if @p key does not exist.
+     */
+    QStringList readEntry(const QString &key, const QStringList& aDefault) const;
+    QStringList readEntry(const char* key, const QStringList& aDefault) const;
+
+    /**
      * Reads a list of strings from the config object, following XDG
      * desktop entry spec separator semantics.
      * @param pKey The key to search for.
      * @param aDefault The default value to use if the key does not exist.
      * @return The list. Contains @p aDefault if @p pKey does not exist.
      */
-    QStringList readXdgListEntry(const QByteArray& pKey, const QStringList& aDefault = QStringList()) const;
     QStringList readXdgListEntry(const QString& pKey, const QStringList& aDefault = QStringList()) const;
     QStringList readXdgListEntry(const char* pKey, const QStringList& aDefault = QStringList()) const;
 
@@ -195,9 +242,8 @@
      *
      * @param pKey The key to search for.
      * @param aDefault A default value returned if the key was not found.
-     * @return The value for this key. Can be QString() if aDefault is null.
+     * @return The value for this key. Can be QString() if @p aDefault is null.
      */
-    QString readPathEntry( const QByteArray &key, const QString & aDefault ) const;
     QString readPathEntry( const QString& pKey, const QString & aDefault ) const;
     QString readPathEntry( const char *key, const QString & aDefault ) const;
 
@@ -212,7 +258,6 @@
      * @param aDefault A default value returned if the key was not found.
      * @return The list. Empty if the entry does not exist.
      */
-    QStringList readPathEntry( const QByteArray &key, const QStringList& aDefault ) const;
     QStringList readPathEntry( const QString& pKey, const QStringList& aDefault ) const;
     QStringList readPathEntry( const char *key, const QStringList& aDefault ) const;
 
@@ -224,8 +269,6 @@
      * @param aDefault A default value returned if the key was not found.
      * @return The value for this key.
      */
-    QString readEntryUntranslated( const QByteArray &key,
-                                   const QString& aDefault = QString() ) const;
     QString readEntryUntranslated( const QString& pKey,
                                    const QString& aDefault = QString() ) const;
     QString readEntryUntranslated( const char *key,
@@ -234,23 +277,116 @@
     /**
      * Writes a value to the config object.
      *
-     * @param pKey The key to write
+     * @param key The key to write
      * @param value The value to write
-     * @param pFlags       The flags to use when writing this entry.
+     * @param pFlags The flags to use when writing this entry.
      */
+    void writeEntry( const QString& key, const QVariant& value,
+                     WriteConfigFlags pFlags = Normal );
+    void writeEntry( const char *key, const QVariant& value,
+                     WriteConfigFlags pFlags = Normal );
+
+    /**
+     * Writes a value to the config object.
+     *
+     * @param key The key to write
+     * @param value The value to write
+     * @param pFlags The flags to use when writing this entry.
+     */
+    void writeEntry( const QString& key, const QString& value,
+                     WriteConfigFlags pFlags = Normal );
+    void writeEntry( const char *key, const QString& value,
+                     WriteConfigFlags pFlags = Normal );
+
+    /**
+     * Writes a value to the config object.
+     *
+     * @param key The key to write
+     * @param value The value to write
+     * @param pFlags The flags to use when writing this entry.
+     */
+    void writeEntry( const QString& key, const QByteArray& value,
+                     WriteConfigFlags pFlags = Normal );
+    void writeEntry( const char *key, const QByteArray& value,
+                     WriteConfigFlags pFlags = Normal );
+
+    /**
+     * Writes a value to the config object.
+     *
+     * @param key The key to write
+     * @param value The value to write
+     * @param pFlags The flags to use when writing this entry.
+     */
+    void writeEntry(const QString &key, const char *value, WriteConfigFlags pFlags = Normal);
+    void writeEntry(const char *key, const char *value, WriteConfigFlags pFlags = Normal);
+
+    /**
+     * Writes a value to the config object.
+     *
+     * @param key The key to write
+     * @param value The value to write
+     * @param pFlags The flags to use when writing this entry.
+     */
     template <typename T>
-        void writeEntry(const QByteArray &key, const T& value, WriteConfigFlags pFlags = Normal )
-            { writeListCheck(key, value, pFlags); }
+        inline void writeEntry( const char *key, const T& value, WriteConfigFlags pFlags = Normal )
+            {
+                writeListCheck( key, value, pFlags );
+            }
+
     template <typename T>
-        void writeEntry( const QString& pKey, const T& value, WriteConfigFlags pFlags = Normal )
-            { writeEntry( pKey.toUtf8(), value, pFlags ); }
+        inline void writeEntry( const QString& key, const T& value, WriteConfigFlags pFlags = Normal )
+            { writeListCheck( key.toUtf8().constData(), value, pFlags ); }
+
+    /**
+     * writeEntry() overridden to accept a list of strings.
+     *
+     * @param key The key to write
+     * @param value The list to write
+     * @param sep  The list separator (default is ",").
+     * @param pFlags       The flags to use when writing this entry.
+     *
+     * @see  writeEntry()
+     */
+    void writeEntry( const QString& key, const QStringList &value,
+                     WriteConfigFlags pFlags = Normal );
+
+    void writeEntry( const char* key, const QStringList &value,
+                     WriteConfigFlags pFlags = Normal );
+
+    /**
+     * writeEntry() overridden to accept a list of QVariant values.
+     *
+     * @param key The key to write
+     * @param value The list to write
+     * @param sep  The list separator (default is ",").
+     * @param pFlags       The flags to use when writing this entry.
+     *
+     * @see  writeEntry()
+     */
+    void writeEntry( const QString& key, const QVariantList &value,
+                     WriteConfigFlags pFlags = Normal );
+
+    void writeEntry( const char* key, const QVariantList &value,
+                     WriteConfigFlags pFlags = Normal );
+
+    /**
+     * Writes a list to the config object.
+     *
+     * @param key The key to write
+     * @param value The list to write
+     * @param pFlags The flags to use when writing this entry.
+     */
     template <typename T>
-        void writeEntry( const char *key, const T& value, WriteConfigFlags pFlags = Normal )
-            { writeEntry( QByteArray(key), value, pFlags ); }
+        inline void writeEntry(const QString& key, const QList<T> &value, WriteConfigFlags pFlags = Normal)
+            {
+                writeListCheck( key.toUtf8().constData(), value, pFlags );
+            }
 
-    void writeEntry(const QByteArray &key, const char *value, WriteConfigFlags pFlags = Normal);
-    void writeEntry(const QString &key, const char *value, WriteConfigFlags pFlags = Normal);
-    void writeEntry(const char *key, const char *value, WriteConfigFlags pFlags = Normal);
+    template <typename T>
+        inline void writeEntry(const char* key, const QList<T> &value, WriteConfigFlags pFlags = Normal)
+            {
+                writeListCheck( key, value, pFlags );
+            }
 
     /**
      * Writes a list of strings to the config object, following XDG
@@ -262,8 +398,6 @@
      *
      * @see  writeEntry()
      */
-    void writeXdgListEntry( const QByteArray &key, const QStringList &value,
-                            WriteConfigFlags pFlags = Normal );
     void writeXdgListEntry( const QString& pKey, const QStringList &value,
                             WriteConfigFlags pFlags = Normal );
     void writeXdgListEntry( const char *pKey, const QStringList &value,
@@ -280,8 +414,6 @@
      * @param path The path to write.
      * @param pFlags       The flags to use when writing this entry.
      */
-    void writePathEntry( const QByteArray &key, const QString & path,
-                         WriteConfigFlags pFlags = Normal );
     void writePathEntry( const QString& pKey, const QString & path,
                          WriteConfigFlags pFlags = Normal );
     void writePathEntry( const char *pKey, const QString & path,
@@ -300,8 +432,6 @@
      *
      * @see  readPathEntry()
      */
-    void writePathEntry( const QByteArray &key, const QStringList &value,
-                         WriteConfigFlags pFlags = Normal );
     void writePathEntry( const QString& pKey, const QStringList &value,
                          WriteConfigFlags pFlags = Normal );
     void writePathEntry( const char *pKey, const QStringList &value,
@@ -313,7 +443,6 @@
      * @param pKey The key to delete.
      * @param pFlags       The flags to use when deleting this entry.
      */
-    void deleteEntry(const QByteArray &key, WriteConfigFlags flags = Normal);
     void deleteEntry(const QString& pKey, WriteConfigFlags pFlags = Normal);
     void deleteEntry(const char *pKey, WriteConfigFlags pFlags = Normal);
 
@@ -326,7 +455,6 @@
      * @param key The key to search for.
      * @return If true, the key is available.
      */
-    bool hasKey(const QByteArray &key) const;
     bool hasKey(const QString &key) const;
     bool hasKey(const char *key) const;
 
@@ -342,7 +470,6 @@
      * @return whether the entry @p key may be changed in the current group
      * in this configuration file.
      */
-    bool isEntryImmutable(const QByteArray &key) const;
     bool isEntryImmutable(const QString &key) const;
     bool isEntryImmutable(const char *key) const;
 
@@ -356,7 +483,6 @@
      *
      * @param key The key of the entry to revert.
      */
-    void revertToDefault(const QByteArray &key);
     void revertToDefault(const QString &key);
     void revertToDefault(const char* key);
 
@@ -385,7 +511,6 @@
      * and will follow changes the computed default makes over time.
      * @param key The key of the entry to check.
      */
-    bool hasDefault(const QByteArray &key) const;
     bool hasDefault(const QString &key) const;
     bool hasDefault(const char* key) const;
 
@@ -409,17 +534,17 @@
 private:
     QExplicitlySharedDataPointer<KConfigGroupPrivate> d;
 
-    template<class T>
-    inline T readListCheck(const QByteArray &key, const T &defaultValue) const;
+    template<typename T>
+    inline T readListCheck(const char* key, const T &defaultValue) const;
 
-    template<class T>
-    inline QList<T> readListCheck(const QByteArray &key, const QList<T> &defaultValue) const;
+    template<typename T>
+    inline QList<T> readListCheck(const char* key, const QList<T> &defaultValue) const;
 
-    template<class T>
-    inline void writeListCheck(const QByteArray &key, const T &value, WriteConfigFlags pFlags);
+    template<typename T>
+    inline void writeListCheck(const char* key, const T &value, WriteConfigFlags pFlags);
 
-    template<class T>
-    inline void writeListCheck(const QByteArray &key, const QList<T> &value, WriteConfigFlags pFlags);
+    template<typename T>
+    inline void writeListCheck(const char* key, const QList<T> &value, WriteConfigFlags pFlags);
 
     friend class KConfigGroupPrivate;
 
@@ -484,24 +609,15 @@
 
 #include "conversion_check.h"
 
-template<>
-KDECORE_EXPORT QVariantList KConfigGroup::readEntry<QVariantList>(const QByteArray &key, const QVariantList &defaultValue) const;
-template<>
-KDECORE_EXPORT QVariant KConfigGroup::readEntry<QVariant>(const QByteArray &key, const QVariant &defaultValue) const;
-template<>
-KDECORE_EXPORT QStringList KConfigGroup::readEntry<QStringList>(const QByteArray &key, const QStringList &defaultValue) const;
-template<>
-KDECORE_EXPORT QString KConfigGroup::readEntry<QString>(const QByteArray &key, const QString &defaultValue) const;
-
-template<class T>
-T KConfigGroup::readListCheck(const QByteArray &key, const T &defaultValue) const
+template <typename T>
+T KConfigGroup::readListCheck(const char* key, const T &defaultValue) const
 {
-    ConversionCheck::to_QVariant<T>();
-    return qvariant_cast<T>(readEntry(key, qVariantFromValue(defaultValue)));
+  ConversionCheck::to_QVariant<T>();
+  return qvariant_cast<T>(readEntry(key, qVariantFromValue(defaultValue)));
 }
 
 template <typename T>
-QList<T> KConfigGroup::readListCheck(const QByteArray &key, const QList<T> &defaultValue) const
+QList<T> KConfigGroup::readListCheck(const char* key, const QList<T> &defaultValue) const
 {
   ConversionCheck::to_QVariant<T>();
   ConversionCheck::to_QString<T>();
@@ -512,7 +628,7 @@
     data.append(qVariantFromValue(value));
 
   QList<T> list;
-  Q_FOREACH (const QVariant &value, readEntry(key, data)) {
+  Q_FOREACH (const QVariant &value, readEntry<QVariantList>(key, data)) {
     Q_ASSERT(qVariantCanConvert<T>(value));
     list.append( qvariant_cast<T>(value) );
   }
@@ -520,26 +636,12 @@
   return list;
 }
 
-template<>
-KDECORE_EXPORT void KConfigGroup::writeEntry<QVariant>(const QByteArray &key, const QVariant &value, KConfigBase::WriteConfigFlags pFlags);
-template<>
-KDECORE_EXPORT void KConfigGroup::writeEntry<const char *>(const QByteArray &key, const char * const &value, KConfigBase::WriteConfigFlags pFlags);
-template<>
-KDECORE_EXPORT void KConfigGroup::writeEntry<QString>(const QByteArray &key, const QString &value, KConfigBase::WriteConfigFlags pFlags);
-template<>
-KDECORE_EXPORT void KConfigGroup::writeEntry<QByteArray>(const QByteArray &key, const QByteArray &value, KConfigBase::WriteConfigFlags pFlags);
-template<>
-KDECORE_EXPORT void KConfigGroup::writeEntry<QStringList>(const QByteArray &key, const QStringList &value, KConfigBase::WriteConfigFlags pFlags);
-template<>
-KDECORE_EXPORT void KConfigGroup::writeEntry<QVariantList>(const QByteArray &key, const QVariantList &value, KConfigBase::WriteConfigFlags pFlags);
-
 template <typename T>
-void KConfigGroup::writeListCheck( const QByteArray &key, const QList<T>& list,
-                              WriteConfigFlags pFlags )
+void KConfigGroup::writeListCheck( const char* key, const QList<T>& list,
+                                   WriteConfigFlags pFlags )
 {
   ConversionCheck::to_QVariant<T>();
   ConversionCheck::to_QString<T>();
-
   QVariantList data;
   Q_FOREACH(const T &value, list)
     data.append(qVariantFromValue(value));
@@ -548,7 +650,7 @@
 }
 
 template <typename T>
-inline void KConfigGroup::writeListCheck( const QByteArray &key, const T& value,
+void KConfigGroup::writeListCheck( const char* key, const T& value,
                               WriteConfigFlags pFlags )
 {
   ConversionCheck::to_QVariant<T>();
Index: kdecore/config/kconfig_p.h
===================================================================
--- kdecore/config/kconfig_p.h	(revision 733566)
+++ kdecore/config/kconfig_p.h	(working copy)
@@ -49,12 +49,12 @@
     void changeFileName(const QString& fileName, const char* resourceType);
 
     // functions for KConfigGroup
-    bool canWriteEntry(const QByteArray& group, const QByteArray& key, bool isDefault=false) const;
-    QString lookupData(const QByteArray& group, const QByteArray& key, KEntryMap::SearchFlags flags,
+    bool canWriteEntry(const QByteArray& group, const char* key, bool isDefault=false) const;
+    QString lookupData(const QByteArray& group, const char* key, KEntryMap::SearchFlags flags,
                        bool* expand) const;
-    QByteArray lookupData(const QByteArray& group, const QByteArray& key, KEntryMap::SearchFlags flags) const;
+    QByteArray lookupData(const QByteArray& group, const char* key, KEntryMap::SearchFlags flags) const;
 
-    void putData(const QByteArray& group, const QByteArray& key, const QByteArray& value,
+    void putData(const QByteArray& group, const char* key, const QByteArray& value,
                  KConfigBase::WriteConfigFlags flags, bool expand=false);
     QStringList groupList(const QByteArray& group) const;
 
Index: kdecore/config/ksharedconfig.cpp
===================================================================
--- kdecore/config/ksharedconfig.cpp	(revision 733566)
+++ kdecore/config/ksharedconfig.cpp	(working copy)
@@ -76,11 +76,11 @@
 KConfigGroup KSharedConfig::groupImpl(const QByteArray &groupName)
 {
     KSharedConfigPtr ptr(this);
-    return KConfigGroup( ptr, groupName);
+    return KConfigGroup( ptr, groupName.constData());
 }
 
 const KConfigGroup KSharedConfig::groupImpl(const QByteArray &groupName) const
 {
     const KSharedConfigPtr ptr(const_cast<KSharedConfig*>(this));
-    return KConfigGroup( ptr, groupName);
+    return KConfigGroup( ptr, groupName.constData());
 }
Index: kdecore/config/kconfig.cpp
===================================================================
--- kdecore/config/kconfig.cpp	(revision 733566)
+++ kdecore/config/kconfig.cpp	(working copy)
@@ -535,14 +535,14 @@
     return d->bForceGlobal;
 }
 
-KConfigGroup KConfig::groupImpl(const QByteArray &arr)
+KConfigGroup KConfig::groupImpl(const QByteArray &group)
 {
-    return KConfigGroup(this, arr);
+    return KConfigGroup(this, group.constData());
 }
 
-const KConfigGroup KConfig::groupImpl(const QByteArray &a) const
+const KConfigGroup KConfig::groupImpl(const QByteArray &group) const
 {
-    return KConfigGroup(this, a);
+    return KConfigGroup(this, group.constData());
 }
 
 KEntryMap::EntryOptions convertToOptions(KConfig::WriteConfigFlags flags)
@@ -608,7 +608,7 @@
     return d->entryMap.hasEntry(aGroup);
 }
 
-bool KConfigPrivate::canWriteEntry(const QByteArray& group, const QByteArray& key, bool isDefault) const
+bool KConfigPrivate::canWriteEntry(const QByteArray& group, const char* key, bool isDefault) const
 {
     if (bFileImmutable ||
         entryMap.getEntryOption(group, key, KEntryMap::SearchLocalized, KEntryMap::EntryImmutable))
@@ -616,7 +616,7 @@
     return true;
 }
 
-void KConfigPrivate::putData( const QByteArray& group, const QByteArray& key,
+void KConfigPrivate::putData( const QByteArray& group, const char* key,
                       const QByteArray& value, KConfigBase::WriteConfigFlags flags, bool expand)
 {
     // the KConfig object is dirty now
@@ -639,7 +639,7 @@
     entryMap.setEntry(group, key, value, options);
 }
 
-QByteArray KConfigPrivate::lookupData(const QByteArray& group, const QByteArray& key,
+QByteArray KConfigPrivate::lookupData(const QByteArray& group, const char* key,
                                       KEntryMap::SearchFlags flags) const
 {
     if (bReadDefaults)
@@ -650,7 +650,7 @@
     return it->mValue;
 }
 
-QString KConfigPrivate::lookupData(const QByteArray& group, const QByteArray& key,
+QString KConfigPrivate::lookupData(const QByteArray& group, const char* key,
                                    KEntryMap::SearchFlags flags, bool *expand) const
 {
     if (bReadDefaults)
Index: kdecore/config/kconfiggroup_p.h
===================================================================
--- kdecore/config/kconfiggroup_p.h	(revision 733566)
+++ kdecore/config/kconfiggroup_p.h	(working copy)
@@ -28,9 +28,9 @@
 
 struct KConfigGroupGui
 {
-    typedef bool (*kReadEntryGui)(const QByteArray& data, const QByteArray &key, const QVariant &input,
+    typedef bool (*kReadEntryGui)(const QByteArray& data, const char* key, const QVariant &input,
                                   QVariant &output);
-    typedef bool (*kWriteEntryGui)(KConfigGroup *, const QByteArray &key, const QVariant &input,
+    typedef bool (*kWriteEntryGui)(KConfigGroup *, const char* key, const QVariant &input,
                                    KConfigGroup::WriteConfigFlags flags);
 
     kReadEntryGui readEntryGui;
Index: kdecore/config/kconfiggroup.cpp
===================================================================
--- kdecore/config/kconfiggroup.cpp	(revision 733566)
+++ kdecore/config/kconfiggroup.cpp	(working copy)
@@ -482,14 +482,14 @@
    // if the path is already relative to another directory
    if ((!startsWithFile && QFileInfo(path).isRelative()) ||
        (startsWithFile && QFileInfo(path.mid(5)).isRelative()))
-	return path;
+   return path;
 
    if (startsWithFile)
-        path.remove(0,5); // strip leading "file:/" off the string
+       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);
+       path.remove(0,1);
 
    // we can not use KGlobal::dirs()->relativeLocation("home", path) here,
    // since it would not recognize paths without a trailing '/'.
@@ -521,7 +521,7 @@
 }
 
 KConfigGroupGui _kde_internal_KConfigGroupGui;
-static inline bool readEntryGui(const QByteArray& data, const QByteArray &key, const QVariant &input,
+static inline bool readEntryGui(const QByteArray& data, const char* key, const QVariant &input,
                                 QVariant &output)
 {
   if (_kde_internal_KConfigGroupGui.readEntryGui)
@@ -529,7 +529,7 @@
   return false;
 }
 
-static inline bool writeEntryGui(KConfigGroup *cg, const QByteArray &key, const QVariant &input,
+static inline bool writeEntryGui(KConfigGroup *cg, const char* key, const QVariant &input,
                                  KConfigGroup::WriteConfigFlags flags)
 {
   if (_kde_internal_KConfigGroupGui.writeEntryGui)
@@ -542,11 +542,6 @@
 {
 }
 
-KConfigGroup::KConfigGroup(KConfigBase *master, const QByteArray &_group)
- : d(KConfigGroupPrivate::create(master, _group, master->isGroupImmutable(_group), false))
-{
-}
-
 KConfigGroup::KConfigGroup(KConfigBase *master, const char *_group)
  : d(KConfigGroupPrivate::create(master, _group, master->isGroupImmutable(_group), false))
 {
@@ -557,11 +552,6 @@
 {
 }
 
-KConfigGroup::KConfigGroup(const KConfigBase *master, const QByteArray &_group)
-    : d(KConfigGroupPrivate::create(const_cast<KConfigBase*>(master), _group, master->isGroupImmutable(_group), true))
-{
-}
-
 KConfigGroup::KConfigGroup(const KConfigBase *master, const char * _group)
     : d(KConfigGroupPrivate::create(const_cast<KConfigBase*>(master), _group, master->isGroupImmutable(_group), true))
 {
@@ -572,11 +562,6 @@
 {
 }
 
-KConfigGroup::KConfigGroup(const KSharedConfigPtr &master, const QByteArray &_group)
-    : d(new KConfigGroupPrivate(master, _group))
-{
-}
-
 KConfigGroup::KConfigGroup(const KSharedConfigPtr &master, const char * _group)
     : d(new KConfigGroupPrivate(master, _group))
 {
@@ -635,16 +620,11 @@
 
 void KConfigGroup::changeGroup( const QString &group )
 {
-    changeGroup(group.toUtf8());
+    changeGroup(group.toUtf8().constData());
 }
 
 void KConfigGroup::changeGroup( const char *group )
 {
-    changeGroup(QByteArray(group));
-}
-
-void KConfigGroup::changeGroup( const QByteArray &group)
-{
     Q_ASSERT_X(isValid(), "KConfigGroup::changeGroup", "accessing an invalid group");
 
     // detach (QExplicitlySharedDataPointer takes care of deleting the old d if necessary)
@@ -695,7 +675,7 @@
     return d->mOwner;
 }
 
-bool KConfigGroup::isEntryImmutable(const QByteArray& key) const
+bool KConfigGroup::isEntryImmutable(const char* key) const
 {
     Q_ASSERT_X(isValid(), "KConfigGroup::isEntryImmutable", "accessing an invalid group");
 
@@ -703,28 +683,18 @@
         !config()->d_func()->canWriteEntry(d->fullName(), key, config()->readDefaults()));
 }
 
-bool KConfigGroup::isEntryImmutable(const char* key) const
-{
-    return isEntryImmutable(QByteArray(key));
-}
-
 bool KConfigGroup::isEntryImmutable(const QString& key) const
 {
-    return isEntryImmutable(key.toUtf8());
+    return isEntryImmutable(key.toUtf8().constData());
 }
 
 QString KConfigGroup::readEntryUntranslated(const QString& pKey, const QString& aDefault) const
 {
-    return readEntryUntranslated(pKey.toUtf8(), aDefault);
+    return readEntryUntranslated(pKey.toUtf8().constData(), aDefault);
 }
 
 QString KConfigGroup::readEntryUntranslated(const char *key, const QString& aDefault) const
 {
-    return readEntryUntranslated(QByteArray(key), aDefault);
-}
-
-QString KConfigGroup::readEntryUntranslated( const QByteArray& key, const QString& aDefault ) const
-{
     Q_ASSERT_X(isValid(), "KConfigGroup::readEntryUntranslated", "accessing an invalid group");
 
     QString result = config()->d_func()->lookupData(d->fullName(), key, KEntryMap::SearchFlags(), 0);
@@ -735,22 +705,16 @@
 
 QString KConfigGroup::readEntry(const char *key, const char* aDefault) const
 {
-    return readEntry(QByteArray(key), aDefault);
+    return readEntry(key, QString::fromUtf8(aDefault));
 }
 
 QString KConfigGroup::readEntry(const QString &key, const char* aDefault) const
 {
-    return readEntry(key.toUtf8(), aDefault);
+    return readEntry(key.toUtf8().constData(), aDefault);
 }
 
-QString KConfigGroup::readEntry(const QByteArray &key, const char* aDefault) const
+QString KConfigGroup::readEntry(const char* key, const QString& aDefault) const
 {
-    return readEntry(key, QString::fromUtf8(aDefault));
-}
-
-template <>
-QString KConfigGroup::readEntry<QString>( const QByteArray& key, const QString& aDefault ) const
-{
     Q_ASSERT_X(isValid(), "KConfigGroup::readEntry", "accessing an invalid group");
 
     bool expand = false;
@@ -767,9 +731,13 @@
     return aValue;
 }
 
-template<>
-QStringList KConfigGroup::readEntry<QStringList>(const QByteArray &key, const QStringList& aDefault) const
+QString KConfigGroup::readEntry(const QString &key, const QString& aDefault) const
 {
+    return readEntry(key.toUtf8().constData(), aDefault);
+}
+
+QStringList KConfigGroup::readEntry(const char* key, const QStringList& aDefault) const
+{
     Q_ASSERT_X(isValid(), "KConfigGroup::readEntry", "accessing an invalid group");
 
     const QString data = readEntry(key, QString());
@@ -779,9 +747,13 @@
     return KConfigGroupPrivate::deserializeList(data);
 }
 
-template<>
-QVariant KConfigGroup::readEntry<QVariant>( const QByteArray &key, const QVariant &aDefault ) const
+QStringList KConfigGroup::readEntry( const QString& key, const QStringList& aDefault) const
 {
+    return readEntry( key.toUtf8().constData(), aDefault );
+}
+
+QVariant KConfigGroup::readEntry( const char* key, const QVariant &aDefault ) const
+{
     Q_ASSERT_X(isValid(), "KConfigGroup::readEntry", "accessing an invalid group");
 
     const QByteArray data = config()->d_func()->lookupData(d->fullName(), key, KEntryMap::SearchFlags());
@@ -795,9 +767,13 @@
     return value;
 }
 
-template<>
-QVariantList KConfigGroup::readEntry<QVariantList>( const QByteArray &key, const QVariantList& aDefault) const
+QVariant KConfigGroup::readEntry( const QString& key, const QVariant& aDefault) const
 {
+    return readEntry( key.toUtf8().constData(), aDefault );
+}
+
+QVariantList KConfigGroup::readEntry( const char* key, const QVariantList& aDefault) const
+{
     Q_ASSERT_X(isValid(), "KConfigGroup::readEntry", "accessing an invalid group");
 
     const QString data = readEntry(key, QString());
@@ -811,17 +787,17 @@
     return value;
 }
 
-QStringList KConfigGroup::readXdgListEntry(const QString& pKey, const QStringList& aDefault) const
+QVariantList KConfigGroup::readEntry( const QString& key, const QVariantList& aDefault) const
 {
-    return readXdgListEntry(pKey.toUtf8(), aDefault);
+    return readEntry( key.toUtf8().constData(), aDefault );
 }
 
-QStringList KConfigGroup::readXdgListEntry(const char *key, const QStringList& aDefault) const
+QStringList KConfigGroup::readXdgListEntry(const QString& key, const QStringList& aDefault) const
 {
-    return readXdgListEntry(QByteArray(key), aDefault);
+    return readXdgListEntry(key.toUtf8().constData(), aDefault);
 }
 
-QStringList KConfigGroup::readXdgListEntry(const QByteArray &key, const QStringList& aDefault) const
+QStringList KConfigGroup::readXdgListEntry(const char *key, const QStringList& aDefault) const
 {
     Q_ASSERT_X(isValid(), "KConfigGroup::readXdgListEntry", "accessing an invalid group");
 
@@ -858,16 +834,11 @@
 
 QString KConfigGroup::readPathEntry(const QString& pKey, const QString & aDefault) const
 {
-    return readPathEntry(pKey.toUtf8(), aDefault);
+    return readPathEntry(pKey.toUtf8().constData(), aDefault);
 }
 
 QString KConfigGroup::readPathEntry(const char *key, const QString & aDefault) const
 {
-    return readPathEntry(QByteArray(key), aDefault);
-}
-
-QString KConfigGroup::readPathEntry(const QByteArray &key, const QString& aDefault) const
-{
     Q_ASSERT_X(isValid(), "KConfigGroup::readPathEntry", "accessing an invalid group");
 
     bool expand = false;
@@ -882,16 +853,11 @@
 
 QStringList KConfigGroup::readPathEntry(const QString& pKey, const QStringList& aDefault) const
 {
-    return readPathEntry(pKey.toUtf8(), aDefault);
+    return readPathEntry(pKey.toUtf8().constData(), aDefault);
 }
 
 QStringList KConfigGroup::readPathEntry(const char *key, const QStringList& aDefault) const
 {
-    return readPathEntry(QByteArray(key), aDefault);
-}
-
-QStringList KConfigGroup::readPathEntry( const QByteArray &key, const QStringList& aDefault ) const
-{
     Q_ASSERT_X(isValid(), "KConfigGroup::readPathEntry", "accessing an invalid group");
 
     const QString data = readPathEntry(key, QString());
@@ -901,8 +867,7 @@
     return KConfigGroupPrivate::deserializeList(data);
 }
 
-template<>
-void KConfigGroup::writeEntry<QString>( const QByteArray &key, const QString& value, WriteConfigFlags flags )
+void KConfigGroup::writeEntry( const char* key, const QString& value, WriteConfigFlags flags )
 {
     Q_ASSERT_X(isValid(), "KConfigGroup::writeEntry", "accessing an invalid group");
     Q_ASSERT_X(!d->bConst, "KConfigGroup::writeEntry", "writing to a read-only group");
@@ -910,9 +875,9 @@
     writeEntry(key, value.toUtf8(), flags);
 }
 
-void KConfigGroup::writeEntry(const QByteArray &key, const char *value, WriteConfigFlags pFlags)
+void KConfigGroup::writeEntry( const QString& key, const QString& value, WriteConfigFlags flags )
 {
-    writeEntry<const char *>(key, value, pFlags);
+    writeEntry(key.toUtf8().constData(), value, flags);
 }
 
 void KConfigGroup::writeEntry(const QString &key, const char *value, WriteConfigFlags pFlags)
@@ -920,33 +885,31 @@
     Q_ASSERT_X(isValid(), "KConfigGroup::writeEntry", "accessing an invalid group");
     Q_ASSERT_X(!d->bConst, "KConfigGroup::writeEntry", "writing to a read-only group");
 
-    writeEntry<const char *>(key.toUtf8(), value, pFlags);
+    writeEntry(key.toUtf8().constData(), QVariant(value), pFlags);
 }
 
 void KConfigGroup::writeEntry(const char *key, const char *value, WriteConfigFlags pFlags)
 {
-    writeEntry<const char *>(QByteArray(key), value, pFlags);
+    writeEntry(key, QVariant(value), pFlags);
 }
 
-template<>
-void KConfigGroup::writeEntry<const char *>(const QByteArray &key, const char* const &value, WriteConfigFlags flags)
+void KConfigGroup::writeEntry( const char* key, const QByteArray& value,
+                               WriteConfigFlags flags )
 {
-    writeEntry(key, QByteArray(value), flags);
-}
-
-template<>
-void KConfigGroup::writeEntry<QByteArray>( const QByteArray &key, const QByteArray& value,
-                     WriteConfigFlags flags )
-{
     Q_ASSERT_X(isValid(), "KConfigGroup::writeEntry", "accessing an invalid group");
     Q_ASSERT_X(!d->bConst, "KConfigGroup::writeEntry", "writing to a read-only group");
 
     config()->d_func()->putData(d->fullName(), key, value.isNull()? QByteArray(""): value, flags);
 }
 
-template<>
-void KConfigGroup::writeEntry<QStringList>(const QByteArray &key, const QStringList &list, WriteConfigFlags flags)
+void KConfigGroup::writeEntry(const QString& key, const QByteArray& value,
+                              WriteConfigFlags pFlags)
 {
+    writeEntry(key.toUtf8().constData(), value, pFlags);
+}
+
+void KConfigGroup::writeEntry(const char* key, const QStringList &list, WriteConfigFlags flags)
+{
     Q_ASSERT_X(isValid(), "KConfigGroup::writeEntry", "accessing an invalid group");
     Q_ASSERT_X(!d->bConst, "KConfigGroup::writeEntry", "writing to a read-only group");
 
@@ -958,9 +921,13 @@
     writeEntry(key, KConfigGroupPrivate::serializeList(balist), flags);
 }
 
-template<>
-void KConfigGroup::writeEntry<QVariantList>( const QByteArray &key, const QVariantList& list, WriteConfigFlags flags )
+void KConfigGroup::writeEntry(const QString& key, const QStringList &list, WriteConfigFlags flags)
 {
+    writeEntry(key.toUtf8().constData(), list, flags);
+}
+
+void KConfigGroup::writeEntry( const char* key, const QVariantList& list, WriteConfigFlags flags )
+{
     Q_ASSERT_X(isValid(), "KConfigGroup::writeEntry", "accessing an invalid group");
     Q_ASSERT_X(!d->bConst, "KConfigGroup::writeEntry", "writing to a read-only group");
 
@@ -976,8 +943,7 @@
     writeEntry(key, KConfigGroupPrivate::serializeList(data), flags);
 }
 
-template<>
-void KConfigGroup::writeEntry<QVariant> ( const QByteArray &key, const QVariant &value,
+void KConfigGroup::writeEntry( const char* key, const QVariant &value,
                                WriteConfigFlags flags )
 {
     Q_ASSERT_X(isValid(), "KConfigGroup::writeEntry", "accessing an invalid group");
@@ -1122,18 +1088,23 @@
     writeEntry(key, data, flags);
 }
 
-void KConfigGroup::writeXdgListEntry(const QString& pKey, const QStringList &value, WriteConfigFlags pFlags)
+void KConfigGroup::writeEntry( const QString& key, const QVariant& value, WriteConfigFlags flags )
 {
-    writeXdgListEntry(pKey.toUtf8(), value, pFlags);
+    writeEntry(key.toUtf8().constData(), value, flags);
 }
 
-void KConfigGroup::writeXdgListEntry(const char *pKey, const QStringList &value, WriteConfigFlags pFlags)
+void KConfigGroup::writeEntry(const QString& key, const QVariantList &list, WriteConfigFlags flags)
 {
-    writeXdgListEntry(QByteArray(pKey), value, pFlags);
+    writeEntry(key.toUtf8().constData(), list, flags);
 }
 
-void KConfigGroup::writeXdgListEntry(const QByteArray &key, const QStringList &list, WriteConfigFlags flags)
+void KConfigGroup::writeXdgListEntry(const QString& key, const QStringList &value, WriteConfigFlags pFlags)
 {
+    writeXdgListEntry(key.toUtf8().constData(), value, pFlags);
+}
+
+void KConfigGroup::writeXdgListEntry(const char *key, const QStringList &list, WriteConfigFlags flags)
+{
     Q_ASSERT_X(isValid(), "KConfigGroup::writeXdgListEntry", "accessing an invalid group");
     Q_ASSERT_X(!d->bConst, "KConfigGroup::writeXdgListEntry", "writing to a read-only group");
 
@@ -1156,34 +1127,24 @@
 
 void KConfigGroup::writePathEntry(const QString& pKey, const QString & path, WriteConfigFlags pFlags)
 {
-    writePathEntry(pKey.toUtf8(), path, pFlags);
+    writePathEntry(pKey.toUtf8().constData(), path, pFlags);
 }
 
 void KConfigGroup::writePathEntry(const char *pKey, const QString & path, WriteConfigFlags pFlags)
 {
-    writePathEntry(QByteArray(pKey), path, pFlags);
-}
-
-void KConfigGroup::writePathEntry(const QByteArray &key, const QString &path, WriteConfigFlags flags)
-{
     Q_ASSERT_X(isValid(), "KConfigGroup::writePathEntry", "accessing an invalid group");
     Q_ASSERT_X(!d->bConst, "KConfigGroup::writePathEntry", "writing to a read-only group");
 
-    config()->d_func()->putData(d->fullName(), key, translatePath(path).toUtf8(), flags, true);
+    config()->d_func()->putData(d->fullName(), pKey, translatePath(path).toUtf8(), pFlags, true);
 }
 
 void KConfigGroup::writePathEntry(const QString& pKey, const QStringList &value, WriteConfigFlags pFlags)
 {
-    writePathEntry(pKey.toUtf8(), value, pFlags);
+    writePathEntry(pKey.toUtf8().constData(), value, pFlags);
 }
 
 void KConfigGroup::writePathEntry(const char *pKey, const QStringList &value, WriteConfigFlags pFlags)
 {
-    writePathEntry(QByteArray(pKey), value, pFlags);
-}
-
-void KConfigGroup::writePathEntry(const QByteArray &key, const QStringList &value, WriteConfigFlags flags)
-{
     Q_ASSERT_X(isValid(), "KConfigGroup::writePathEntry", "accessing an invalid group");
     Q_ASSERT_X(!d->bConst, "KConfigGroup::writePathEntry", "writing to a read-only group");
 
@@ -1191,10 +1152,10 @@
     foreach(const QString& path, value)
         list << translatePath(path).toUtf8();
 
-    config()->d_func()->putData(d->fullName(), key, KConfigGroupPrivate::serializeList(list), flags, true);
+    config()->d_func()->putData(d->fullName(), pKey, KConfigGroupPrivate::serializeList(list), pFlags, true);
 }
 
-void KConfigGroup::deleteEntry(const QByteArray& key, WriteConfigFlags flags)
+void KConfigGroup::deleteEntry( const char *key, WriteConfigFlags flags)
 {
     Q_ASSERT_X(isValid(), "KConfigGroup::deleteEntry", "accessing an invalid group");
     Q_ASSERT_X(!d->bConst, "KConfigGroup::deleteEntry", "deleting from a read-only group");
@@ -1204,16 +1165,11 @@
 
 void KConfigGroup::deleteEntry( const QString& key, WriteConfigFlags flags)
 {
-    deleteEntry(key.toUtf8(), flags);
+    deleteEntry(key.toUtf8().constData(), flags);
 }
 
-void KConfigGroup::deleteEntry( const char *key, WriteConfigFlags flags)
+void KConfigGroup::revertToDefault(const char *key)
 {
-    deleteEntry(QByteArray(key), flags);
-}
-
-void KConfigGroup::revertToDefault(const QByteArray& key)
-{
     Q_ASSERT_X(isValid(), "KConfigGroup::revertToDefault", "accessing an invalid group");
     Q_ASSERT_X(!d->bConst, "KConfigGroup::revertToDefault", "writing to a read-only group");
 
@@ -1223,17 +1179,12 @@
     config()->d_func()->putData(d->fullName(), key, theDefault, KConfig::Normal);
 }
 
-void KConfigGroup::revertToDefault(const char *key)
-{
-    revertToDefault(QByteArray(key));
-}
-
 void KConfigGroup::revertToDefault(const QString &key)
 {
-    revertToDefault(key.toUtf8());
+    revertToDefault(key.toUtf8().constData());
 }
 
-bool KConfigGroup::hasDefault(const QByteArray& key) const
+bool KConfigGroup::hasDefault(const char *key) const
 {
     Q_ASSERT_X(isValid(), "KConfigGroup::hasDefault", "accessing an invalid group");
 
@@ -1242,17 +1193,12 @@
     return !config()->d_func()->lookupData(d->fullName(), key, flags).isNull();
 }
 
-bool KConfigGroup::hasDefault(const char *key) const
-{
-    return hasDefault(QByteArray(key));
-}
-
 bool KConfigGroup::hasDefault(const QString &key) const
 {
-    return hasDefault(key.toUtf8());
+    return hasDefault(key.toUtf8().constData());
 }
 
-bool KConfigGroup::hasKey(const QByteArray& key) const
+bool KConfigGroup::hasKey(const char *key) const
 {
     Q_ASSERT_X(isValid(), "KConfigGroup::hasKey", "accessing an invalid group");
 
@@ -1265,14 +1211,9 @@
 
 bool KConfigGroup::hasKey(const QString &key) const
 {
-   return hasKey(key.toUtf8());
+   return hasKey(key.toUtf8().constData());
 }
 
-bool KConfigGroup::hasKey(const char *key) const
-{
-    return hasKey(QByteArray(key));
-}
-
 bool KConfigGroup::isImmutable() const
 {
     Q_ASSERT_X(isValid(), "KConfigGroup::isImmutable", "accessing an invalid group");