Initial import from the monolithic kdelibs.

This is the beginning of revision history for this module. If you
want to look at revision history older than this, please refer to the
techbase wiki for how to use Git history grafting. At the time of
writing, this wiki is located here:

http://community.kde.org/Frameworks/GitOldHistory

If you have already performed the grafting and you don't see any
history beyond this commit, try running "git log" with the "--follow"
argument.

Branched from the monolithic repo, kdelibs frameworks branch, at commit
162066dbbecde401a7347a1cff4fe72a9c919f58

1 files changed, 442 insertions, 0 deletions

diff --git a/tier1/kconfig/src/gui/kconfigloader.cpp b/tier1/kconfig/src/gui/kconfigloader.cpp
new file mode 100644
index 00000000..150c6b69
--- /dev/null
+++ b/tier1/kconfig/src/gui/kconfigloader.cpp
@@ -0,0 +1,442 @@
+/*
+ *   Copyright 2007 Aaron Seigo <aseigo@kde.org>
+ *
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU Library General Public License as
+ *   published by the Free Software Foundation; either version 2, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details
+ *
+ *   You should have received a copy of the GNU Library General Public
+ *   License along with this program; if not, write to the
+ *   Free Software Foundation, Inc.,
+ *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+
+#include "kconfigloader.h"
+#include "kconfigloader_p.h"
+#include "kconfigloaderhandler_p.h"
+
+#include <QColor>
+#include <QFont>
+#include <QHash>
+#include <QXmlContentHandler>
+#include <QXmlInputSource>
+#include <QXmlSimpleReader>
+#include <QUrl>
+
+#include <QDebug>
+
+void ConfigLoaderPrivate::parse(KConfigLoader *loader, QIODevice *xml)
+{
+    clearData();
+    loader->clearItems();
+
+    if (xml) {
+        QXmlInputSource source(xml);
+        QXmlSimpleReader reader;
+        ConfigLoaderHandler handler(loader, this);
+        reader.setContentHandler(&handler);
+        reader.parse(&source, false);
+    }
+}
+
+ConfigLoaderHandler::ConfigLoaderHandler(KConfigLoader *config, ConfigLoaderPrivate *d)
+    : QXmlDefaultHandler(),
+      m_config(config),
+      d(d)
+{
+    resetState();
+}
+
+bool ConfigLoaderHandler::startElement(const QString &namespaceURI, const QString &localName,
+                                       const QString &qName, const QXmlAttributes &attrs)
+{
+    Q_UNUSED(namespaceURI)
+    Q_UNUSED(qName)
+
+//     qDebug() << "ConfigLoaderHandler::startElement(" << localName << qName;
+    int numAttrs = attrs.count();
+    QString tag = localName.toLower();
+    if (tag == QStringLiteral("group")) {
+        QString group;
+        for (int i = 0; i < numAttrs; ++i) {
+            QString name = attrs.localName(i).toLower();
+            if (name == QStringLiteral("name")) {
+                //qDebug() << "set group to" << attrs.value(i);
+                group = attrs.value(i);
+            }
+        }
+        if (group.isEmpty()) {
+            group = d->baseGroup;
+        } else {
+            d->groups.append(group);
+            if (!d->baseGroup.isEmpty()) {
+                group = d->baseGroup + QStringLiteral("\x1d") + group;
+            }
+        }
+        m_currentGroup = group;
+        if (m_config) {
+            m_config->setCurrentGroup(group);
+        }
+    } else if (tag == QStringLiteral("entry")) {
+        for (int i = 0; i < numAttrs; ++i) {
+            QString name = attrs.localName(i).toLower();
+            if (name == QStringLiteral("name")) {
+                m_name = attrs.value(i).trimmed();
+            } else if (name == QStringLiteral("type")) {
+                m_type = attrs.value(i).toLower();
+            } else if (name == QStringLiteral("key")) {
+                m_key = attrs.value(i).trimmed();
+            }
+        }
+    } else if (tag == QStringLiteral("choice")) {
+        m_choice.name.clear();
+        m_choice.label.clear();
+        m_choice.whatsThis.clear();
+        for (int i = 0; i < numAttrs; ++i) {
+            QString name = attrs.localName(i).toLower();
+            if (name == QStringLiteral("name")) {
+                m_choice.name = attrs.value(i);
+            }
+        }
+        m_inChoice = true;
+    }
+
+    return true;
+}
+
+bool ConfigLoaderHandler::characters(const QString &ch)
+{
+    m_cdata.append(ch);
+    return true;
+}
+
+QString ConfigLoaderHandler::name() const
+{
+    return m_name;
+}
+
+void ConfigLoaderHandler::setName(const QString &name)
+{
+    m_name = name;
+}
+
+QString ConfigLoaderHandler::key() const
+{
+    return m_key;
+}
+
+void ConfigLoaderHandler::setKey(const QString &key)
+{
+    m_key = key;
+}
+
+QString ConfigLoaderHandler::type() const
+{
+    return m_type;
+}
+
+QString ConfigLoaderHandler::currentGroup() const
+{
+    return m_currentGroup;
+}
+
+QString ConfigLoaderHandler::defaultValue() const
+{
+    return m_default;
+}
+
+bool ConfigLoaderHandler::endElement(const QString &namespaceURI,
+                                  const QString &localName, const QString &qName)
+{
+    Q_UNUSED(namespaceURI)
+    Q_UNUSED(qName)
+
+//     qDebug() << "ConfigLoaderHandler::endElement(" << localName << qName;
+    const QString tag = localName.toLower();
+    if (tag == QStringLiteral("entry")) {
+        addItem();
+        resetState();
+    } else if (tag == QStringLiteral("label")) {
+        if (m_inChoice) {
+            m_choice.label = m_cdata.trimmed();
+        } else {
+            m_label = m_cdata.trimmed();
+        }
+    } else if (tag == QStringLiteral("whatsthis")) {
+        if (m_inChoice) {
+            m_choice.whatsThis = m_cdata.trimmed();
+        } else {
+            m_whatsThis = m_cdata.trimmed();
+        }
+    } else if (tag == QStringLiteral("default")) {
+        m_default = m_cdata.trimmed();
+    } else if (tag == QStringLiteral("min")) {
+        m_min = m_cdata.toInt(&m_haveMin);
+    } else if (tag == QStringLiteral("max")) {
+        m_max = m_cdata.toInt(&m_haveMax);
+    } else if (tag == QStringLiteral("choice")) {
+        m_enumChoices.append(m_choice);
+        m_inChoice = false;
+    }
+
+    m_cdata.clear();
+    return true;
+}
+
+void ConfigLoaderHandler::addItem()
+{
+    if (m_name.isEmpty()) {
+        if (m_key.isEmpty()) {
+            return;
+        }
+
+        m_name = m_key;
+    }
+
+    m_name.remove(QStringLiteral(" "));
+
+    KConfigSkeletonItem *item = 0;
+
+    if (m_type == QStringLiteral("bool")) {
+        bool defaultValue = m_default.toLower() == QStringLiteral("true");
+        item = m_config->addItemBool(m_name, *d->newBool(), defaultValue, m_key);
+    } else if (m_type == QStringLiteral("color")) {
+        item = m_config->addItemColor(m_name, *d->newColor(), QColor(m_default), m_key);
+    } else if (m_type == QStringLiteral("datetime")) {
+        item = m_config->addItemDateTime(m_name, *d->newDateTime(),
+                                         QDateTime::fromString(m_default), m_key);
+    } else if (m_type == QStringLiteral("enum")) {
+        m_key = (m_key.isEmpty()) ? m_name : m_key;
+        KConfigSkeleton::ItemEnum *enumItem =
+            new KConfigSkeleton::ItemEnum(m_config->currentGroup(),
+                                          m_key, *d->newInt(),
+                                          m_enumChoices,
+                                          m_default.toUInt());
+        m_config->addItem(enumItem, m_name);
+        item = enumItem;
+    } else if (m_type == QStringLiteral("font")) {
+        item = m_config->addItemFont(m_name, *d->newFont(), QFont(m_default), m_key);
+    } else if (m_type == QStringLiteral("int")) {
+        KConfigSkeleton::ItemInt *intItem = m_config->addItemInt(m_name, *d->newInt(),
+                                                                 m_default.toInt(), m_key);
+
+        if (m_haveMin) {
+            intItem->setMinValue(m_min);
+        }
+
+        if (m_haveMax) {
+            intItem->setMaxValue(m_max);
+        }
+
+        item = intItem;
+    } else if (m_type == QStringLiteral("password")) {
+        item = m_config->addItemPassword(m_name, *d->newString(), m_default, m_key);
+    } else if (m_type == QStringLiteral("path")) {
+        item = m_config->addItemPath(m_name, *d->newString(), m_default, m_key);
+    } else if (m_type == QStringLiteral("string")) {
+        item = m_config->addItemString(m_name, *d->newString(), m_default, m_key);
+    } else if (m_type == QStringLiteral("stringlist")) {
+        //FIXME: the split() is naive and will break on lists with ,'s in them
+        item = m_config->addItemStringList(m_name, *d->newStringList(),
+                                           m_default.split(QStringLiteral(",")), m_key);
+    } else if (m_type == QStringLiteral("uint")) {
+        KConfigSkeleton::ItemUInt *uintItem =
+            m_config->addItemUInt(m_name, *d->newUint(), m_default.toUInt(), m_key);
+        if (m_haveMin) {
+            uintItem->setMinValue(m_min);
+        }
+        if (m_haveMax) {
+            uintItem->setMaxValue(m_max);
+        }
+        item = uintItem;
+    } else if (m_type == QStringLiteral("url")) {
+        m_key = (m_key.isEmpty()) ? m_name : m_key;
+        KConfigSkeleton::ItemUrl *urlItem =
+            new KConfigSkeleton::ItemUrl(m_config->currentGroup(),
+                                         m_key, *d->newUrl(),
+                                         QUrl::fromUserInput(m_default));
+        m_config->addItem(urlItem, m_name);
+        item = urlItem;
+    } else if (m_type == QStringLiteral("double")) {
+        KConfigSkeleton::ItemDouble *doubleItem = m_config->addItemDouble(m_name,
+                *d->newDouble(), m_default.toDouble(), m_key);
+        if (m_haveMin) {
+            doubleItem->setMinValue(m_min);
+        }
+        if (m_haveMax) {
+            doubleItem->setMaxValue(m_max);
+        }
+        item = doubleItem;
+    } else if (m_type == QStringLiteral("intlist")) {
+        QStringList tmpList = m_default.split(QStringLiteral(","));
+        QList<int> defaultList;
+        foreach (const QString &tmp, tmpList) {
+            defaultList.append(tmp.toInt());
+        }
+        item = m_config->addItemIntList(m_name, *d->newIntList(), defaultList, m_key);
+    } else if (m_type == QStringLiteral("longlong")) {
+        KConfigSkeleton::ItemLongLong *longlongItem = m_config->addItemLongLong(m_name,
+                *d->newLongLong(), m_default.toLongLong(), m_key);
+        if (m_haveMin) {
+            longlongItem->setMinValue(m_min);
+        }
+        if (m_haveMax) {
+            longlongItem->setMaxValue(m_max);
+        }
+        item = longlongItem;
+    /* No addItemPathList in KConfigSkeleton ?
+    } else if (m_type == "PathList") {
+        //FIXME: the split() is naive and will break on lists with ,'s in them
+        item = m_config->addItemPathList(m_name, *d->newStringList(), m_default.split(","), m_key);
+    */
+    } else if (m_type == QStringLiteral("point")) {
+        QPoint defaultPoint;
+        QStringList tmpList = m_default.split(QStringLiteral(","));
+        if (tmpList.size() >= 2) {
+            defaultPoint.setX(tmpList[0].toInt());
+            defaultPoint.setY(tmpList[1].toInt());
+        }
+        item = m_config->addItemPoint(m_name, *d->newPoint(), defaultPoint, m_key);
+    } else if (m_type == QStringLiteral("rect")) {
+        QRect defaultRect;
+        QStringList tmpList = m_default.split(QStringLiteral(","));
+        if (tmpList.size() >= 4) {
+            defaultRect.setCoords(tmpList[0].toInt(), tmpList[1].toInt(),
+                                  tmpList[2].toInt(), tmpList[3].toInt());
+        }
+        item = m_config->addItemRect(m_name, *d->newRect(), defaultRect, m_key);
+    } else if (m_type == QStringLiteral("size")) {
+        QSize defaultSize;
+        QStringList tmpList = m_default.split(QStringLiteral(","));
+        if (tmpList.size() >= 2) {
+            defaultSize.setWidth(tmpList[0].toInt());
+            defaultSize.setHeight(tmpList[1].toInt());
+        }
+        item = m_config->addItemSize(m_name, *d->newSize(), defaultSize, m_key);
+    } else if (m_type == QStringLiteral("ulonglong")) {
+        KConfigSkeleton::ItemULongLong *ulonglongItem =
+            m_config->addItemULongLong(m_name, *d->newULongLong(), m_default.toULongLong(), m_key);
+        if (m_haveMin) {
+            ulonglongItem->setMinValue(m_min);
+        }
+        if (m_haveMax) {
+            ulonglongItem->setMaxValue(m_max);
+        }
+        item = ulonglongItem;
+    /* No addItemUrlList in KConfigSkeleton ?
+    } else if (m_type == "urllist") {
+        //FIXME: the split() is naive and will break on lists with ,'s in them
+        QStringList tmpList = m_default.split(",");
+        QList<QUrl> defaultList;
+        foreach (const QString& tmp, tmpList) {
+            defaultList.append(QUrl(tmp));
+        }
+        item = m_config->addItemUrlList(m_name, *d->newUrlList(), defaultList, m_key);*/
+    }
+
+    if (item) {
+        item->setLabel(m_label);
+        item->setWhatsThis(m_whatsThis);
+        d->keysToNames.insert(item->group() + item->key(), item->name());
+    }
+}
+
+void ConfigLoaderHandler::resetState()
+{
+    m_haveMin = false;
+    m_min = 0;
+    m_haveMax = false;
+    m_max = 0;
+    m_name.clear();
+    m_type.clear();
+    m_label.clear();
+    m_default.clear();
+    m_key.clear();
+    m_whatsThis.clear();
+    m_enumChoices.clear();
+    m_inChoice = false;
+}
+
+KConfigLoader::KConfigLoader(const QString &configFile, QIODevice *xml, QObject *parent)
+    : KConfigSkeleton(configFile, parent),
+      d(new ConfigLoaderPrivate)
+{
+    d->parse(this, xml);
+}
+
+KConfigLoader::KConfigLoader(KSharedConfigPtr config, QIODevice *xml, QObject *parent)
+    : KConfigSkeleton(config, parent),
+      d(new ConfigLoaderPrivate)
+{
+    d->parse(this, xml);
+}
+
+//FIXME: obviously this is broken and should be using the group as the root,
+//       but KConfigSkeleton does not currently support this. it will eventually though,
+//       at which point this can be addressed properly
+KConfigLoader::KConfigLoader(const KConfigGroup &config, QIODevice *xml, QObject *parent)
+    : KConfigSkeleton(KSharedConfig::openConfig(config.config()->name()), parent),
+      d(new ConfigLoaderPrivate)
+{
+    KConfigGroup group = config.parent();
+    d->baseGroup = config.name();
+    while (group.isValid() && group.name() != QStringLiteral("<default>")) {
+        d->baseGroup = group.name() + QStringLiteral("\x1d") + d->baseGroup;
+        group = group.parent();
+    }
+    d->parse(this, xml);
+}
+
+KConfigLoader::~KConfigLoader()
+{
+    delete d;
+}
+
+KConfigSkeletonItem *KConfigLoader::findItem(const QString &group, const QString &key) const
+{
+    return KConfigSkeleton::findItem(d->keysToNames[group + key]);
+}
+
+KConfigSkeletonItem *KConfigLoader::findItemByName(const QString &name) const
+{
+    return KConfigSkeleton::findItem(name);
+}
+
+QVariant KConfigLoader::property(const QString &name) const
+{
+    KConfigSkeletonItem *item = KConfigSkeleton::findItem(name);
+
+    if (item) {
+        return item->property();
+    }
+
+    return QVariant();
+}
+
+bool KConfigLoader::hasGroup(const QString &group) const
+{
+    return d->groups.contains(group);
+}
+
+QStringList KConfigLoader::groupList() const
+{
+    return d->groups;
+}
+
+bool KConfigLoader::usrWriteConfig()
+{
+    if (d->saveDefaults) {
+        KConfigSkeletonItem::List itemList = items();
+        for(int i = 0; i < itemList.size(); i++) {
+            KConfigGroup cg(config(), itemList.at(i)->group());
+            cg.writeEntry(itemList.at(i)->key(), "");
+        }
+    }
+    return true;
+}