Index: kdecore/config/kconfiggroup.h
===================================================================
--- kdecore/config/kconfiggroup.h	(revision 730754)
+++ kdecore/config/kconfiggroup.h	(working copy)
@@ -35,6 +35,7 @@
 class KConfig;
 class KConfigGroupPrivate;
 class KSharedConfig;
+class KUrl;
 template <typename T> class KSharedPtr;
 typedef KSharedPtr<KSharedConfig> KSharedConfigPtr;
 
@@ -162,19 +163,97 @@
      * @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 readListCheck(QByteArray(key), aDefault); }
 
+    template <typename T>
+        QList<T> readEntryTemplate(const QByteArray &key, const QList<T>& aDefault) const
+            { return readListCheck<T>(key, aDefault); }
+    template <typename T>
+        QList<T> readEntryTemplate(const QString &key, const QList<T>& aDefault) const
+            { return readListCheck<T>(key.toUtf8(), aDefault); }
+    template <typename T>
+        QList<T> readEntryTemplate(const char *key, const QList<T>& aDefault) const
+            { return readListCheck<T>(QByteArray(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 QByteArray &key, const QString &aDefault) const;
+    QString readEntry(const QString &key, const QString &aDefault) const;
+    QString readEntry(const char *key, const QString &aDefault) const;
+
+    QStringList readEntry(const QByteArray &key, const QStringList &defaultValue) const;
+    QStringList readEntry(const QString &key, const QStringList &aDefault) const;
+    QStringList readEntry(const char *key, const QStringList &aDefault) const;
+
+    QByteArray readEntry(const QByteArray &key, const QByteArray &defaultValue) const;
+    QByteArray readEntry(const QString &key, const QByteArray &defaultValue) const;
+    QByteArray readEntry(const char *key, const QByteArray &defaultValue) const;
+
+    QVariant readEntry(const QByteArray &key, const QVariant &defaultValue) const;
+    QVariant readEntry(const QString &key, const QVariant &defaultValue) const;
+    QVariant readEntry(const char *key, const QVariant &aDefault) const;
+
+    QVariantList readEntry(const QByteArray &key, const QVariantList &defaultValue) const;
+    QVariantList readEntry(const QString &key, const QVariantList &aDefault) const;
+    QVariantList readEntry(const char *key, const QVariantList &aDefault) const;
+
+    double readEntry(const QByteArray &key, double aDefault) const;
+    double readEntry(const QString &key, double aDefault) const;
+    double readEntry(const char *key, double aDefault) const;
+
+    bool readEntry(const QByteArray &key, bool aDefault) const;
+    bool readEntry(const QString &key, bool aDefault) const;
+    bool readEntry(const char *key, bool aDefault) const;
+
+    int readEntry(const QByteArray &key, int aDefault) const;
+    int readEntry(const QString &key, int aDefault) const;
+    int readEntry(const char *key, int aDefault) const;
+
+    uint readEntry(const QByteArray &key, uint aDefault) const;
+    uint readEntry(const QString &key, uint aDefault) const;
+    uint readEntry(const char *key, uint aDefault) const;
+
+    qlonglong readEntry(const QByteArray &key, qlonglong aDefault) const;
+    qlonglong readEntry(const QString &key, qlonglong aDefault) const;
+    qlonglong readEntry(const char *key, qlonglong aDefault) const;
+
+    qulonglong readEntry(const QByteArray &key, qulonglong aDefault) const;
+    qulonglong readEntry(const QString &key, qulonglong aDefault) const;
+    qulonglong readEntry(const char *key, qulonglong aDefault) const;
+
+    KUrl readEntry(const QByteArray &key, const KUrl& aDefault) const;
+    KUrl readEntry(const QString &key, const KUrl& aDefault) const;
+    KUrl readEntry(const char *key, const KUrl& aDefault) const;
+
+    QPoint readEntry(const QByteArray &key, const QPoint &aDefault) const;
+    QPoint readEntry(const QString &key, const QPoint &aDefault) const;
+    QPoint readEntry(const char *key, const QPoint &aDefault) const;
+
+    QSize readEntry(const QByteArray &key, const QSize &aDefault) const;
+    QSize readEntry(const QString &key, const QSize &aDefault) const;
+    QSize readEntry(const char *key, const QSize &aDefault) const;
+
+    QRect readEntry(const QByteArray &key, const QRect &aDefault) const;
+    QRect readEntry(const QString &key, const QRect &aDefault) const;
+    QRect readEntry(const char *key, const QRect &aDefault) const;
+
+    QDate readEntry(const QByteArray &key, const QDate &aDefault) const;
+    QDate readEntry(const QString &key, const QDate &aDefault) const;
+    QDate readEntry(const char *key, const QDate &aDefault) const;
+
+    QDateTime readEntry(const QByteArray &key, const QDateTime &aDefault) const;
+    QDateTime readEntry(const QString &key, const QDateTime &aDefault) const;
+    QDateTime readEntry(const char *key, const QDateTime &aDefault) const;
+
     /**
      * Reads a list of strings from the config object, following XDG
      * desktop entry spec separator semantics.
@@ -239,19 +318,64 @@
      * @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 ); }
 
+    template <typename T>
+        void writeEntry(const QByteArray &key, const QList<T>& value, WriteConfigFlags pFlags = Normal )
+            { writeListCheck<T>(key, value, pFlags); }
+    template <typename T>
+        void writeEntry(const QString& key, const QList<T>& value, WriteConfigFlags pFlags = Normal )
+            { writeListCheck<T>(key.toUtf8(), value, pFlags); }
+    template <typename T>
+        void writeEntry(const char *key, const QList<T>& value, WriteConfigFlags pFlags = Normal )
+            { writeListCheck<T>(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 QByteArray &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, qlonglong value, WriteConfigFlags pFlags = Normal);
+    void writeEntry(const QString &key, uint value, WriteConfigFlags pFlags = Normal);
+    void writeEntry(const QString &key, qulonglong value, WriteConfigFlags pFlags = Normal);
+    void writeEntry(const QString &key, double value, WriteConfigFlags pFlags = Normal);
+    void writeEntry(const QString &key, const QStringList &value, KConfigBase::WriteConfigFlags pFlags = Normal);
+    void writeEntry(const QString &key, const KUrl &value, KConfigBase::WriteConfigFlags pFlags = Normal);
+    void writeEntry(const QString &key, const QVariant& value, 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 char *key, const QVariantList &value, WriteConfigFlags pFlags = Normal);
+    void writeEntry(const char *key, qlonglong value, WriteConfigFlags pFlags = Normal);
+    void writeEntry(const char *key, uint value, WriteConfigFlags pFlags = Normal);
+    void writeEntry(const char *key, qulonglong value, WriteConfigFlags pFlags = Normal);
+    void writeEntry(const char *key, double value, WriteConfigFlags pFlags = Normal);
+    void writeEntry(const char *key, const KUrl &value, WriteConfigFlags pFlags = Normal);
 
+    void writeEntry(const QByteArray &key, const QVariant &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);
+    void writeEntry(const QByteArray &key, int value, WriteConfigFlags pFlags = Normal);
+    void writeEntry(const QByteArray &key, qlonglong value, WriteConfigFlags pFlags = Normal);
+    void writeEntry(const QByteArray &key, uint value, WriteConfigFlags pFlags = Normal);
+    void writeEntry(const QByteArray &key, qulonglong value, WriteConfigFlags pFlags = Normal);
+    void writeEntry(const QByteArray &key, double value, WriteConfigFlags pFlags = Normal);
+    void writeEntry(const QByteArray &key, const KUrl &value, WriteConfigFlags pFlags = Normal);
+
     /**
      * Writes a list of strings to the config object, following XDG
      * desktop entry spec separator semantics.
@@ -484,15 +608,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
 {
@@ -520,19 +635,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 )
@@ -552,7 +654,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 730754)
+++ 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 730754)
+++ kdecore/config/kconfiggroup.cpp	(working copy)
@@ -195,7 +195,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();
@@ -738,6 +738,111 @@
     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 readEntry(QByteArray(key), QVariant(aDefault)).toBool();
+}
+
+bool KConfigGroup::readEntry(const QString &key, bool aDefault) const
+{
+    return readEntry(key.toUtf8(), QVariant(aDefault)).toBool();
+}
+
+bool KConfigGroup::readEntry(const QByteArray &key, bool aDefault) const
+{
+    return readEntry(key, QVariant(aDefault)).toBool();
+}
+
+int KConfigGroup::readEntry(const char *key, int aDefault) const
+{
+    return readEntry(QByteArray(key), QVariant(aDefault)).toInt();
+}
+
+int KConfigGroup::readEntry(const QString &key, int aDefault) const
+{
+    return readEntry(key.toUtf8(), QVariant(aDefault)).toInt();
+}
+
+int KConfigGroup::readEntry(const QByteArray &key, int aDefault) const
+{
+    return readEntry(key, QVariant(aDefault)).toInt();
+}
+
+uint KConfigGroup::readEntry(const char *key, uint aDefault) const
+{
+    return readEntry(QByteArray(key), QVariant(aDefault)).toUInt();
+}
+
+uint KConfigGroup::readEntry(const QString &key, uint aDefault) const
+{
+    return readEntry(key.toUtf8(), QVariant(aDefault)).toUInt();
+}
+
+uint KConfigGroup::readEntry(const QByteArray &key, uint aDefault) const
+{
+    return readEntry(key, QVariant(aDefault)).toUInt();
+}
+
+qlonglong KConfigGroup::readEntry(const char *key, qlonglong aDefault) const
+{
+    return readEntry(QByteArray(key), QVariant(aDefault)).toLongLong();
+}
+
+qlonglong KConfigGroup::readEntry(const QString &key, qlonglong aDefault) const
+{
+    return readEntry(key.toUtf8(), QVariant(aDefault)).toLongLong();
+}
+
+qlonglong KConfigGroup::readEntry(const QByteArray &key, qlonglong aDefault) const
+{
+    return readEntry(key, QVariant(aDefault)).toLongLong();
+}
+
+qulonglong KConfigGroup::readEntry(const char *key, qulonglong aDefault) const
+{
+    return readEntry(QByteArray(key), QVariant(aDefault)).toULongLong();
+}
+
+qulonglong KConfigGroup::readEntry(const QString &key, qulonglong aDefault) const
+{
+    return readEntry(key.toUtf8(), QVariant(aDefault)).toULongLong();
+}
+
+qulonglong KConfigGroup::readEntry(const QByteArray &key, qulonglong aDefault) const
+{
+    return readEntry(key, QVariant(aDefault)).toULongLong();
+}
+
+double KConfigGroup::readEntry(const char *key, double aDefault) const
+{
+    return readEntry(QByteArray(key), QVariant(aDefault)).toDouble();
+}
+
+double KConfigGroup::readEntry(const QString &key, double aDefault) const
+{
+    return readEntry(key.toUtf8(), QVariant(aDefault)).toDouble();
+}
+
+double KConfigGroup::readEntry(const QByteArray &key, double aDefault) const
+{
+    return readEntry(key, QVariant(aDefault)).toDouble();
+}
+
+QStringList KConfigGroup::readEntry(const char *key, const QStringList &aDefault) const
+{
+    return readEntry(QByteArray(key), aDefault);
+}
+
+QStringList KConfigGroup::readEntry(const QString &key, const QStringList &aDefault) const
+{
+    return readEntry(key.toUtf8(), aDefault);
+}
+
 QString KConfigGroup::readEntry(const QString &key, const char* aDefault) const
 {
     return readEntry(key.toUtf8(), aDefault);
@@ -748,9 +853,28 @@
     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();
+}
+
+QByteArray KConfigGroup::readEntry(const QString &key, const QByteArray &defaultValue) const
+{
+    return readEntry(key.toUtf8(), defaultValue.constData()).toUtf8();
+}
+
+QByteArray KConfigGroup::readEntry(const char *key, const QByteArray &defaultValue) const
+{
+    return readEntry(QByteArray(key), defaultValue.constData()).toUtf8();
+}
+
+QString KConfigGroup::readEntry(const QString &key, const QString &aDefault) const
+{
+    return readEntry(key.toUtf8(), aDefault);
+}
+
+QString KConfigGroup::readEntry( const QByteArray& key, const QString& aDefault ) const
+{
     Q_ASSERT_X(isValid(), "KConfigGroup::readEntry", "accessing an invalid group");
 
     bool expand = false;
@@ -767,20 +891,17 @@
     return aValue;
 }
 
-template<>
-QStringList KConfigGroup::readEntry<QStringList>(const QByteArray &key, const QStringList& aDefault) const
+QVariant KConfigGroup::readEntry( const QString &key, const QVariant &aDefault ) const
 {
-    Q_ASSERT_X(isValid(), "KConfigGroup::readEntry", "accessing an invalid group");
+    return readEntry(key.toUtf8(), aDefault);
+}
 
-    const QString data = readEntry(key, QString());
-    if (data.isNull())
-        return aDefault;
-
-    return KConfigGroupPrivate::deserializeList(data);
+QVariant KConfigGroup::readEntry( const char *key, const QVariant &aDefault ) const
+{
+    return readEntry(QByteArray(key), aDefault);
 }
 
-template<>
-QVariant KConfigGroup::readEntry<QVariant>( const QByteArray &key, const QVariant &aDefault ) const
+QVariant KConfigGroup::readEntry( const QByteArray &key, const QVariant &aDefault ) const
 {
     Q_ASSERT_X(isValid(), "KConfigGroup::readEntry", "accessing an invalid group");
 
@@ -795,8 +916,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
 {
     Q_ASSERT_X(isValid(), "KConfigGroup::readEntry", "accessing an invalid group");
 
@@ -811,6 +931,106 @@
     return value;
 }
 
+QVariantList KConfigGroup::readEntry( const char *key, const QVariantList &aDefault ) const
+{
+    return readEntry(QByteArray(key), aDefault);
+}
+
+QVariantList KConfigGroup::readEntry( const QString &key, const QVariantList &aDefault ) const
+{
+    return readEntry(key.toUtf8(), aDefault);
+}
+
+KUrl KConfigGroup::readEntry( const QByteArray &key, const KUrl &aDefault ) const
+{
+    return readEntry(key, QVariant(aDefault)).value<KUrl>();
+}
+
+KUrl KConfigGroup::readEntry( const QString &key, const KUrl &aDefault ) const
+{
+    return readEntry(key.toUtf8(), QVariant(aDefault)).value<KUrl>();
+}
+
+KUrl KConfigGroup::readEntry( const char *key, const KUrl &aDefault ) const
+{
+    return readEntry(QByteArray(key), QVariant(aDefault)).value<KUrl>();
+}
+
+QPoint KConfigGroup::readEntry( const QByteArray &key, const QPoint &aDefault ) const
+{
+    return readEntry(key, QVariant(aDefault)).value<QPoint>();
+}
+
+QPoint KConfigGroup::readEntry( const QString &key, const QPoint &aDefault ) const
+{
+    return readEntry(key.toUtf8(), QVariant(aDefault)).value<QPoint>();
+}
+
+QPoint KConfigGroup::readEntry( const char *key, const QPoint &aDefault ) const
+{
+    return readEntry(QByteArray(key), QVariant(aDefault)).value<QPoint>();
+}
+
+QSize KConfigGroup::readEntry( const QByteArray &key, const QSize &aDefault ) const
+{
+    return readEntry(key, QVariant(aDefault)).value<QSize>();
+}
+
+QSize KConfigGroup::readEntry( const QString &key, const QSize &aDefault ) const
+{
+    return readEntry(key.toUtf8(), QVariant(aDefault)).value<QSize>();
+}
+
+QSize KConfigGroup::readEntry( const char *key, const QSize &aDefault ) const
+{
+    return readEntry(QByteArray(key), QVariant(aDefault)).value<QSize>();
+}
+
+QRect KConfigGroup::readEntry( const QByteArray &key, const QRect &aDefault ) const
+{
+    return readEntry(key, QVariant(aDefault)).value<QRect>();
+}
+
+QRect KConfigGroup::readEntry( const QString &key, const QRect &aDefault ) const
+{
+    return readEntry(key.toUtf8(), QVariant(aDefault)).value<QRect>();
+}
+
+QRect KConfigGroup::readEntry( const char *key, const QRect &aDefault ) const
+{
+    return readEntry(QByteArray(key), QVariant(aDefault)).value<QRect>();
+}
+
+QDate KConfigGroup::readEntry( const QByteArray &key, const QDate &aDefault ) const
+{
+    return readEntry(key, QVariant(aDefault)).value<QDate>();
+}
+
+QDate KConfigGroup::readEntry( const QString &key, const QDate &aDefault ) const
+{
+    return readEntry(key.toUtf8(), QVariant(aDefault)).value<QDate>();
+}
+
+QDate KConfigGroup::readEntry( const char *key, const QDate &aDefault ) const
+{
+    return readEntry(QByteArray(key), QVariant(aDefault)).value<QDate>();
+}
+
+QDateTime KConfigGroup::readEntry( const QByteArray &key, const QDateTime &aDefault ) const
+{
+    return readEntry(key, QVariant(aDefault)).value<QDateTime>();
+}
+
+QDateTime KConfigGroup::readEntry( const QString &key, const QDateTime &aDefault ) const
+{
+    return readEntry(key.toUtf8(), QVariant(aDefault)).value<QDateTime>();
+}
+
+QDateTime KConfigGroup::readEntry( const char *key, const QDateTime &aDefault ) const
+{
+    return readEntry(QByteArray(key), QVariant(aDefault)).value<QDateTime>();
+}
+
 QStringList KConfigGroup::readXdgListEntry(const QString& pKey, const QStringList& aDefault) const
 {
     return readXdgListEntry(pKey.toUtf8(), aDefault);
@@ -901,41 +1121,133 @@
     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)
 {
     Q_ASSERT_X(isValid(), "KConfigGroup::writeEntry", "accessing an invalid group");
     Q_ASSERT_X(!d->bConst, "KConfigGroup::writeEntry", "writing to a read-only group");
 
+    writeEntryTemplate(key, QVariant(value), pFlags);
+}
+
+void KConfigGroup::writeEntry( const QByteArray &key, const QString& value, WriteConfigFlags flags )
+{
     writeEntry(key, value.toUtf8(), flags);
 }
 
-void KConfigGroup::writeEntry(const QByteArray &key, const char *value, WriteConfigFlags pFlags)
+/*void KConfigGroup::writeEntry(const QByteArray &key, const char *value, WriteConfigFlags pFlags)
 {
-    writeEntry<const char *>(key, value, pFlags);
+    writeEntry(key, QByteArray(value), pFlags);
+}*/
+
+void KConfigGroup::writeEntry(const QString &key, const QByteArray &value, WriteConfigFlags pFlags)
+{
+    writeEntry(key.toUtf8(), value, pFlags);
 }
 
+void KConfigGroup::writeEntry(const QString &key, const QString &value, WriteConfigFlags pFlags)
+{
+    writeEntry(key.toUtf8(), value.toUtf8(), pFlags);
+}
+
 void KConfigGroup::writeEntry(const QString &key, const char *value, WriteConfigFlags pFlags)
 {
     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(), QByteArray(value), pFlags);
 }
 
+void KConfigGroup::writeEntry(const char *key, int value, WriteConfigFlags pFlags)
+{
+    writeEntry(QByteArray(key), QVariant(value), pFlags);
+}
+
+void KConfigGroup::writeEntry(const char *key, const QStringList &value, WriteConfigFlags pFlags)
+{
+    writeEntry(QByteArray(key), value, pFlags);
+}
+
+void KConfigGroup::writeEntry(const char *key, const QVariantList &value, WriteConfigFlags pFlags)
+{
+    writeEntry(QByteArray(key), value, pFlags);
+}
+
+void KConfigGroup::writeEntry(const char *key, qlonglong value, WriteConfigFlags pFlags)
+{
+    writeEntry(QByteArray(key), value, pFlags);
+}
+
+void KConfigGroup::writeEntry(const char *key, double value, WriteConfigFlags pFlags)
+{
+    writeEntry(QByteArray(key), value, pFlags);
+}
+
+void KConfigGroup::writeEntry(const char *key, uint value, WriteConfigFlags pFlags)
+{
+    writeEntry(QByteArray(key), value, pFlags);
+}
+
+void KConfigGroup::writeEntry(const char *key, qulonglong value, WriteConfigFlags pFlags)
+{
+    writeEntry(QByteArray(key), value, pFlags);
+}
+
+void KConfigGroup::writeEntry(const char *key, const KUrl &value, WriteConfigFlags pFlags)
+{
+    writeEntry(QByteArray(key), value, pFlags);
+}
+
+void KConfigGroup::writeEntry(const QString &key, int value, WriteConfigFlags pFlags)
+{
+    writeEntry(key.toUtf8(), QVariant(value), pFlags);
+}
+
+void KConfigGroup::writeEntry(const QString &key, qlonglong value, WriteConfigFlags pFlags)
+{
+    writeEntry(key.toUtf8(), QVariant(value), pFlags);
+}
+
+void KConfigGroup::writeEntry(const QString &key, uint value, WriteConfigFlags pFlags)
+{
+    writeEntry(key.toUtf8(), QVariant(value), pFlags);
+}
+
+void KConfigGroup::writeEntry(const QString &key, qulonglong value, WriteConfigFlags pFlags)
+{
+    writeEntry(key.toUtf8(), QVariant(value), pFlags);
+}
+
+void KConfigGroup::writeEntry(const QString &key, double value, WriteConfigFlags pFlags)
+{
+    writeEntry(key.toUtf8(), QVariant(value), pFlags);
+}
+
+void KConfigGroup::writeEntry(const QString &key, const QStringList &value, WriteConfigFlags pFlags)
+{
+    writeEntry(key.toUtf8(), value, pFlags);
+}
+
+void KConfigGroup::writeEntry(const QString &key, const KUrl &value, WriteConfigFlags pFlags)
+{
+    writeEntry(key.toUtf8(), QVariant(value), pFlags);
+}
+
+void KConfigGroup::writeEntry(const QString &key, const QVariant &value, WriteConfigFlags pFlags)
+{
+    writeEntry(key.toUtf8(), value, pFlags);
+}
+
 void KConfigGroup::writeEntry(const char *key, const char *value, WriteConfigFlags pFlags)
 {
-    writeEntry<const char *>(QByteArray(key), value, pFlags);
+    writeEntry(QByteArray(key), QByteArray(value), pFlags);
 }
 
-template<>
-void KConfigGroup::writeEntry<const char *>(const QByteArray &key, const char* const &value, WriteConfigFlags flags)
+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_X(isValid(), "KConfigGroup::writeEntry", "accessing an invalid group");
@@ -944,8 +1256,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_X(isValid(), "KConfigGroup::writeEntry", "accessing an invalid group");
     Q_ASSERT_X(!d->bConst, "KConfigGroup::writeEntry", "writing to a read-only group");
@@ -958,8 +1269,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_X(isValid(), "KConfigGroup::writeEntry", "accessing an invalid group");
     Q_ASSERT_X(!d->bConst, "KConfigGroup::writeEntry", "writing to a read-only group");
@@ -976,8 +1286,42 @@
     writeEntry(key, KConfigGroupPrivate::serializeList(data), flags);
 }
 
-template<>
-void KConfigGroup::writeEntry<QVariant> ( const QByteArray &key, const QVariant &value,
+void KConfigGroup::writeEntry(const QByteArray &key, int value, WriteConfigFlags pFlags)
+{
+	writeEntryTemplate<int>(key, value, pFlags);
+}
+
+void KConfigGroup::writeEntry(const QByteArray &key, qlonglong value, WriteConfigFlags pFlags)
+{
+	writeEntryTemplate<int>(key, value, pFlags);
+}
+
+void KConfigGroup::writeEntry(const QByteArray &key, uint value, WriteConfigFlags pFlags)
+{
+	writeEntryTemplate<int>(key, value, pFlags);
+}
+
+void KConfigGroup::writeEntry(const QByteArray &key, qulonglong value, WriteConfigFlags pFlags)
+{
+	writeEntryTemplate<int>(key, value, pFlags);
+}
+
+void KConfigGroup::writeEntry(const QByteArray &key, double value, WriteConfigFlags pFlags)
+{
+	writeEntryTemplate<int>(key, value, pFlags);
+}
+
+void KConfigGroup::writeEntry(const QByteArray &key, const KUrl &value, WriteConfigFlags pFlags)
+{
+	writeEntryTemplate<KUrl>(key, value, pFlags);
+}
+
+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_X(isValid(), "KConfigGroup::writeEntry", "accessing an invalid group");
@@ -989,7 +1333,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 = "";
@@ -1122,6 +1466,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);

