aboutsummaryrefslogtreecommitdiff
path: root/tier1/kconfig/src/gui
diff options
context:
space:
mode:
authorJenkins CI <null@kde.org>2013-12-18 00:45:18 +0000
committerJenkins CI <null@kde.org>2013-12-18 00:45:18 +0000
commitc38b88497a833e482e6892b72c8f52adec6de857 (patch)
tree8c2d4b788cf54ab2179ffe53515d276feaeba2d1 /tier1/kconfig/src/gui
downloadkconfig-c38b88497a833e482e6892b72c8f52adec6de857.tar.gz
kconfig-c38b88497a833e482e6892b72c8f52adec6de857.tar.bz2
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
Diffstat (limited to 'tier1/kconfig/src/gui')
-rw-r--r--tier1/kconfig/src/gui/CMakeLists.txt41
-rw-r--r--tier1/kconfig/src/gui/kconfiggroupgui.cpp197
-rw-r--r--tier1/kconfig/src/gui/kconfiggui.cpp51
-rw-r--r--tier1/kconfig/src/gui/kconfiggui.h58
-rw-r--r--tier1/kconfig/src/gui/kconfigloader.cpp442
-rw-r--r--tier1/kconfig/src/gui/kconfigloader.h176
-rw-r--r--tier1/kconfig/src/gui/kconfigloader_p.h222
-rw-r--r--tier1/kconfig/src/gui/kconfigloaderhandler_p.h68
-rw-r--r--tier1/kconfig/src/gui/kconfigskeleton.cpp121
-rw-r--r--tier1/kconfig/src/gui/kconfigskeleton.h140
-rw-r--r--tier1/kconfig/src/gui/kstandardshortcut.cpp377
-rw-r--r--tier1/kconfig/src/gui/kstandardshortcut.h482
-rw-r--r--tier1/kconfig/src/gui/kwindowconfig.cpp83
-rw-r--r--tier1/kconfig/src/gui/kwindowconfig.h58
14 files changed, 2516 insertions, 0 deletions
diff --git a/tier1/kconfig/src/gui/CMakeLists.txt b/tier1/kconfig/src/gui/CMakeLists.txt
new file mode 100644
index 00000000..974b05cc
--- /dev/null
+++ b/tier1/kconfig/src/gui/CMakeLists.txt
@@ -0,0 +1,41 @@
+
+find_package(Qt5Widgets 5.2.0 REQUIRED NO_MODULE)
+find_package(Qt5Xml 5.2.0 REQUIRED NO_MODULE)
+
+set(libkconfiggui_SRCS
+ kconfiggui.cpp
+ kconfiggroupgui.cpp
+ kconfigloader.cpp
+ kconfigskeleton.cpp
+ kstandardshortcut.cpp
+ kwindowconfig.cpp
+)
+
+add_library(KF5ConfigGui ${libkconfiggui_SRCS})
+generate_export_header(KF5ConfigGui BASE_NAME KConfigGui)
+add_library(KF5::ConfigGui ALIAS KF5ConfigGui)
+
+target_link_libraries(KF5ConfigGui PUBLIC Qt5::Gui Qt5::Xml KF5::ConfigCore)
+
+if(IS_ABSOLUTE "${INCLUDE_INSTALL_DIR}")
+ target_include_directories(KF5ConfigGui INTERFACE "$<INSTALL_INTERFACE:${INCLUDE_INSTALL_DIR}>" )
+else()
+ target_include_directories(KF5ConfigGui INTERFACE "$<INSTALL_INTERFACE:${CMAKE_INSTALL_PREFIX}/${INCLUDE_INSTALL_DIR}>" )
+endif()
+
+set_target_properties(KF5ConfigGui PROPERTIES VERSION ${KCONFIG_VERSION_STRING}
+ SOVERSION ${KCONFIG_SOVERSION}
+ EXPORT_NAME ConfigGui
+)
+
+install(TARGETS KF5ConfigGui EXPORT KF5ConfigTargets ${INSTALL_TARGETS_DEFAULT_ARGS})
+
+install( FILES
+ ${CMAKE_CURRENT_BINARY_DIR}/kconfiggui_export.h
+ kconfiggui.h
+ kconfigloader.h
+ kconfigskeleton.h
+ kstandardshortcut.h
+ kwindowconfig.h
+ DESTINATION ${INCLUDE_INSTALL_DIR} COMPONENT Devel
+)
diff --git a/tier1/kconfig/src/gui/kconfiggroupgui.cpp b/tier1/kconfig/src/gui/kconfiggroupgui.cpp
new file mode 100644
index 00000000..22706e77
--- /dev/null
+++ b/tier1/kconfig/src/gui/kconfiggroupgui.cpp
@@ -0,0 +1,197 @@
+/*
+ This file is part of the KDE libraries
+ Copyright (c) 2007 Thiago Macieira <thiago@kde.org>
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Library General Public
+ License as published by the Free Software Foundation; either
+ version 2 of the License, or (at your option) any later version.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Library General Public License for more details.
+
+ You should have received a copy of the GNU Library General Public License
+ along with this library; see the file COPYING.LIB. If not, write to
+ the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ Boston, MA 02110-1301, USA.
+*/
+
+#include <kconfiggroup.h>
+
+#include <QtCore/QMutableStringListIterator>
+#include <QColor>
+#include <QDebug>
+#include <QFont>
+
+#include <kconfiggroup_p.h>
+
+/**
+ * Try to read a GUI type from config group @p cg at key @p key.
+ * @p input is the default value and also indicates the type to be read.
+ * @p output is to be set with the value that has been read.
+ *
+ * @returns true if something was handled (even if output was set to clear or default)
+ * or false if nothing was handled (e.g., Core type)
+ */
+static bool readEntryGui(const QByteArray& data, const char* key, const QVariant &input,
+ QVariant &output)
+{
+ const QString errString = QString::fromLatin1("\"%1\" - conversion from \"%3\" to %2 failed")
+ .arg(QLatin1String(key))
+ .arg(QLatin1String(QVariant::typeToName(input.type())))
+ .arg(QLatin1String(data.constData()));
+ const QString formatError = QString::fromLatin1(" (wrong format: expected '%1' items, read '%2')");
+
+ // set in case of failure
+ output = input;
+
+ switch (input.type()) {
+ case QVariant::Color: {
+ if (data.isEmpty() || data == "invalid") {
+ output = QColor(); // return what was stored
+ return true;
+ } else if (data.at(0) == '#') {
+ QColor col;
+ col.setNamedColor(QString::fromUtf8(data.constData(), data.length()));
+ output = col;
+ return true;
+ } else if (!data.contains(',')) {
+ QColor col;
+ col.setNamedColor(QString::fromUtf8(data.constData(), data.length()));
+ if (!col.isValid())
+ qCritical() << qPrintable(errString);
+ output = col;
+ return true;
+ } else {
+ const QList<QByteArray> list = data.split(',');
+ const int count = list.count();
+
+ if (count != 3 && count != 4) {
+ qCritical() << qPrintable(errString) << qPrintable(formatError.arg(QLatin1String("3' or '4")).arg(count));
+ return true; // return default
+ }
+
+ int temp[4];
+ // bounds check components
+ for(int i = 0; i < count; i++) {
+ bool ok;
+ const int j = temp[i] = list.at(i).toInt(&ok);
+ if (!ok) { // failed to convert to int
+ qCritical() << qPrintable(errString) << " (integer conversion failed)";
+ return true; // return default
+ }
+ if (j < 0 || j > 255) {
+ static const char *const components[6] = {
+ "red", "green", "blue", "alpha"
+ };
+ const QString boundsError = QLatin1String(" (bounds error: %1 component %2)");
+ qCritical() << qPrintable(errString)
+ << qPrintable(boundsError.arg(QLatin1String(components[i])).arg(j < 0? QLatin1String("< 0"): QLatin1String("> 255")));
+ return true; // return default
+ }
+ }
+ QColor aColor(temp[0], temp[1], temp[2]);
+ if (count == 4)
+ aColor.setAlpha(temp[3]);
+
+ if (aColor.isValid())
+ output = aColor;
+ else
+ qCritical() << qPrintable(errString);
+ return true;
+ }
+ }
+
+ case QVariant::Font: {
+ QVariant tmp = QString::fromUtf8(data.constData(), data.length());
+ if (tmp.convert(QVariant::Font))
+ output = tmp;
+ else
+ qCritical() << qPrintable(errString);
+ return true;
+ }
+ case QVariant::Pixmap:
+ case QVariant::Image:
+ case QVariant::Brush:
+ case QVariant::Palette:
+ case QVariant::Icon:
+ case QVariant::Region:
+ case QVariant::Bitmap:
+ case QVariant::Cursor:
+ case QVariant::SizePolicy:
+ case QVariant::Pen:
+ // we may want to handle these in the future
+
+ default:
+ break;
+ }
+
+ return false; // not handled
+}
+
+/**
+ * Try to write a GUI type @p prop to config group @p cg at key @p key.
+ *
+ * @returns true if something was handled (even if an empty value was written)
+ * or false if nothing was handled (e.g., Core type)
+ */
+static bool writeEntryGui(KConfigGroup *cg, const char* key, const QVariant &prop,
+ KConfigGroup::WriteConfigFlags pFlags)
+{
+ switch (prop.type()) {
+ case QVariant::Color: {
+ const QColor rColor = prop.value<QColor>();
+
+ if (!rColor.isValid()) {
+ cg->writeEntry(key, "invalid", pFlags);
+ return true;
+ }
+
+ QList<int> list;
+ list.insert(0, rColor.red());
+ list.insert(1, rColor.green());
+ list.insert(2, rColor.blue());
+ if (rColor.alpha() != 255)
+ list.insert(3, rColor.alpha());
+
+ cg->writeEntry( key, list, pFlags );
+ return true;
+ }
+ case QVariant::Font:
+ cg->writeEntry( key, prop.toString().toUtf8(), pFlags );
+ return true;
+
+ case QVariant::Pixmap:
+ case QVariant::Image:
+ case QVariant::Brush:
+ case QVariant::Palette:
+ case QVariant::Icon:
+ case QVariant::Region:
+ case QVariant::Bitmap:
+ case QVariant::Cursor:
+ case QVariant::SizePolicy:
+ case QVariant::Pen:
+ // we may want to handle one of these in the future
+ break;
+
+ default:
+ break;
+ }
+
+ return false;
+}
+
+static int initKConfigGroupGui()
+{
+ _kde_internal_KConfigGroupGui.readEntryGui = readEntryGui;
+ _kde_internal_KConfigGroupGui.writeEntryGui = writeEntryGui;
+ return 42; // because 42 is nicer than 1 or 0
+}
+
+#ifdef Q_CONSTRUCTOR_FUNCTION
+Q_CONSTRUCTOR_FUNCTION(initKConfigGroupGui)
+#else
+static int dummyKConfigGroupGui = initKConfigGroupGui();
+#endif
diff --git a/tier1/kconfig/src/gui/kconfiggui.cpp b/tier1/kconfig/src/gui/kconfiggui.cpp
new file mode 100644
index 00000000..88da6b56
--- /dev/null
+++ b/tier1/kconfig/src/gui/kconfiggui.cpp
@@ -0,0 +1,51 @@
+/*
+ This file is part of the KDE libraries
+ Copyright (c) 1999 Matthias Ettrich <ettrich@kde.org>
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) version 3, or any
+ later version accepted by the membership of KDE e.V. (or its
+ successor approved by the membership of KDE e.V.), which shall
+ act as a proxy defined in Section 6 of version 3 of the license.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "kconfiggui.h"
+
+#include <QGuiApplication>
+
+#include <kconfig.h>
+
+static KConfig* s_sessionConfig = 0;
+
+KConfig* KConfigGui::sessionConfig()
+{
+ if (!s_sessionConfig) // create an instance specific config object
+ s_sessionConfig = new KConfig( sessionConfigName(), KConfig::SimpleConfig );
+ return s_sessionConfig;
+}
+
+bool KConfigGui::hasSessionConfig()
+{
+ return s_sessionConfig != 0;
+}
+
+QString KConfigGui::sessionConfigName()
+{
+#ifdef QT_NO_SESSIONMANAGER
+#error QT_NO_SESSIONMANAGER was set, this will not compile. Reconfigure Qt with Session management support.
+#endif
+ const QString sessionKey = qApp->sessionKey();
+ const QString sessionId = qApp->sessionId();
+ return QString(QLatin1String("session/%1_%2_%3")).arg(QGuiApplication::applicationName()).arg(sessionId).arg(sessionKey);
+}
+
diff --git a/tier1/kconfig/src/gui/kconfiggui.h b/tier1/kconfig/src/gui/kconfiggui.h
new file mode 100644
index 00000000..4e2313f3
--- /dev/null
+++ b/tier1/kconfig/src/gui/kconfiggui.h
@@ -0,0 +1,58 @@
+/*
+ This file is part of the KDE libraries
+ Copyright (c) 1999 Matthias Ettrich <ettrich@kde.org>
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) version 3, or any
+ later version accepted by the membership of KDE e.V. (or its
+ successor approved by the membership of KDE e.V.), which shall
+ act as a proxy defined in Section 6 of version 3 of the license.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef KCONFIGGUI_H
+#define KCONFIGGUI_H
+
+#include <kconfiggui_export.h>
+
+#include <QString>
+
+class KConfig;
+
+namespace KConfigGui
+{
+ /**
+ * Returns the application session config object.
+ *
+ * @return A pointer to the application's instance specific
+ * KConfig object.
+ * @see KConfig
+ */
+ KCONFIGGUI_EXPORT KConfig* sessionConfig();
+
+ /**
+ * Indicates if a session config has been created for that application
+ * (ie. if sessionConfig() got called at least once)
+ *
+ * @return true if a sessionConfig object was created, false otherwise
+ */
+ KCONFIGGUI_EXPORT bool hasSessionConfig();
+
+ /**
+ * Returns the name of the application session
+ *
+ * @return the application session name
+ */
+ KCONFIGGUI_EXPORT QString sessionConfigName();
+}
+
+#endif // KCONFIGGUI_H
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;
+}
diff --git a/tier1/kconfig/src/gui/kconfigloader.h b/tier1/kconfig/src/gui/kconfigloader.h
new file mode 100644
index 00000000..df38ce79
--- /dev/null
+++ b/tier1/kconfig/src/gui/kconfigloader.h
@@ -0,0 +1,176 @@
+/*
+ * 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.
+ */
+
+#ifndef KCONFIGLOADER_H
+#define KCONFIGLOADER_H
+
+#include <kconfiggroup.h>
+#include <kconfigskeleton.h>
+#include <ksharedconfig.h>
+
+#include <kconfiggui_export.h>
+
+class ConfigLoaderPrivate;
+
+/**
+ * @class KConfigLoader kconfigloader.h <KConfigLoader>
+ *
+ * @short A KConfigSkeleton that populates itself based on KConfigXT XML
+ *
+ * This class allows one to ship an XML file and reconstitute it into a
+ * KConfigSkeleton object at runtime. Common usage might look like this:
+ *
+ * \code
+ * QFile file(xmlFilePath);
+ * KConfigLoader appletConfig(configFilePath, &file);
+ * \endcode
+ *
+ * Alternatively, any QIODevice may be used in place of QFile in the
+ * example above.
+ *
+ * KConfigLoader is useful if it is not possible to use compiled code
+ * and by that the kconfig compiler cannot be used. Common examples are
+ * scripted plugins which want to provide a configuration interface.
+ * With the help of KConfigLoader a dynamically loaded ui file can be
+ * populated with the stored values and also stored back to the config
+ * file.
+ *
+ * An example for populating a QDialog with a dynamically populated UI
+ * with the help of a KConfigDialogManager:
+ * \code
+ * QDialog *dialog = new QDialog();
+ * QFile xmlFile("path/to/kconfigxt.xml");
+ * KConfigGroup cg = KSharedConfig::openConfig()->group(QString());
+ * KConfigLoader *configLoader = new KConfigLoader(cg, &xmlFile, this);
+ *
+ * // load the ui file
+ * QUiLoader *loader = new QUiLoader(this);
+ * QFile uiFile("path/to/userinterface.ui");
+ * uiFile.open(QFile::ReadOnly);
+ * QWidget *customConfigForm = loader->load(&uiFile, dialog);
+ * uiFile.close();
+ *
+ * KConfigDialogManager *manager = new KConfigDialogManager(customConfigForm, configLoader);
+ * if (dialog->exec() == QDialog::Accepted) {
+ * manager->updateSettings();
+ * }
+ * \endcode
+ *
+ * Currently the following data types are supported:
+ *
+ * @li bools
+ * @li colors
+ * @li datetimes
+ * @li enumerations
+ * @li fonts
+ * @li ints
+ * @li passwords
+ * @li paths
+ * @li strings
+ * @li stringlists
+ * @li uints
+ * @li urls
+ * @li doubles
+ * @li int lists
+ * @li longlongs
+ * @li path lists
+ * @li points
+ * @li rects
+ * @li sizes
+ * @li ulonglongs
+ * @li url lists
+ **/
+class KCONFIGGUI_EXPORT KConfigLoader : public KConfigSkeleton
+{
+public:
+ /**
+ * Creates a KConfigSkeleton populated using the definition found in
+ * the XML data passed in.
+ *
+ * @param configFile path to the configuration file to use
+ * @param xml the xml data; must be valid KConfigXT data
+ * @param parent optional QObject parent
+ **/
+ KConfigLoader(const QString &configFile, QIODevice *xml, QObject *parent = 0);
+
+ /**
+ * Creates a KConfigSkeleton populated using the definition found in
+ * the XML data passed in.
+ *
+ * @param config the configuration object to use
+ * @param xml the xml data; must be valid KConfigXT data
+ * @param parent optional QObject parent
+ **/
+ KConfigLoader(KSharedConfigPtr config, QIODevice *xml, QObject *parent = 0);
+
+ /**
+ * Creates a KConfigSkeleton populated using the definition found in
+ * the XML data passed in.
+ *
+ * @param config the group to use as the root for configuration items
+ * @param xml the xml data; must be valid KConfigXT data
+ * @param parent optional QObject parent
+ **/
+ KConfigLoader(const KConfigGroup &config, QIODevice *xml, QObject *parent = 0);
+
+ ~KConfigLoader();
+
+ /**
+ * Finds the item for the given group and key.
+ *
+ * @param group the group in the config file to look in
+ * @param key the configuration key to find
+ * @return the associated KConfigSkeletonItem, or 0 if none
+ */
+ KConfigSkeletonItem *findItem(const QString &group, const QString &key) const;
+
+ /**
+ * Finds an item by its name
+ */
+ KConfigSkeletonItem *findItemByName(const QString &name) const;
+
+ /**
+ * Returns the property (variantized value) of the named item
+ */
+ QVariant property(const QString &name) const;
+
+ /**
+ * Check to see if a group exists
+ *
+ * @param group the name of the group to check for
+ * @return true if the group exists, or false if it does not
+ */
+ bool hasGroup(const QString &group) const;
+
+ /**
+ * @return the list of groups defined by the XML
+ */
+ QStringList groupList() const;
+
+protected:
+ /**
+ * Hack used to force writing when no default exists in config file.
+ */
+ bool usrWriteConfig();
+
+private:
+ ConfigLoaderPrivate * const d;
+};
+
+#endif //multiple inclusion guard
diff --git a/tier1/kconfig/src/gui/kconfigloader_p.h b/tier1/kconfig/src/gui/kconfigloader_p.h
new file mode 100644
index 00000000..f9aa9191
--- /dev/null
+++ b/tier1/kconfig/src/gui/kconfigloader_p.h
@@ -0,0 +1,222 @@
+/*
+ * Copyright 2007-2008 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.
+ */
+
+#ifndef KCONFIGLOADER_P_H
+#define KCONFIGLOADER_P_H
+
+#include <QUrl>
+
+class ConfigLoaderPrivate
+{
+ public:
+ ConfigLoaderPrivate()
+ : saveDefaults(false)
+ {
+ }
+
+ ~ConfigLoaderPrivate()
+ {
+ clearData();
+ }
+
+ void clearData()
+ {
+ qDeleteAll(bools);
+ qDeleteAll(strings);
+ qDeleteAll(stringlists);
+ qDeleteAll(colors);
+ qDeleteAll(fonts);
+ qDeleteAll(ints);
+ qDeleteAll(uints);
+ qDeleteAll(urls);
+ qDeleteAll(dateTimes);
+ qDeleteAll(doubles);
+ qDeleteAll(intlists);
+ qDeleteAll(longlongs);
+ qDeleteAll(points);
+ qDeleteAll(rects);
+ qDeleteAll(sizes);
+ qDeleteAll(ulonglongs);
+ qDeleteAll(urllists);
+ }
+
+ bool *newBool()
+ {
+ bool *v = new bool;
+ bools.append(v);
+ return v;
+ }
+
+ QString *newString()
+ {
+ QString *v = new QString;
+ strings.append(v);
+ return v;
+ }
+
+ QStringList *newStringList()
+ {
+ QStringList *v = new QStringList;
+ stringlists.append(v);
+ return v;
+ }
+
+ QColor *newColor()
+ {
+ QColor *v = new QColor;
+ colors.append(v);
+ return v;
+ }
+
+ QFont *newFont()
+ {
+ QFont *v = new QFont;
+ fonts.append(v);
+ return v;
+ }
+
+ qint32 *newInt()
+ {
+ qint32 *v = new qint32;
+ ints.append(v);
+ return v;
+ }
+
+ quint32 *newUint()
+ {
+ quint32 *v = new quint32;
+ uints.append(v);
+ return v;
+ }
+
+ QUrl *newUrl()
+ {
+ QUrl *v = new QUrl;
+ urls.append(v);
+ return v;
+ }
+
+ QDateTime *newDateTime()
+ {
+ QDateTime *v = new QDateTime;
+ dateTimes.append(v);
+ return v;
+ }
+
+ double *newDouble()
+ {
+ double *v = new double;
+ doubles.append(v);
+ return v;
+ }
+
+ QList<qint32>* newIntList()
+ {
+ QList<qint32> *v = new QList<qint32>;
+ intlists.append(v);
+ return v;
+ }
+
+ qint64 *newLongLong()
+ {
+ qint64 *v = new qint64;
+ longlongs.append(v);
+ return v;
+ }
+
+ QPoint *newPoint()
+ {
+ QPoint *v = new QPoint;
+ points.append(v);
+ return v;
+ }
+
+ QRect *newRect()
+ {
+ QRect *v = new QRect;
+ rects.append(v);
+ return v;
+ }
+
+ QSize *newSize()
+ {
+ QSize *v = new QSize;
+ sizes.append(v);
+ return v;
+ }
+
+ quint64 *newULongLong()
+ {
+ quint64 *v = new quint64;
+ ulonglongs.append(v);
+ return v;
+ }
+
+ QList<QUrl> *newUrlList()
+ {
+ QList<QUrl> *v = new QList<QUrl>();
+ urllists.append(v);
+ return v;
+ }
+
+ void parse(KConfigLoader *loader, QIODevice *xml);
+
+ /**
+ * Whether or not to write out default values.
+ *
+ * @param writeDefaults true if defaults should be written out
+ */
+ void setWriteDefaults(bool writeDefaults)
+ {
+ saveDefaults = writeDefaults;
+ }
+
+ /**
+ * @return true if default values will also be written out
+ */
+ bool writeDefaults() const
+ {
+ return saveDefaults;
+ }
+
+
+ QList<bool *> bools;
+ QList<QString *> strings;
+ QList<QStringList *> stringlists;
+ QList<QColor *> colors;
+ QList<QFont *> fonts;
+ QList<qint32 *> ints;
+ QList<quint32 *> uints;
+ QList<QUrl *> urls;
+ QList<QDateTime *> dateTimes;
+ QList<double *> doubles;
+ QList<QList<qint32> *> intlists;
+ QList<qint64 *> longlongs;
+ QList<QPoint *> points;
+ QList<QRect *> rects;
+ QList<QSize *> sizes;
+ QList<quint64 *> ulonglongs;
+ QList<QList<QUrl> *> urllists;
+ QString baseGroup;
+ QStringList groups;
+ QHash<QString, QString> keysToNames;
+ bool saveDefaults;
+};
+
+#endif
diff --git a/tier1/kconfig/src/gui/kconfigloaderhandler_p.h b/tier1/kconfig/src/gui/kconfigloaderhandler_p.h
new file mode 100644
index 00000000..f0766346
--- /dev/null
+++ b/tier1/kconfig/src/gui/kconfigloaderhandler_p.h
@@ -0,0 +1,68 @@
+/*
+ * Copyright 2007-2008 Aaron Seigo <aseigo@kde.org>
+ * Copyright 2013 Marco Martin <mart@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.
+ */
+
+#ifndef KCONFIGLOADERHANDLER_P_H
+#define KCONFIGLOADERHANDLER_P_H
+
+#include <QXmlDefaultHandler>
+
+class ConfigLoaderHandler : public QXmlDefaultHandler
+{
+public:
+ ConfigLoaderHandler(KConfigLoader *config, ConfigLoaderPrivate *d);
+ bool startElement(const QString &namespaceURI, const QString &localName,
+ const QString &qName, const QXmlAttributes &atts);
+ bool endElement(const QString &namespaceURI, const QString &localName,
+ const QString &qName);
+ bool characters(const QString &ch);
+
+ QString name() const;
+ void setName(const QString &name);
+ QString key() const;
+ void setKey(const QString &name);
+ QString type() const;
+ QString currentGroup() const;
+ QString defaultValue() const;
+
+private:
+ virtual void addItem();
+ void resetState();
+
+ KConfigLoader *m_config;
+ ConfigLoaderPrivate *d;
+ int m_min;
+ int m_max;
+ QString m_currentGroup;
+ QString m_name;
+ QString m_key;
+ QString m_type;
+ QString m_label;
+ QString m_default;
+ QString m_cdata;
+ QString m_whatsThis;
+ KConfigSkeleton::ItemEnum::Choice m_choice;
+ QList<KConfigSkeleton::ItemEnum::Choice> m_enumChoices;
+ bool m_haveMin;
+ bool m_haveMax;
+ bool m_inChoice;
+};
+
+#endif
+
diff --git a/tier1/kconfig/src/gui/kconfigskeleton.cpp b/tier1/kconfig/src/gui/kconfigskeleton.cpp
new file mode 100644
index 00000000..7704d36e
--- /dev/null
+++ b/tier1/kconfig/src/gui/kconfigskeleton.cpp
@@ -0,0 +1,121 @@
+/*
+ This file is part of KOrganizer.
+ Copyright (c) 2000,2001 Cornelius Schumacher <schumacher@kde.org>
+ Copyright (c) 2003 Waldo Bastian <bastian@kde.org>
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Library General Public
+ License as published by the Free Software Foundation; either
+ version 2 of the License, or (at your option) any later version.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Library General Public License for more details.
+
+ You should have received a copy of the GNU Library General Public License
+ along with this library; see the file COPYING.LIB. If not, write to
+ the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ Boston, MA 02110-1301, USA.
+*/
+
+#include "kconfigskeleton.h"
+
+#include <kcoreconfigskeleton_p.h>
+
+KConfigSkeleton::KConfigSkeleton(const QString &configname, QObject* parent)
+ : KCoreConfigSkeleton(configname, parent)
+{
+}
+
+KConfigSkeleton::KConfigSkeleton(KSharedConfig::Ptr pConfig, QObject* parent)
+ : KCoreConfigSkeleton(pConfig, parent)
+{
+}
+
+
+KConfigSkeleton::ItemColor::ItemColor( const QString &_group, const QString &_key,
+ QColor &reference,
+ const QColor &defaultValue )
+ : KConfigSkeletonGenericItem<QColor>( _group, _key, reference, defaultValue )
+{
+}
+
+void KConfigSkeleton::ItemColor::readConfig( KConfig *config )
+{
+ KConfigGroup cg(config, mGroup );
+ mReference = cg.readEntry( mKey, mDefault );
+ mLoadedValue = mReference;
+
+ readImmutability( cg );
+}
+
+void KConfigSkeleton::ItemColor::setProperty(const QVariant & p)
+{
+ mReference = qvariant_cast<QColor>(p);
+}
+
+bool KConfigSkeleton::ItemColor::isEqual(const QVariant &v) const
+{
+ return mReference == qvariant_cast<QColor>(v);
+}
+
+QVariant KConfigSkeleton::ItemColor::property() const
+{
+ return QVariant(mReference);
+}
+
+
+KConfigSkeleton::ItemFont::ItemFont( const QString &_group, const QString &_key,
+ QFont &reference,
+ const QFont &defaultValue )
+ : KConfigSkeletonGenericItem<QFont>( _group, _key, reference, defaultValue )
+{
+}
+
+void KConfigSkeleton::ItemFont::readConfig( KConfig *config )
+{
+ KConfigGroup cg(config, mGroup );
+ mReference = cg.readEntry( mKey, mDefault );
+ mLoadedValue = mReference;
+
+ readImmutability( cg );
+}
+
+void KConfigSkeleton::ItemFont::setProperty(const QVariant & p)
+{
+ mReference = qvariant_cast<QFont>(p);
+}
+
+bool KConfigSkeleton::ItemFont::isEqual(const QVariant &v) const
+{
+ return mReference == qvariant_cast<QFont>(v);
+}
+
+QVariant KConfigSkeleton::ItemFont::property() const
+{
+ return QVariant(mReference);
+}
+
+
+KConfigSkeleton::ItemColor *KConfigSkeleton::addItemColor( const QString &name, QColor &reference,
+ const QColor &defaultValue, const QString &key )
+{
+ KConfigSkeleton::ItemColor *item;
+ item = new KConfigSkeleton::ItemColor( d->mCurrentGroup, key.isNull() ? name : key,
+ reference, defaultValue );
+ addItem( item, name );
+ return item;
+}
+
+KConfigSkeleton::ItemFont *KConfigSkeleton::addItemFont( const QString &name, QFont &reference,
+ const QFont &defaultValue, const QString &key )
+{
+ KConfigSkeleton::ItemFont *item;
+ item = new KConfigSkeleton::ItemFont( d->mCurrentGroup, key.isNull() ? name : key,
+ reference, defaultValue );
+ addItem( item, name );
+ return item;
+}
+
+
diff --git a/tier1/kconfig/src/gui/kconfigskeleton.h b/tier1/kconfig/src/gui/kconfigskeleton.h
new file mode 100644
index 00000000..e62e60b4
--- /dev/null
+++ b/tier1/kconfig/src/gui/kconfigskeleton.h
@@ -0,0 +1,140 @@
+/*
+ * This file is part of KDE.
+ *
+ * Copyright (c) 2001,2002,2003 Cornelius Schumacher <schumacher@kde.org>
+ * Copyright (c) 2003 Waldo Bastian <bastian@kde.org>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB. If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#ifndef KCONFIGSKELETON_H
+#define KCONFIGSKELETON_H
+
+#include <kconfiggui_export.h>
+
+#include <kcoreconfigskeleton.h>
+
+#include <QColor>
+#include <QFont>
+
+/**
+ * @short Class for handling preferences settings for an application.
+ * @author Cornelius Schumacher
+ *
+ * This class extends KCoreConfigSkeleton by support for GUI types.
+ *
+ */
+class KCONFIGGUI_EXPORT KConfigSkeleton : public KCoreConfigSkeleton
+{
+ Q_OBJECT
+public:
+ /**
+ * Class for handling a color preferences item.
+ */
+ class KCONFIGGUI_EXPORT ItemColor:public KConfigSkeletonGenericItem < QColor >
+ {
+ public:
+ /** @copydoc KConfigSkeletonGenericItem::KConfigSkeletonGenericItem */
+ ItemColor(const QString & _group, const QString & _key,
+ QColor & reference,
+ const QColor & defaultValue = QColor(128, 128, 128));
+
+ /** @copydoc KConfigSkeletonItem::readConfig(KConfig*) */
+ void readConfig(KConfig * config);
+
+ /** @copydoc KConfigSkeletonItem::setProperty(const QVariant&) */
+ void setProperty(const QVariant & p);
+
+ /** @copydoc KConfigSkeletonItem::isEqual(const QVariant &) */
+ bool isEqual(const QVariant &p) const;
+
+ /** @copydoc KConfigSkeletonItem::property() */
+ QVariant property() const;
+ };
+
+
+ /**
+ * Class for handling a font preferences item.
+ */
+ class KCONFIGGUI_EXPORT ItemFont:public KConfigSkeletonGenericItem < QFont >
+ {
+ public:
+ /** @copydoc KConfigSkeletonGenericItem::KConfigSkeletonGenericItem */
+ ItemFont(const QString & _group, const QString & _key, QFont & reference,
+ const QFont & defaultValue = QFont());
+
+ /** @copydoc KConfigSkeletonItem::readConfig(KConfig*) */
+ void readConfig(KConfig * config);
+
+ /** @copydoc KConfigSkeletonItem::setProperty(const QVariant&) */
+ void setProperty(const QVariant & p);
+
+ /** @copydoc KConfigSkeletonItem::isEqual(const QVariant &) */
+ bool isEqual(const QVariant &p) const;
+
+ /** @copydoc KConfigSkeletonItem::property() */
+ QVariant property() const;
+ };
+
+public:
+ /**
+ * Constructor.
+ *
+ * @param configname name of config file. If no name is given, the default
+ * config file as returned by KSharedConfig::openConfig() is used.
+ */
+ explicit KConfigSkeleton(const QString & configname = QString(), QObject* parent = 0);
+
+ /**
+ * Constructor.
+ *
+ * @param config configuration object to use.
+ */
+ explicit KConfigSkeleton(KSharedConfig::Ptr config, QObject* parent = 0);
+
+ /**
+ * Register an item of type QColor.
+ *
+ * @param name Name used to identify this setting. Names must be unique.
+ * @param reference Pointer to the variable, which is set by readConfig()
+ * calls and read by writeConfig() calls.
+ * @param defaultValue Default value, which is used when the config file
+ * does not yet contain the key of this item.
+ * @param key Key used in config file. If key is null, name is used as key.
+ * @return The created item
+ */
+ ItemColor *addItemColor(const QString & name, QColor & reference,
+ const QColor & defaultValue = QColor(128, 128, 128),
+ const QString & key = QString());
+
+ /**
+ * Register an item of type QFont.
+ *
+ * @param name Name used to identify this setting. Names must be unique.
+ * @param reference Pointer to the variable, which is set by readConfig()
+ * calls and read by writeConfig() calls.
+ * @param defaultValue Default value, which is used when the config file
+ * does not yet contain the key of this item.
+ * @param key Key used in config file. If key is null, name is used as key.
+ * @return The created item
+ */
+ ItemFont *addItemFont(const QString & name, QFont & reference,
+ const QFont & defaultValue = QFont(),
+ const QString & key = QString());
+
+};
+
+#endif
diff --git a/tier1/kconfig/src/gui/kstandardshortcut.cpp b/tier1/kconfig/src/gui/kstandardshortcut.cpp
new file mode 100644
index 00000000..a377ff0f
--- /dev/null
+++ b/tier1/kconfig/src/gui/kstandardshortcut.cpp
@@ -0,0 +1,377 @@
+/* This file is part of the KDE libraries
+ Copyright (C) 1997 Stefan Taferner (taferner@alpin.or.at)
+ Copyright (C) 2000 Nicolas Hadacek (haadcek@kde.org)
+ Copyright (C) 2001,2002 Ellis Whitehead (ellis@kde.org)
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Library General Public
+ License version 2 as published by the Free Software Foundation.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Library General Public License for more details.
+
+ You should have received a copy of the GNU Library General Public License
+ along with this library; see the file COPYING.LIB. If not, write to
+ the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ Boston, MA 02110-1301, USA.
+*/
+
+#include "kstandardshortcut.h"
+
+#include "kconfig.h"
+#include "ksharedconfig.h"
+#include <kconfiggroup.h>
+
+#include <QCoreApplication>
+#include <QDebug>
+#include <QKeySequence>
+
+namespace KStandardShortcut
+{
+
+struct KStandardShortcutInfo
+{
+ //! The standard shortcut id. @see StandardShortcut
+ StandardShortcut id;
+
+ /**
+ * Unique name for the given accel. The name is used to save the user
+ * settings. It's not representable. Use description for that.
+ * @warning NEVER EVER CHANGE IT OR TRANSLATE IT!
+ */
+ const char* name;
+
+ //! Context for the translation
+ const char* translation_context;
+
+ //! Localized label for user-visible display
+ const char* description;
+
+ //! The keys for this shortcut
+ int cutDefault, cutDefault2;
+
+ //! A shortcut that is created with @a cutDefault and @cutDefault2
+ QList<QKeySequence> cut;
+
+ //! If this struct is initialized. If not initialized @cut is not valid
+ bool isInitialized;
+};
+
+//! We need to remember the context to get the correct translation.
+#undef I18N_NOOP2
+#define I18N_NOOP2(comment,x) comment, x
+
+#define CTRL(x) Qt::CTRL+Qt::Key_##x
+#define SHIFT(x) Qt::SHIFT+Qt::Key_##x
+#define CTRLSHIFT(x) Qt::CTRL+Qt::SHIFT+Qt::Key_##x
+#define ALT(x) Qt::ALT+Qt::Key_##x
+#define ALTSHIFT(x) Qt::ALT+Qt::SHIFT+Qt::Key_##x
+
+/** Array of predefined KStandardShortcutInfo objects, which cover all
+ the "standard" accelerators. Each enum value from StandardShortcut
+ should appear in this table.
+*/
+// STUFF WILL BREAK IF YOU DON'T READ THIS!!!
+// Read the comments of the big enum in kstandardshortcut.h before you change anything!
+static KStandardShortcutInfo g_infoStandardShortcut[] =
+{
+//Group File,
+ {AccelNone, 0 , 0 , 0 , 0 , 0 , QList<QKeySequence>(), false },
+ { Open , "Open" , I18N_NOOP2("@action", "Open") , CTRL(O), 0 , QList<QKeySequence>(), false } ,
+ { New , "New" , I18N_NOOP2("@action", "New") , CTRL(N), 0 , QList<QKeySequence>(), false } ,
+ { Close , "Close", I18N_NOOP2("@action", "Close"), CTRL(W), CTRL(Escape), QList<QKeySequence>(), false } ,
+ { Save , "Save" , I18N_NOOP2("@action", "Save") , CTRL(S), 0 , QList<QKeySequence>(), false } ,
+ { Print , "Print", I18N_NOOP2("@action", "Print"), CTRL(P), 0 , QList<QKeySequence>(), false } ,
+ { Quit , "Quit" , I18N_NOOP2("@action", "Quit") , CTRL(Q), 0 , QList<QKeySequence>(), false } ,
+
+//Group Edit
+ { Undo , "Undo" , I18N_NOOP2("@action", "Undo") , CTRL(Z) , 0 , QList<QKeySequence>(), false },
+ { Redo , "Redo" , I18N_NOOP2("@action", "Redo") , CTRLSHIFT(Z) , 0 , QList<QKeySequence>(), false },
+ { Cut , "Cut" , I18N_NOOP2("@action", "Cut") , CTRL(X) , SHIFT(Delete), QList<QKeySequence>(), false },
+ { Copy , "Copy" , I18N_NOOP2("@action", "Copy") , CTRL(C) , CTRL(Insert) , QList<QKeySequence>(), false },
+ { Paste , "Paste" , I18N_NOOP2("@action", "Paste") , CTRL(V) , SHIFT(Insert), QList<QKeySequence>(), false },
+ { PasteSelection , "Paste Selection" , I18N_NOOP2("@action", "Paste Selection") , CTRLSHIFT(Insert), 0 , QList<QKeySequence>(), false },
+
+ { SelectAll , "SelectAll" , I18N_NOOP2("@action", "Select All") , CTRL(A) , 0 , QList<QKeySequence>(), false },
+ { Deselect , "Deselect" , I18N_NOOP2("@action", "Deselect") , CTRLSHIFT(A) , 0 , QList<QKeySequence>(), false },
+ { DeleteWordBack , "DeleteWordBack" , I18N_NOOP2("@action", "Delete Word Backwards"), CTRL(Backspace) , 0 , QList<QKeySequence>(), false },
+ { DeleteWordForward, "DeleteWordForward", I18N_NOOP2("@action", "Delete Word Forward") , CTRL(Delete) , 0 , QList<QKeySequence>(), false },
+
+ { Find , "Find" , I18N_NOOP2("@action", "Find") , CTRL(F) , 0 , QList<QKeySequence>(), false },
+ { FindNext , "FindNext" , I18N_NOOP2("@action", "Find Next") , Qt::Key_F3 , 0 , QList<QKeySequence>(), false },
+ { FindPrev , "FindPrev" , I18N_NOOP2("@action", "Find Prev") , SHIFT(F3) , 0 , QList<QKeySequence>(), false },
+ { Replace , "Replace" , I18N_NOOP2("@action", "Replace") , CTRL(R) , 0 , QList<QKeySequence>(), false },
+
+//Group Navigation
+ { Home , "Home" , I18N_NOOP2("@action Go to main page" , "Home") , ALT(Home) , Qt::Key_HomePage , QList<QKeySequence>(), false },
+ { Begin , "Begin" , I18N_NOOP2("@action Beginning of document", "Begin") , CTRL(Home) , 0 , QList<QKeySequence>(), false },
+ { End , "End" , I18N_NOOP2("@action End of document" , "End") , CTRL(End) , 0 , QList<QKeySequence>(), false },
+ { Prior , "Prior" , I18N_NOOP2("@action" , "Prior") , Qt::Key_PageUp , 0 , QList<QKeySequence>(), false },
+ { Next , "Next" , I18N_NOOP2("@action Opposite to Prior" , "Next") , Qt::Key_PageDown, 0 , QList<QKeySequence>(), false },
+
+ { Up , "Up" , I18N_NOOP2("@action" , "Up") , ALT(Up) , 0 , QList<QKeySequence>(), false },
+ { Back , "Back" , I18N_NOOP2("@action" , "Back") , ALT(Left) , Qt::Key_Back , QList<QKeySequence>(), false },
+ { Forward , "Forward" , I18N_NOOP2("@action" , "Forward") , ALT(Right) , Qt::Key_Forward , QList<QKeySequence>(), false },
+ { Reload , "Reload" , I18N_NOOP2("@action" , "Reload") , Qt::Key_F5 , Qt::Key_Refresh , QList<QKeySequence>(), false },
+
+ { BeginningOfLine, "BeginningOfLine" , I18N_NOOP2("@action" , "Beginning of Line") , Qt::Key_Home , 0 , QList<QKeySequence>(), false },
+ { EndOfLine , "EndOfLine" , I18N_NOOP2("@action" , "End of Line") , Qt::Key_End , 0 , QList<QKeySequence>(), false },
+ { GotoLine , "GotoLine" , I18N_NOOP2("@action" , "Go to Line") , CTRL(G) , 0 , QList<QKeySequence>(), false },
+ { BackwardWord , "BackwardWord" , I18N_NOOP2("@action" , "Backward Word") , CTRL(Left) , 0 , QList<QKeySequence>(), false },
+ { ForwardWord , "ForwardWord" , I18N_NOOP2("@action" , "Forward Word") , CTRL(Right) , 0 , QList<QKeySequence>(), false },
+
+ { AddBookmark , "AddBookmark" , I18N_NOOP2("@action" , "Add Bookmark") , CTRL(B) , 0 , QList<QKeySequence>(), false },
+ { ZoomIn , "ZoomIn" , I18N_NOOP2("@action" , "Zoom In") , CTRL(Plus) , CTRL(Equal) , QList<QKeySequence>(), false },
+ { ZoomOut , "ZoomOut" , I18N_NOOP2("@action" , "Zoom Out") , CTRL(Minus) , 0 , QList<QKeySequence>(), false },
+ { FullScreen , "FullScreen" , I18N_NOOP2("@action" , "Full Screen Mode") , CTRLSHIFT(F) , 0 , QList<QKeySequence>(), false },
+
+ { ShowMenubar , "ShowMenubar" , I18N_NOOP2("@action" , "Show Menu Bar") , CTRL(M) , 0 , QList<QKeySequence>(), false },
+ { TabNext , "Activate Next Tab" , I18N_NOOP2("@action" , "Activate Next Tab") , CTRL(Period) , CTRL(BracketRight), QList<QKeySequence>(), false },
+ { TabPrev , "Activate Previous Tab", I18N_NOOP2("@action" , "Activate Previous Tab"), CTRL(Comma) , CTRL(BracketLeft) , QList<QKeySequence>(), false },
+
+ //Group Help
+ { Help , "Help" , I18N_NOOP2("@action" , "Help") , Qt::Key_F1 , 0 , QList<QKeySequence>(), false },
+ { WhatsThis , "WhatsThis" , I18N_NOOP2("@action" , "What's This") , SHIFT(F1) , 0 , QList<QKeySequence>(), false },
+
+//Group TextCompletion
+ { TextCompletion , "TextCompletion" , I18N_NOOP2("@action", "Text Completion") , CTRL(E) , 0, QList<QKeySequence>(), false },
+ { PrevCompletion , "PrevCompletion" , I18N_NOOP2("@action", "Previous Completion Match"), CTRL(Up) , 0, QList<QKeySequence>(), false },
+ { NextCompletion , "NextCompletion" , I18N_NOOP2("@action", "Next Completion Match") , CTRL(Down) , 0, QList<QKeySequence>(), false },
+ { SubstringCompletion , "SubstringCompletion" , I18N_NOOP2("@action", "Substring Completion") , CTRL(T) , 0, QList<QKeySequence>(), false },
+
+ { RotateUp , "RotateUp" , I18N_NOOP2("@action", "Previous Item in List") , Qt::Key_Up , 0, QList<QKeySequence>(), false },
+ { RotateDown , "RotateDown" , I18N_NOOP2("@action", "Next Item in List") , Qt::Key_Down, 0, QList<QKeySequence>(), false },
+
+ { OpenRecent , "OpenRecent" , I18N_NOOP2("@action", "Open Recent") , 0 , 0, QList<QKeySequence>(), false },
+ { SaveAs , "SaveAs" , I18N_NOOP2("@action", "Save As") , CTRLSHIFT(S), 0, QList<QKeySequence>(), false },
+ { Revert , "Revert" , I18N_NOOP2("@action", "Revert") , 0 , 0, QList<QKeySequence>(), false },
+ { PrintPreview , "PrintPreview" , I18N_NOOP2("@action", "Print Preview") , 0 , 0, QList<QKeySequence>(), false },
+ { Mail , "Mail" , I18N_NOOP2("@action", "Mail") , 0 , 0, QList<QKeySequence>(), false },
+ { Clear , "Clear" , I18N_NOOP2("@action", "Clear") , 0 , 0, QList<QKeySequence>(), false },
+ { ActualSize , "ActualSize" , I18N_NOOP2("@action", "Actual Size") , 0 , 0, QList<QKeySequence>(), false },
+ { FitToPage , "FitToPage" , I18N_NOOP2("@action", "Fit To Page") , 0 , 0, QList<QKeySequence>(), false },
+ { FitToWidth , "FitToWidth" , I18N_NOOP2("@action", "Fit To Width") , 0 , 0, QList<QKeySequence>(), false },
+ { FitToHeight , "FitToHeight" , I18N_NOOP2("@action", "Fit To Height") , 0 , 0, QList<QKeySequence>(), false },
+ { Zoom , "Zoom" , I18N_NOOP2("@action", "Zoom") , 0 , 0, QList<QKeySequence>(), false },
+ { Goto , "Goto" , I18N_NOOP2("@action", "Goto") , 0 , 0, QList<QKeySequence>(), false },
+ { GotoPage , "GotoPage" , I18N_NOOP2("@action", "Goto Page") , 0 , 0, QList<QKeySequence>(), false },
+ { DocumentBack , "DocumentBack" , I18N_NOOP2("@action", "Document Back") , ALTSHIFT(Left), 0, QList<QKeySequence>(), false },
+ { DocumentForward , "DocumentForward" , I18N_NOOP2("@action", "Document Forward") , ALTSHIFT(Right), 0, QList<QKeySequence>(), false },
+ { EditBookmarks , "EditBookmarks" , I18N_NOOP2("@action", "Edit Bookmarks") , 0 , 0, QList<QKeySequence>(), false },
+ { Spelling , "Spelling" , I18N_NOOP2("@action", "Spelling") , 0 , 0, QList<QKeySequence>(), false },
+ { ShowToolbar , "ShowToolbar" , I18N_NOOP2("@action", "Show Toolbar") , 0 , 0, QList<QKeySequence>(), false },
+ { ShowStatusbar , "ShowStatusbar" , I18N_NOOP2("@action", "Show Statusbar") , 0 , 0, QList<QKeySequence>(), false },
+ { SaveOptions , "SaveOptions" , I18N_NOOP2("@action", "Save Options") , 0 , 0, QList<QKeySequence>(), false },
+ { KeyBindings , "KeyBindings" , I18N_NOOP2("@action", "Key Bindings") , 0 , 0, QList<QKeySequence>(), false },
+ { Preferences , "Preferences" , I18N_NOOP2("@action", "Preferences") , 0 , 0, QList<QKeySequence>(), false },
+ { ConfigureToolbars , "ConfigureToolbars" , I18N_NOOP2("@action", "Configure Toolbars") , 0 , 0, QList<QKeySequence>(), false },
+ { ConfigureNotifications , "ConfigureNotifications" , I18N_NOOP2("@action", "Configure Notifications") , 0 , 0, QList<QKeySequence>(), false },
+ { TipofDay , "TipofDay" , I18N_NOOP2("@action", "Tip Of Day") , 0 , 0, QList<QKeySequence>(), false },
+ { ReportBug , "ReportBug" , I18N_NOOP2("@action", "Report Bug") , 0 , 0, QList<QKeySequence>(), false },
+ { SwitchApplicationLanguage, "SwitchApplicationLanguage", I18N_NOOP2("@action", "Switch Application Language"), 0 , 0, QList<QKeySequence>(), false },
+ { AboutApp , "AboutApp" , I18N_NOOP2("@action", "About Application") , 0 , 0, QList<QKeySequence>(), false },
+ { AboutKDE , "AboutKDE" , I18N_NOOP2("@action", "About KDE") , 0 , 0, QList<QKeySequence>(), false },
+
+ //dummy entry to catch simple off-by-one errors. Insert new entries before this line.
+ { AccelNone , 0 , 0 , 0 , 0, 0, QList<QKeySequence>(), false }
+};
+
+
+/** Search for the KStandardShortcutInfo object associated with the given @p id.
+ Return a dummy entry with no name and an empty shortcut if @p id is invalid.
+*/
+static KStandardShortcutInfo *guardedStandardShortcutInfo(StandardShortcut id)
+{
+ if (id >= static_cast<int>(sizeof(g_infoStandardShortcut) / sizeof(KStandardShortcutInfo)) ||
+ id < 0) {
+ qWarning() << "KStandardShortcut: id not found!";
+ return &g_infoStandardShortcut[AccelNone];
+ } else
+ return &g_infoStandardShortcut[id];
+}
+
+/** Initialize the accelerator @p id by checking if it is overridden
+ in the configuration file (and if it isn't, use the default).
+ On X11, if QApplication was initialized with GUI disabled,
+ the default will always be used.
+*/
+static void initialize(StandardShortcut id)
+{
+ KStandardShortcutInfo *info = guardedStandardShortcutInfo(id);
+
+ // All three are needed.
+ if (info->id!=AccelNone) {
+ Q_ASSERT(info->description);
+ Q_ASSERT(info->translation_context);
+ Q_ASSERT(info->name);
+ }
+
+ KConfigGroup cg(KSharedConfig::openConfig(), "Shortcuts");
+
+ if (cg.hasKey(info->name)) {
+ QString s = cg.readEntry(info->name);
+ if (s != QLatin1String("none"))
+ info->cut = QKeySequence::listFromString(s);
+ else
+ info->cut = QList<QKeySequence>();
+ } else {
+ info->cut = hardcodedDefaultShortcut(id);
+ }
+
+ info->isInitialized = true;
+}
+
+void saveShortcut(StandardShortcut id, const QList<QKeySequence> &newShortcut)
+{
+ KStandardShortcutInfo *info = guardedStandardShortcutInfo(id);
+ // If the action has no standard shortcut associated there is nothing to
+ // save
+ if(info->id == AccelNone)
+ return;
+
+ KConfigGroup cg(KSharedConfig::openConfig(), "Shortcuts");
+
+ info->cut = newShortcut;
+ bool sameAsDefault = (newShortcut == hardcodedDefaultShortcut(id));
+
+ if (sameAsDefault) {
+ // If the shortcut is the equal to the hardcoded one we remove it from
+ // kdeglobal if necessary and return.
+ if(cg.hasKey(info->name))
+ cg.deleteEntry(info->name, KConfig::Global|KConfig::Persistent);
+
+ return;
+ }
+
+ // Write the changed shortcut to kdeglobals
+ cg.writeEntry(info->name, QKeySequence::listToString(info->cut), KConfig::Global|KConfig::Persistent);
+}
+
+QString name(StandardShortcut id)
+{
+ return QString::fromLatin1(guardedStandardShortcutInfo(id)->name);
+}
+
+QString label(StandardShortcut id)
+{
+ KStandardShortcutInfo *info = guardedStandardShortcutInfo( id );
+ return QCoreApplication::translate("KStandardShortcut",
+ info->description,
+ info->translation_context);
+}
+
+// TODO: Add psWhatsThis entry to KStandardShortcutInfo
+QString whatsThis( StandardShortcut /*id*/ )
+{
+// KStandardShortcutInfo* info = guardedStandardShortcutInfo( id );
+// if( info && info->whatsThis )
+// return i18n(info->whatsThis);
+// else
+ return QString();
+}
+
+const QList<QKeySequence> &shortcut(StandardShortcut id)
+{
+ KStandardShortcutInfo *info = guardedStandardShortcutInfo(id);
+
+ if(!info->isInitialized)
+ initialize(id);
+
+ return info->cut;
+}
+
+StandardShortcut find(const QKeySequence &seq)
+{
+ if( !seq.isEmpty() ) {
+ for(uint i = 0; i < sizeof(g_infoStandardShortcut) / sizeof(KStandardShortcutInfo); i++) {
+ StandardShortcut id = g_infoStandardShortcut[i].id;
+ if( id != AccelNone ) {
+ if(!g_infoStandardShortcut[i].isInitialized)
+ initialize(id);
+ if(g_infoStandardShortcut[i].cut.contains(seq))
+ return id;
+ }
+ }
+ }
+ return AccelNone;
+}
+
+StandardShortcut find(const char *keyName)
+{
+ for(uint i = 0; i < sizeof(g_infoStandardShortcut) / sizeof(KStandardShortcutInfo); i++)
+ if (qstrcmp(g_infoStandardShortcut[i].name, keyName))
+ return g_infoStandardShortcut[i].id;
+
+ return AccelNone;
+}
+
+QList<QKeySequence> hardcodedDefaultShortcut(StandardShortcut id)
+{
+ QList<QKeySequence> cut;
+ KStandardShortcutInfo *info = guardedStandardShortcutInfo(id);
+
+ if (info->cutDefault != 0)
+ cut << info->cutDefault;
+
+ if (info->cutDefault2 != 0) {
+ if (cut.isEmpty())
+ cut << QKeySequence();
+
+ cut << info->cutDefault2;
+ }
+
+ return cut;
+}
+
+const QList<QKeySequence> &open() { return shortcut( Open ); }
+const QList<QKeySequence> &openNew() { return shortcut( New ); }
+const QList<QKeySequence> &close() { return shortcut( Close ); }
+const QList<QKeySequence> &save() { return shortcut( Save ); }
+const QList<QKeySequence> &print() { return shortcut( Print ); }
+const QList<QKeySequence> &quit() { return shortcut( Quit ); }
+const QList<QKeySequence> &cut() { return shortcut( Cut ); }
+const QList<QKeySequence> &copy() { return shortcut( Copy ); }
+const QList<QKeySequence> &paste() { return shortcut( Paste ); }
+const QList<QKeySequence> &pasteSelection() { return shortcut( PasteSelection ); }
+const QList<QKeySequence> &deleteWordBack() { return shortcut( DeleteWordBack ); }
+const QList<QKeySequence> &deleteWordForward() { return shortcut( DeleteWordForward ); }
+const QList<QKeySequence> &undo() { return shortcut( Undo ); }
+const QList<QKeySequence> &redo() { return shortcut( Redo ); }
+const QList<QKeySequence> &find() { return shortcut( Find ); }
+const QList<QKeySequence> &findNext() { return shortcut( FindNext ); }
+const QList<QKeySequence> &findPrev() { return shortcut( FindPrev ); }
+const QList<QKeySequence> &replace() { return shortcut( Replace ); }
+const QList<QKeySequence> &home() { return shortcut( Home ); }
+const QList<QKeySequence> &begin() { return shortcut( Begin ); }
+const QList<QKeySequence> &end() { return shortcut( End ); }
+const QList<QKeySequence> &beginningOfLine() { return shortcut( BeginningOfLine ); }
+const QList<QKeySequence> &endOfLine() { return shortcut( EndOfLine ); }
+const QList<QKeySequence> &prior() { return shortcut( Prior ); }
+const QList<QKeySequence> &next() { return shortcut( Next ); }
+const QList<QKeySequence> &backwardWord() { return shortcut( BackwardWord ); }
+const QList<QKeySequence> &forwardWord() { return shortcut( ForwardWord ); }
+const QList<QKeySequence> &gotoLine() { return shortcut( GotoLine ); }
+const QList<QKeySequence> &addBookmark() { return shortcut( AddBookmark ); }
+const QList<QKeySequence> &tabNext() { return shortcut( TabNext ); }
+const QList<QKeySequence> &tabPrev() { return shortcut( TabPrev ); }
+const QList<QKeySequence> &fullScreen() { return shortcut( FullScreen ); }
+const QList<QKeySequence> &zoomIn() { return shortcut( ZoomIn ); }
+const QList<QKeySequence> &zoomOut() { return shortcut( ZoomOut ); }
+const QList<QKeySequence> &help() { return shortcut( Help ); }
+const QList<QKeySequence> &completion() { return shortcut( TextCompletion ); }
+const QList<QKeySequence> &prevCompletion() { return shortcut( PrevCompletion ); }
+const QList<QKeySequence> &nextCompletion() { return shortcut( NextCompletion ); }
+const QList<QKeySequence> &rotateUp() { return shortcut( RotateUp ); }
+const QList<QKeySequence> &rotateDown() { return shortcut( RotateDown ); }
+const QList<QKeySequence> &substringCompletion() { return shortcut( SubstringCompletion ); }
+const QList<QKeySequence> &whatsThis() { return shortcut( WhatsThis ); }
+const QList<QKeySequence> &reload() { return shortcut( Reload ); }
+const QList<QKeySequence> &selectAll() { return shortcut( SelectAll ); }
+const QList<QKeySequence> &up() { return shortcut( Up ); }
+const QList<QKeySequence> &back() { return shortcut( Back ); }
+const QList<QKeySequence> &forward() { return shortcut( Forward ); }
+const QList<QKeySequence> &showMenubar() { return shortcut( ShowMenubar ); }
+
+}
diff --git a/tier1/kconfig/src/gui/kstandardshortcut.h b/tier1/kconfig/src/gui/kstandardshortcut.h
new file mode 100644
index 00000000..b02a6ebf
--- /dev/null
+++ b/tier1/kconfig/src/gui/kstandardshortcut.h
@@ -0,0 +1,482 @@
+/* This file is part of the KDE libraries
+ Copyright (C) 1997 Stefan Taferner (taferner@kde.org)
+ Copyright (C) 2000 Nicolas Hadacek (hadacek@kde.org)
+ Copyright (C) 2001,2002 Ellis Whitehead (ellis@kde.org)
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Library General Public
+ License version 2 as published by the Free Software Foundation.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Library General Public License for more details.
+
+ You should have received a copy of the GNU Library General Public License
+ along with this library; see the file COPYING.LIB. If not, write to
+ the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ Boston, MA 02110-1301, USA.
+*/
+#ifndef KSTANDARDSHORTCUT_H
+#define KSTANDARDSHORTCUT_H
+
+#include <QtCore/QString>
+#include <QKeySequence>
+
+#include <kconfiggui_export.h>
+
+/**
+ * \namespace KStandardShortcut
+ * Convenient methods for access to the common accelerator keys in
+ * the key configuration. These are the standard keybindings that should
+ * be used in all KDE applications. They will be configurable,
+ * so do not hardcode the default behavior.
+ */
+namespace KStandardShortcut
+{ // STUFF WILL BREAK IF YOU DON'T READ THIS!!!
+ /*
+ *Always add new std-accels to the end of this enum, never in the middle!
+ *Don't forget to add the corresponding entries in g_infoStandardShortcut[] in kstandardshortcut.cpp, too.
+ *Values of elements here and positions of the corresponding entries in
+ *the big array g_infoStandardShortcut[] ABSOLUTELY MUST BE THE SAME.
+ * !!! !!!! !!!!! !!!!
+ * !!!! !!! !!!! !!!!
+ * Remember to also update kdoctools/genshortcutents.cpp.
+ *
+ * Other Rules:
+ *
+ * - Never change the name of an existing shortcut
+ * - Never translate the name of a shortcut
+ */
+
+ /**
+ * Defines the identifier of all standard accelerators.
+ */
+ enum StandardShortcut {
+ //C++ requires that the value of an enum symbol be one more than the previous one.
+ //This means that everything will be well-ordered from here on.
+ AccelNone=0,
+ // File menu
+ Open, New, Close, Save,
+ // The Print item
+ Print,
+ Quit,
+ // Edit menu
+ Undo, Redo, Cut, Copy, Paste, PasteSelection,
+ SelectAll, Deselect, DeleteWordBack, DeleteWordForward,
+ Find, FindNext, FindPrev, Replace,
+ // Navigation
+ Home, Begin, End, Prior, Next,
+ Up, Back, Forward, Reload,
+ // Text Navigation
+ BeginningOfLine, EndOfLine, GotoLine,
+ BackwardWord, ForwardWord,
+ // View parameters
+ AddBookmark, ZoomIn, ZoomOut, FullScreen,
+ ShowMenubar,
+ // Tabular navigation
+ TabNext, TabPrev,
+ // Help menu
+ Help, WhatsThis,
+ // Text completion
+ TextCompletion, PrevCompletion, NextCompletion, SubstringCompletion,
+
+ RotateUp, RotateDown,
+
+ OpenRecent,
+ SaveAs,
+ Revert,
+ PrintPreview,
+ Mail,
+ Clear,
+ ActualSize,
+ FitToPage,
+ FitToWidth,
+ FitToHeight,
+ Zoom,
+ Goto,
+ GotoPage,
+ DocumentBack,
+ DocumentForward,
+ EditBookmarks,
+ Spelling,
+ ShowToolbar,
+ ShowStatusbar,
+ SaveOptions,
+ KeyBindings,
+ Preferences,
+ ConfigureToolbars,
+ ConfigureNotifications,
+ TipofDay,
+ ReportBug,
+ SwitchApplicationLanguage,
+ AboutApp,
+ AboutKDE,
+
+ // Insert new items here!
+
+ StandardShortcutCount // number of standard shortcuts
+ };
+
+ /**
+ * Returns the keybinding for @p accel.
+ * On X11, if QApplication was initialized with GUI disabled, the
+ * default keybinding will always be returned.
+ * @param id the id of the accelerator
+ */
+ KCONFIGGUI_EXPORT const QList<QKeySequence> &shortcut(StandardShortcut id);
+
+ /**
+ * Returns a unique name for the given accel.
+ * @param id the id of the accelerator
+ * @return the unique name of the accelerator
+ */
+ KCONFIGGUI_EXPORT QString name(StandardShortcut id);
+
+ /**
+ * Returns a localized label for user-visible display.
+ * @param id the id of the accelerator
+ * @return a localized label for the accelerator
+ */
+ KCONFIGGUI_EXPORT QString label(StandardShortcut id);
+
+ /**
+ * Returns an extended WhatsThis description for the given accelerator.
+ * @param id the id of the accelerator
+ * @return a localized description of the accelerator
+ */
+ KCONFIGGUI_EXPORT QString whatsThis(StandardShortcut id);
+
+ /**
+ * Return the StandardShortcut id of the standard accel action which
+ * uses this key sequence, or AccelNone if none of them do.
+ * This is used by class KKeyChooser.
+ * @param keySeq the key sequence to search
+ * @return the id of the standard accelerator, or AccelNone if there
+ * is none
+ */
+ KCONFIGGUI_EXPORT StandardShortcut find(const QKeySequence &keySeq);
+
+ /**
+ * Return the StandardShortcut id of the standard accel action which
+ * has \a keyName as its name, or AccelNone if none of them do.
+ * This is used by class KKeyChooser.
+ * @param keyName the key sequence to search
+ * @return the id of the standard accelerator, or AccelNone if there
+ * is none
+ */
+ KCONFIGGUI_EXPORT StandardShortcut find(const char *keyName);
+
+ /**
+ * Returns the hardcoded default shortcut for @p id.
+ * This does not take into account the user's configuration.
+ * @param id the id of the accelerator
+ * @return the default shortcut of the accelerator
+ */
+ KCONFIGGUI_EXPORT QList<QKeySequence> hardcodedDefaultShortcut(StandardShortcut id);
+
+ /**
+ * Saves the new shortcut \a cut for standard accel \a id.
+ */
+ KCONFIGGUI_EXPORT void saveShortcut(StandardShortcut id, const QList<QKeySequence> &newShortcut);
+
+ /**
+ * Open file. Default: Ctrl-o
+ * @return the shortcut of the standard accelerator
+ */
+ KCONFIGGUI_EXPORT const QList<QKeySequence> &open();
+
+ /**
+ * Create a new document (or whatever). Default: Ctrl-n
+ * @return the shortcut of the standard accelerator
+ */
+ KCONFIGGUI_EXPORT const QList<QKeySequence> &openNew();
+
+ /**
+ * Close current document. Default: Ctrl-w
+ * @return the shortcut of the standard accelerator
+ */
+ KCONFIGGUI_EXPORT const QList<QKeySequence> &close();
+
+ /**
+ * Save current document. Default: Ctrl-s
+ * @return the shortcut of the standard accelerator
+ */
+ KCONFIGGUI_EXPORT const QList<QKeySequence> &save();
+
+ /**
+ * Print current document. Default: Ctrl-p
+ * @return the shortcut of the standard accelerator
+ */
+ KCONFIGGUI_EXPORT const QList<QKeySequence> &print();
+
+ /**
+ * Quit the program. Default: Ctrl-q
+ * @return the shortcut of the standard accelerator
+ */
+ KCONFIGGUI_EXPORT const QList<QKeySequence> &quit();
+
+ /**
+ * Undo last operation. Default: Ctrl-z
+ * @return the shortcut of the standard accelerator
+ */
+ KCONFIGGUI_EXPORT const QList<QKeySequence> &undo();
+
+ /**
+ * Redo. Default: Shift-Ctrl-z
+ * @return the shortcut of the standard accelerator
+ */
+ KCONFIGGUI_EXPORT const QList<QKeySequence> &redo();
+
+ /**
+ * Cut selected area and store it in the clipboard. Default: Ctrl-x
+ * @return the shortcut of the standard accelerator
+ */
+ KCONFIGGUI_EXPORT const QList<QKeySequence> &cut();
+
+ /**
+ * Copy selected area into the clipboard. Default: Ctrl-c
+ * @return the shortcut of the standard accelerator
+ */
+ KCONFIGGUI_EXPORT const QList<QKeySequence> &copy();
+
+ /**
+ * Paste contents of clipboard at mouse/cursor position. Default: Ctrl-v
+ * @return the shortcut of the standard accelerator
+ */
+ KCONFIGGUI_EXPORT const QList<QKeySequence> &paste();
+
+ /**
+ * Paste the selection at mouse/cursor position. Default: Ctrl-Shift-Insert
+ * @return the shortcut of the standard accelerator
+ */
+ KCONFIGGUI_EXPORT const QList<QKeySequence> &pasteSelection();
+
+ /**
+ * Select all. Default: Ctrl-A
+ * @return the shortcut of the standard accelerator
+ **/
+ KCONFIGGUI_EXPORT const QList<QKeySequence> &selectAll();
+
+ /**
+ * Delete a word back from mouse/cursor position. Default: Ctrl-Backspace
+ * @return the shortcut of the standard accelerator
+ */
+ KCONFIGGUI_EXPORT const QList<QKeySequence> &deleteWordBack();
+
+ /**
+ * Delete a word forward from mouse/cursor position. Default: Ctrl-Delete
+ * @return the shortcut of the standard accelerator
+ */
+ KCONFIGGUI_EXPORT const QList<QKeySequence> &deleteWordForward();
+
+ /**
+ * Find, search. Default: Ctrl-f
+ * @return the shortcut of the standard accelerator
+ */
+ KCONFIGGUI_EXPORT const QList<QKeySequence> &find();
+
+ /**
+ * Find/search next. Default: F3
+ * @return the shortcut of the standard accelerator
+ */
+ KCONFIGGUI_EXPORT const QList<QKeySequence> &findNext();
+
+ /**
+ * Find/search previous. Default: Shift-F3
+ * @return the shortcut of the standard accelerator
+ */
+ KCONFIGGUI_EXPORT const QList<QKeySequence> &findPrev();
+
+ /**
+ * Find and replace matches. Default: Ctrl-r
+ * @return the shortcut of the standard accelerator
+ */
+ KCONFIGGUI_EXPORT const QList<QKeySequence> &replace();
+
+ /**
+ * Zoom in. Default: Ctrl-Plus
+ * @return the shortcut of the standard accelerator
+ */
+ KCONFIGGUI_EXPORT const QList<QKeySequence> &zoomIn();
+
+ /**
+ * Zoom out. Default: Ctrl-Minus
+ * @return the shortcut of the standard accelerator
+ */
+ KCONFIGGUI_EXPORT const QList<QKeySequence> &zoomOut();
+
+ /**
+ * Toggle insert/overwrite (with visual feedback, e.g. in the statusbar). Default: Insert
+ * @return the shortcut of the standard accelerator
+ */
+ KCONFIGGUI_EXPORT const QList<QKeySequence> &insert();
+
+ /**
+ * Goto home page. Default: Alt-Home
+ * @return the shortcut of the standard accelerator
+ */
+ KCONFIGGUI_EXPORT const QList<QKeySequence> &home();
+
+ /**
+ * Goto beginning of the document. Default: Ctrl-Home
+ * @return the shortcut of the standard accelerator
+ */
+ KCONFIGGUI_EXPORT const QList<QKeySequence> &begin();
+
+ /**
+ * Goto end of the document. Default: Ctrl-End
+ * @return the shortcut of the standard accelerator
+ */
+ KCONFIGGUI_EXPORT const QList<QKeySequence> &end();
+
+ /**
+ * Goto beginning of current line. Default: Home
+ * @return the shortcut of the standard accelerator
+ */
+ KCONFIGGUI_EXPORT const QList<QKeySequence> &beginningOfLine();
+
+ /**
+ * Goto end of current line. Default: End
+ * @return the shortcut of the standard accelerator
+ */
+ KCONFIGGUI_EXPORT const QList<QKeySequence> &endOfLine();
+
+ /**
+ * Scroll up one page. Default: Prior
+ * @return the shortcut of the standard accelerator
+ */
+ KCONFIGGUI_EXPORT const QList<QKeySequence> &prior();
+
+ /**
+ * Scroll down one page. Default: Next
+ * @return the shortcut of the standard accelerator
+ */
+ KCONFIGGUI_EXPORT const QList<QKeySequence> &next();
+
+ /**
+ * Go to line. Default: Ctrl+G
+ * @return the shortcut of the standard accelerator
+ */
+ KCONFIGGUI_EXPORT const QList<QKeySequence> &gotoLine();
+
+ /**
+ * Add current page to bookmarks. Default: Ctrl+B
+ * @return the shortcut of the standard accelerator
+ */
+ KCONFIGGUI_EXPORT const QList<QKeySequence> &addBookmark();
+
+ /**
+ * Next Tab. Default: Ctrl-<
+ * @return the shortcut of the standard accelerator
+ */
+ KCONFIGGUI_EXPORT const QList<QKeySequence> &tabNext();
+
+ /**
+ * Previous Tab. Default: Ctrl->
+ * @return the shortcut of the standard accelerator
+ */
+ KCONFIGGUI_EXPORT const QList<QKeySequence> &tabPrev();
+
+ /**
+ * Full Screen Mode. Default: Ctrl+Shift+F
+ * @return the shortcut of the standard accelerator
+ */
+ KCONFIGGUI_EXPORT const QList<QKeySequence> &fullScreen();
+
+ /**
+ * Help the user in the current situation. Default: F1
+ * @return the shortcut of the standard accelerator
+ */
+ KCONFIGGUI_EXPORT const QList<QKeySequence> &help();
+
+ /**
+ * Complete text in input widgets. Default Ctrl+E
+ * @return the shortcut of the standard accelerator
+ **/
+ KCONFIGGUI_EXPORT const QList<QKeySequence> &completion();
+
+ /**
+ * Iterate through a list when completion returns
+ * multiple items. Default: Ctrl+Up
+ * @return the shortcut of the standard accelerator
+ */
+ KCONFIGGUI_EXPORT const QList<QKeySequence> &prevCompletion();
+
+ /**
+ * Iterate through a list when completion returns
+ * multiple items. Default: Ctrl+Down
+ * @return the shortcut of the standard accelerator
+ */
+ KCONFIGGUI_EXPORT const QList<QKeySequence> &nextCompletion();
+
+ /**
+ * Find a string within another string or list of strings.
+ * Default: Ctrl-T
+ * @return the shortcut of the standard accelerator
+ */
+ KCONFIGGUI_EXPORT const QList<QKeySequence> &substringCompletion();
+
+ /**
+ * Help users iterate through a list of entries. Default: Up
+ * @return the shortcut of the standard accelerator
+ */
+ KCONFIGGUI_EXPORT const QList<QKeySequence> &rotateUp();
+
+ /**
+ * Help users iterate through a list of entries. Default: Down
+ * @return the shortcut of the standard accelerator
+ */
+ KCONFIGGUI_EXPORT const QList<QKeySequence> &rotateDown();
+
+ /**
+ * What's This button. Default: Shift+F1
+ * @return the shortcut of the standard accelerator
+ */
+ KCONFIGGUI_EXPORT const QList<QKeySequence> &whatsThis();
+
+ /**
+ * Reload. Default: F5
+ * @return the shortcut of the standard accelerator
+ */
+ KCONFIGGUI_EXPORT const QList<QKeySequence> &reload();
+
+ /**
+ * Up. Default: Alt+Up
+ * @return the shortcut of the standard accelerator
+ */
+ KCONFIGGUI_EXPORT const QList<QKeySequence> &up();
+
+ /**
+ * Back. Default: Alt+Left
+ * @return the shortcut of the standard accelerator
+ */
+ KCONFIGGUI_EXPORT const QList<QKeySequence> &back();
+
+ /**
+ * Forward. Default: ALT+Right
+ * @return the shortcut of the standard accelerator
+ */
+ KCONFIGGUI_EXPORT const QList<QKeySequence> &forward();
+
+ /**
+ * BackwardWord. Default: Ctrl+Left
+ * @return the shortcut of the standard accelerator
+ */
+ KCONFIGGUI_EXPORT const QList<QKeySequence> &backwardWord();
+
+ /**
+ * ForwardWord. Default: Ctrl+Right
+ * @return the shortcut of the standard accelerator
+ */
+ KCONFIGGUI_EXPORT const QList<QKeySequence> &forwardWord();
+
+ /**
+ * Show Menu Bar. Default: Ctrl-M
+ * @return the shortcut of the standard accelerator
+ */
+ KCONFIGGUI_EXPORT const QList<QKeySequence> &showMenubar();
+
+}
+
+#endif // KSTANDARDSHORTCUT_H
diff --git a/tier1/kconfig/src/gui/kwindowconfig.cpp b/tier1/kconfig/src/gui/kwindowconfig.cpp
new file mode 100644
index 00000000..6b7ae5f0
--- /dev/null
+++ b/tier1/kconfig/src/gui/kwindowconfig.cpp
@@ -0,0 +1,83 @@
+/*
+ This file is part of the KDE libraries
+ Copyright (c) 2012 Benjamin Port <benjamin.port@ben2367.fr>
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) version 3, or any
+ later version accepted by the membership of KDE e.V. (or its
+ successor approved by the membership of KDE e.V.), which shall
+ act as a proxy defined in Section 6 of version 3 of the license.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "kwindowconfig.h"
+
+#include <QScreen>
+#include <QWindow>
+
+static const char* s_initialSizePropertyName = "_kconfig_initial_size";
+static const char* s_initialScreenSizePropertyName = "_kconfig_initial_screen_size";
+
+void KWindowConfig::saveWindowSize(const QWindow *window, KConfigGroup &config, KConfigGroup::WriteConfigFlags options)
+{
+ if (!window)
+ return;
+ const QRect desk = window->screen()->geometry();
+
+ const QSize sizeToSave = window->size();
+ const bool isMaximized = window->windowState() & Qt::WindowMaximized;
+
+ const QString screenMaximizedString(QString::fromLatin1("Window-Maximized %1x%2").arg(desk.height()).arg(desk.width()));
+ // Save size only if window is not maximized
+ if (!isMaximized) {
+ const QSize defaultSize(window->property(s_initialSizePropertyName).toSize());
+ const QSize defaultScreenSize(window->property(s_initialScreenSizePropertyName).toSize());
+ const bool sizeValid = defaultSize.isValid() && defaultScreenSize.isValid();
+ if (!sizeValid || (sizeValid && (defaultSize != sizeToSave || defaultScreenSize != desk.size()))) {
+ const QString wString(QString::fromLatin1("Width %1").arg(desk.width()));
+ const QString hString(QString::fromLatin1("Height %1").arg(desk.height()));
+ config.writeEntry(wString, sizeToSave.width(), options);
+ config.writeEntry(hString, sizeToSave.height(), options);
+ }
+ }
+ if ( (isMaximized == false) && !config.hasDefault(screenMaximizedString) )
+ config.revertToDefault(screenMaximizedString);
+ else
+ config.writeEntry(screenMaximizedString, isMaximized, options);
+
+}
+
+void KWindowConfig::restoreWindowSize(QWindow* window, const KConfigGroup& config)
+{
+ if (!window)
+ return;
+
+ const QRect desk = window->screen()->geometry();
+
+ const int width = config.readEntry(QString::fromLatin1("Width %1").arg(desk.width()), window->size().width());
+ const int height = config.readEntry(QString::fromLatin1("Height %1").arg(desk.height()), window->size().height());
+ const bool isMaximized = config.readEntry(QString::fromLatin1("Window-Maximized %1x%2").arg(desk.height()).arg(desk.width()), false);
+
+ // Check default size
+ const QSize defaultSize(window->property(s_initialSizePropertyName).toSize());
+ const QSize defaultScreenSize(window->property(s_initialScreenSizePropertyName).toSize());
+ if (!defaultSize.isValid() || !defaultScreenSize.isValid()) {
+ window->setProperty(s_initialSizePropertyName, window->size());
+ window->setProperty(s_initialScreenSizePropertyName, desk.size());
+ }
+
+ // If window is maximized set maximized state and in all case set the size
+ window->resize(width, height);
+ if (isMaximized) {
+ window->setWindowState(Qt::WindowMaximized);
+ }
+}
diff --git a/tier1/kconfig/src/gui/kwindowconfig.h b/tier1/kconfig/src/gui/kwindowconfig.h
new file mode 100644
index 00000000..2c70571d
--- /dev/null
+++ b/tier1/kconfig/src/gui/kwindowconfig.h
@@ -0,0 +1,58 @@
+/*
+ This file is part of the KDE libraries
+ Copyright (c) 2012 Benjamin Port <benjamin.port@ben2367.fr>
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) version 3, or any
+ later version accepted by the membership of KDE e.V. (or its
+ successor approved by the membership of KDE e.V.), which shall
+ act as a proxy defined in Section 6 of version 3 of the license.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef KWINDOWCONFIG_H
+#define KWINDOWCONFIG_H
+
+#include <kconfiggroup.h>
+#include <kconfiggui_export.h>
+
+class QWindow;
+
+namespace KWindowConfig
+{
+ /**
+ * Saves the window's size dependent on the screen dimension either to the
+ * global or application config file.
+ *
+ * @note the group must be set before calling
+ *
+ * @param window The window to save size.
+ * @param config The config group to read from.
+ * @param options passed to KConfigGroup::writeEntry()
+ * @since 5.0
+ */
+ KCONFIGGUI_EXPORT void saveWindowSize( const QWindow* window, KConfigGroup& config, KConfigGroup::WriteConfigFlags options = KConfigGroup::Normal );
+
+ /**
+ * Restores the dialog's size from the configuration according to
+ * the screen size.
+ *
+ * @note the group must be set before calling
+ *
+ * @param dialog The dialog to restore size.
+ * @param config The config group to read from.
+ * @since 5.0.
+ */
+ KCONFIGGUI_EXPORT void restoreWindowSize( QWindow* window, const KConfigGroup& config );
+}
+
+#endif // KWINDOWCONFIG_H
generated by cgit v1.2.1 (git 2.18.0) at 2025-06-12 23:24:03 +0000