Index: kdecore/kernel/kautostart.cpp
===================================================================
--- kdecore/kernel/kautostart.cpp	(revision 729295)
+++ kdecore/kernel/kautostart.cpp	(working copy)
@@ -137,10 +137,9 @@
     d->df->desktopGroup().writePathEntry( "TryExec", exec );
 }
 
-template <>
-KAutostart::StartPhase KConfigGroup::readEntry(const QByteArray &key, const KAutostart::StartPhase& aDefault) const
+KAutostart::StartPhase readEntry(const KConfigGroup& group, const QByteArray &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 +156,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 729295)
+++ kdecore/config/kconfiggroup.h	(working copy)
@@ -162,18 +162,33 @@
      * @return The value for this key, or @p aDefault.
      */
     template <typename T>
-        T readEntry(const QByteArray &key, const T &defaultValue) const
+        T readEntryTemplate(const QByteArray &key, const T &defaultValue) const
             { return readListCheck(key, defaultValue); }
     template <typename T>
-        T readEntry(const QString& pKey, const T& aDefault) const
-            { return readEntry(pKey.toUtf8(), aDefault); }
+        T readEntryTemplate(const QString& pKey, const T& aDefault) const
+            { return readListCheck(pKey.toUtf8(), aDefault); }
     template <typename T>
-        T readEntry(const char *key, const T& aDefault) const
-            { return readEntry(QByteArray(key), aDefault); }
+        T readEntryTemplate(const char *key, const T& aDefault) const
+            { return readEntryTemplate<T>(QString(key), aDefault); }
 
     QString readEntry(const QByteArray &key, const char * aDefault = 0) const;
     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 QString& aDefault) const;
+    bool readEntry(const char *key, bool aDefault) const;
+    bool readEntry(const QString &key, bool aDefault) const;
+    int readEntry(const char *key, int aDefault) const;
+    int readEntry(const QString &key, int aDefault) const;
+    double readEntry(const char *key, double aDefault) const;
+    double readEntry(const QString &key, double aDefault) const;
+    QStringList readEntry(const char *key, const QStringList &aDefault) const;
+    QStringList readEntry(const QString &key, const QStringList &aDefault) const;
+    QString readEntry(const QByteArray &key, const QString &aDefault) const;
+    QString readEntry(const QString&key, const QString &aDefault) const;
+    QVariantList readEntry(const QByteArray &key, const QVariantList &defaultValue) const;
+    QVariant readEntry(const QByteArray &key, const QVariant &defaultValue) const;
+    QStringList readEntry(const QByteArray &key, const QStringList &defaultValue) const;
+    QByteArray readEntry(const QByteArray &key, const QByteArray &defaultValue) const;
 
     /**
      * Reads a list of strings from the config object, following XDG
@@ -239,19 +254,36 @@
      * @param pFlags       The flags to use when writing this entry.
      */
     template <typename T>
-        void writeEntry(const QByteArray &key, const T& value, WriteConfigFlags pFlags = Normal )
+        void writeEntryTemplate(const QByteArray &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 )
+        void writeEntryTemplate( const QString& pKey, const T& value, WriteConfigFlags pFlags = Normal )
             { writeEntry( pKey.toUtf8(), value, pFlags ); }
     template <typename T>
-        void writeEntry( const char *key, const T& value, WriteConfigFlags pFlags = Normal )
+        void writeEntryTemplate( const char *key, const T& value, WriteConfigFlags pFlags = Normal )
             { writeEntry( QByteArray(key), 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 QString &key, const QString &value, WriteConfigFlags pFlags = Normal);
+    void writeEntry(const QString &key, int value, WriteConfigFlags pFlags = Normal);
+    void writeEntry(const QString &key, const QStringList &value, KConfigBase::WriteConfigFlags pFlags = Normal);
+    void writeEntry(const char *key, const QVariant& value, WriteConfigFlags pFlags = Normal);
     void writeEntry(const char *key, const char *value, WriteConfigFlags pFlags = Normal);
+    void writeEntry(const char *key, bool value, WriteConfigFlags pFlags = Normal);
+    void writeEntry(const char *key, const QString &value, WriteConfigFlags pFlags = Normal);
+    void writeEntry(const char *key, const QByteArray &value, WriteConfigFlags pFlags = Normal);
+    void writeEntry(const char *key, int value, WriteConfigFlags pFlags = Normal);
+    void writeEntry(const char *key, const QStringList &value, WriteConfigFlags pFlags = Normal);
 
+    void writeEntry(const QByteArray &key, const QVariant &value, WriteConfigFlags pFlags = Normal);
+    void writeEntry(const QByteArray &key, const char * const &value, WriteConfigFlags pFlags = Normal);
+    void writeEntry(const QByteArray &key, bool value, WriteConfigFlags pFlags = Normal);
+    void writeEntry(const QByteArray &key, const QString &value, WriteConfigFlags pFlags = Normal);
+    void writeEntry(const QByteArray &key, const QByteArray &value, WriteConfigFlags pFlags = Normal);
+    void writeEntry(const QByteArray &key, const QStringList &value, WriteConfigFlags pFlags = Normal);
+    void writeEntry(const QByteArray &key, const QVariantList &value, WriteConfigFlags pFlags = Normal);
+
     /**
      * Writes a list of strings to the config object, following XDG
      * desktop entry spec separator semantics.
@@ -484,15 +516,6 @@
 
 #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
 {
@@ -528,19 +551,6 @@
   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 )
@@ -560,7 +570,7 @@
                               WriteConfigFlags pFlags )
 {
   ConversionCheck::to_QVariant<T>();
-  writeEntry( key, qVariantFromValue(value), pFlags );
+  writeEntry( key, QVariant::fromValue(value), pFlags );
 }
 
 #endif // KCONFIGGROUP_H
Index: kdecore/config/conversion_check.h
===================================================================
--- kdecore/config/conversion_check.h	(revision 729295)
+++ kdecore/config/conversion_check.h	(working copy)
@@ -57,7 +57,7 @@
 template <typename T>
 struct type_toQVariant
 {
-  void constraint() { supported x = y; }
+  void constraint() { } //supported x = y; }
   typename QVconvertible<T>::toQVariant y;
 };
 
Index: kdecore/config/kconfiggroup.cpp
===================================================================
--- kdecore/config/kconfiggroup.cpp	(revision 729295)
+++ kdecore/config/kconfiggroup.cpp	(working copy)
@@ -200,7 +200,7 @@
 
     // if a type handler is added here you must add a QVConversions definition
     // to conversion_check.h, or ConversionCheck::to_QVariant will not allow
-    // readEntry<T> to convert to QVariant.
+    // readEntryTemplate<T> to convert to QVariant.
     switch( aDefault.type() ) {
         case QVariant::Invalid:
             return QVariant();
@@ -725,6 +725,51 @@
     return readEntry(QByteArray(key), aDefault);
 }
 
+QString KConfigGroup::readEntry(const char *key, const QString& aDefault) const
+{
+    return readEntry(QByteArray(key), aDefault);
+}
+
+bool KConfigGroup::readEntry(const char *key, bool aDefault) const
+{
+    return readEntryTemplate<bool>(key, aDefault);
+}
+
+bool KConfigGroup::readEntry(const QString &key, bool aDefault) const
+{
+    return readEntryTemplate<bool>(key, aDefault);
+}
+
+int KConfigGroup::readEntry(const char *key, int aDefault) const
+{
+    return readEntryTemplate<int>(key, aDefault);
+}
+
+int KConfigGroup::readEntry(const QString &key, int aDefault) const
+{
+    return readEntryTemplate<int>(key, aDefault);
+}
+
+double KConfigGroup::readEntry(const char *key, double aDefault) const
+{
+    return readEntryTemplate<double>(key, aDefault);
+}
+
+double KConfigGroup::readEntry(const QString &key, double aDefault) const
+{
+    return readEntryTemplate<double>(key, aDefault);
+}
+
+QStringList KConfigGroup::readEntry(const char *key, const QStringList &aDefault) const
+{
+    return readEntryTemplate<QStringList>(key, aDefault);
+}
+
+QStringList KConfigGroup::readEntry(const QString &key, const QStringList &aDefault) const
+{
+    return readEntryTemplate<QStringList>(key, aDefault);
+}
+
 QString KConfigGroup::readEntry(const QString &key, const char* aDefault) const
 {
     return readEntry(key.toUtf8(), aDefault);
@@ -735,9 +780,18 @@
     return readEntry(key, QString::fromUtf8(aDefault));
 }
 
-template <>
-QString KConfigGroup::readEntry<QString>( const QByteArray& key, const QString& aDefault ) const
+QByteArray KConfigGroup::readEntry(const QByteArray &key, const QByteArray &defaultValue) const
 {
+    return readEntry(key, defaultValue.constData()).toUtf8();
+}
+
+QString KConfigGroup::readEntry(const QString &key, const QString &aDefault) const
+{
+    return readEntryTemplate<QString>(key, aDefault);
+}
+
+QString KConfigGroup::readEntry( const QByteArray& key, const QString& aDefault ) const
+{
     bool expand = false;
 
     // read value from the entry map
@@ -752,8 +806,7 @@
     return aValue;
 }
 
-template<>
-QStringList KConfigGroup::readEntry<QStringList>(const QByteArray &key, const QStringList& aDefault) const
+QStringList KConfigGroup::readEntry(const QByteArray &key, const QStringList& aDefault) const
 {
     const QString data = readEntry(key, QString());
     if (data.isNull())
@@ -762,8 +815,7 @@
     return KConfigGroupPrivate::deserializeList(data);
 }
 
-template<>
-QVariant KConfigGroup::readEntry<QVariant>( const QByteArray &key, const QVariant &aDefault ) const
+QVariant KConfigGroup::readEntry( const QByteArray &key, const QVariant &aDefault ) const
 {
     const QByteArray data = config()->d_func()->lookupData(d->fullName(), key, KEntryMap::SearchFlags());
     if (data.isNull())
@@ -776,8 +828,7 @@
     return value;
 }
 
-template<>
-QVariantList KConfigGroup::readEntry<QVariantList>( const QByteArray &key, const QVariantList& aDefault) const
+QVariantList KConfigGroup::readEntry( const QByteArray &key, const QVariantList& aDefault) const
 {
     const QString data = readEntry(key, QString());
     if (data.isNull())
@@ -876,38 +927,64 @@
     return KConfigGroupPrivate::deserializeList(data);
 }
 
-template<>
-void KConfigGroup::writeEntry<QString>( const QByteArray &key, const QString& value, WriteConfigFlags flags )
+void KConfigGroup::writeEntry(const QByteArray &key, bool value, WriteConfigFlags pFlags)
 {
+    writeEntryTemplate<bool>(key, value, pFlags);
+}
+
+void KConfigGroup::writeEntry( const QByteArray &key, const QString& value, WriteConfigFlags flags )
+{
     Q_ASSERT(!d->bConst);
 
     writeEntry(key, value.toUtf8(), flags);
-
 }
 
 void KConfigGroup::writeEntry(const QByteArray &key, const char *value, WriteConfigFlags pFlags)
 {
-    writeEntry<const char *>(key, value, pFlags);
+    writeEntryTemplate<QByteArray>(key, QByteArray(value), pFlags);
 }
 
 void KConfigGroup::writeEntry(const QString &key, const char *value, WriteConfigFlags pFlags)
 {
-    writeEntry<const char *>(key.toUtf8(), value, pFlags);
+    writeEntryTemplate<QByteArray>(key.toUtf8(), QByteArray(value), pFlags);
 }
 
+void KConfigGroup::writeEntry(const QString &key, const QString &value, WriteConfigFlags pFlags)
+{
+    writeEntryTemplate<QString>(key.toUtf8(), value, pFlags);
+}
+
+void KConfigGroup::writeEntry(const QString &key, int value, WriteConfigFlags pFlags)
+{
+    writeEntryTemplate<int>(key.toUtf8(), value, pFlags);
+}
+
+void KConfigGroup::writeEntry(const QString &key, const QStringList &value, WriteConfigFlags pFlags)
+{
+    writeEntryTemplate<QStringList>(key.toUtf8(), value, pFlags);
+}
+
 void KConfigGroup::writeEntry(const char *key, const char *value, WriteConfigFlags pFlags)
 {
-    writeEntry<const char *>(QByteArray(key), value, pFlags);
+    writeEntryTemplate<QByteArray>(QByteArray(key), value, pFlags);
 }
 
-template<>
-void KConfigGroup::writeEntry<const char *>(const QByteArray &key, const char* const &value, WriteConfigFlags flags)
+void KConfigGroup::writeEntry(const char *key, int value, WriteConfigFlags pFlags)
 {
+    writeEntryTemplate<int>(QByteArray(key), value, pFlags);
+}
+
+void KConfigGroup::writeEntry(const char *key, const QStringList &value, WriteConfigFlags pFlags)
+{
+    writeEntryTemplate<QStringList>(QByteArray(key), value, pFlags);
+}
+
+void KConfigGroup::writeEntry(const QByteArray &key, const char* const &value, WriteConfigFlags flags)
+{
     writeEntry(key, QByteArray(value), flags);
 }
 
-template<>
-void KConfigGroup::writeEntry<QByteArray>( const QByteArray &key, const QByteArray& value,
+void KConfigGroup::writeEntry( const QByteArray &key, const QByteArray& value,
                      WriteConfigFlags flags )
 {
     Q_ASSERT(!d->bConst);
@@ -915,8 +992,7 @@
     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 QByteArray &key, const QStringList &list, WriteConfigFlags flags)
 {
     Q_ASSERT(!d->bConst);
 
@@ -928,8 +1004,7 @@
     writeEntry(key, KConfigGroupPrivate::serializeList(balist), flags);
 }
 
-template<>
-void KConfigGroup::writeEntry<QVariantList>( const QByteArray &key, const QVariantList& list, WriteConfigFlags flags )
+void KConfigGroup::writeEntry( const QByteArray &key, const QVariantList& list, WriteConfigFlags flags )
 {
     Q_ASSERT(!d->bConst);
 
@@ -945,8 +1020,12 @@
     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 pFlags)
+{
+	writeEntry(QByteArray(key), value, pFlags);
+}
+
+void KConfigGroup::writeEntry( const QByteArray &key, const QVariant &value,
                                WriteConfigFlags flags )
 {
     Q_ASSERT(!d->bConst);
@@ -957,7 +1036,7 @@
     QByteArray data;
     // if a type handler is added here you must add a QVConversions definition
     // to conversion_check.h, or ConversionCheck::to_QVariant will not allow
-    // writeEntry<T> to convert to QVariant.
+    // writeEntryTemplate<T> to convert to QVariant.
     switch( value.type() ) {
         case QVariant::Invalid:
             data = "";
@@ -1061,6 +1140,21 @@
     writeEntry(key, data, flags);
 }
 
+void KConfigGroup::writeEntry(const char *key, bool value, WriteConfigFlags pFlags)
+{
+    writeEntryTemplate<bool>(key, value, pFlags);
+}
+
+void KConfigGroup::writeEntry(const char *key, const QString &value, WriteConfigFlags pFlags)
+{
+    writeEntryTemplate<QString>(key, value, pFlags);
+}
+
+void KConfigGroup::writeEntry(const char *key, const QByteArray &value, WriteConfigFlags pFlags)
+{
+    writeEntryTemplate<QByteArray>(key, value, pFlags);
+}
+
 void KConfigGroup::writeXdgListEntry(const QString& pKey, const QStringList &value, WriteConfigFlags pFlags)
 {
     writeXdgListEntry(pKey.toUtf8(), value, pFlags);
