$$PWD/dobject.cpp
includes.files += $$PWD/*.h
-includes.files += $$PWD/*.cpp
includes.files += \
$$PWD/DObject \
$$PWD/DSingleton
}
includes.files += $$PWD/*.h
-includes.files += $$PWD/*.cpp
includes.files += \
$$PWD/DFileWatcher \
$$PWD/DBaseFileWatcher \
+++ /dev/null
-includes.path = $${DTK_INCLUDEPATH}/DCore
-
-INSTALLS += includes target
-
-QMAKE_PKGCONFIG_LIBDIR = $$target.path
-QMAKE_PKGCONFIG_VERSION = $$VERSION
-QMAKE_PKGCONFIG_DESTDIR = pkgconfig
-
-QMAKE_PKGCONFIG_NAME = DTK_CORE
-QMAKE_PKGCONFIG_DESCRIPTION = Deepin Tool Kit Core Header Files
-QMAKE_PKGCONFIG_INCDIR = $$includes.path
include(cutelogger.pri)
includes.files += $$PWD/*.h
-includes.files += $$PWD/*.cpp
includes.files += \
$$PWD/DLog
--- /dev/null
+#include "option.h"
--- /dev/null
+#include "settings.h"
--- /dev/null
+/**
+ * Copyright (C) 2016 Deepin Technology Co., Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ **/
+
+#include "qsettingbackend.h"
+
+#include <QDebug>
+#include <QMutex>
+#include <QSettings>
+
+DCORE_BEGIN_NAMESPACE
+
+class QSettingBackendPrivate
+{
+public:
+ QSettingBackendPrivate(QSettingBackend *parent) : q_ptr(parent) {}
+
+ QSettings *settings = nullptr;
+ QMutex writeLock;
+
+ QSettingBackend *q_ptr;
+ Q_DECLARE_PUBLIC(QSettingBackend)
+};
+
+QSettingBackend::QSettingBackend(const QString &filepath, QObject *parent) :
+ DSettingsBackend(parent), d_ptr(new QSettingBackendPrivate(this))
+{
+ Q_D(QSettingBackend);
+
+ d->settings = new QSettings(filepath, QSettings::NativeFormat, this);
+ qDebug() << "create config" << d->settings->fileName();
+}
+
+QSettingBackend::~QSettingBackend()
+{
+
+}
+
+QStringList QSettingBackend::keys() const
+{
+ Q_D(const QSettingBackend);
+ return d->settings->childGroups();
+}
+
+QVariant QSettingBackend::getOption(const QString &key) const
+{
+ Q_D(const QSettingBackend);
+ d->settings->beginGroup(key);
+ auto value = d->settings->value("value");
+ d->settings->endGroup();
+ return value;
+}
+
+void QSettingBackend::doSetOption(const QString &key, const QVariant &value)
+{
+ Q_D(QSettingBackend);
+ d->writeLock.lock();
+ d->settings->beginGroup(key);
+ d->settings->setValue("value", value);
+ d->settings->endGroup();
+ d->settings->sync();
+ d->writeLock.unlock();
+}
+
+void QSettingBackend::doSync()
+{
+ Q_D(QSettingBackend);
+ d->settings->sync();
+}
+
+DCORE_END_NAMESPACE
--- /dev/null
+/**
+ * Copyright (C) 2016 Deepin Technology Co., Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ **/
+
+#pragma once
+
+#include <QObject>
+#include <QScopedPointer>
+
+#include "dsettingsbackend.h"
+
+DCORE_BEGIN_NAMESPACE
+
+class QSettingBackendPrivate;
+class QSettingBackend : public Dtk::Core::DSettingsBackend
+{
+ Q_OBJECT
+public:
+ explicit QSettingBackend(const QString &filepath, QObject *parent = 0);
+ ~QSettingBackend();
+
+ virtual QStringList keys() const Q_DECL_OVERRIDE;
+ virtual QVariant getOption(const QString &key) const Q_DECL_OVERRIDE;
+
+protected Q_SLOTS:
+ virtual void doSetOption(const QString &key, const QVariant &value) Q_DECL_OVERRIDE;
+ virtual void doSync() Q_DECL_OVERRIDE;
+
+private:
+ QScopedPointer<QSettingBackendPrivate> d_ptr;
+ Q_DECLARE_PRIVATE_D(qGetPtrHelper(d_ptr), QSettingBackend)
+};
+
+DCORE_END_NAMESPACE
--- /dev/null
+/**
+ * Copyright (C) 2016 Deepin Technology Co., Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ **/
+
+#include "dsettings.h"
+
+#include <QMap>
+#include <QFile>
+#include <QJsonObject>
+#include <QJsonArray>
+#include <QJsonDocument>
+#include <QThread>
+#include <QDebug>
+
+#include "dsettingsoption.h"
+#include "dsettingsgroup.h"
+#include "dsettingsbackend.h"
+
+#include "backend/qsettingbackend.h"
+
+DCORE_BEGIN_NAMESPACE
+
+class DSettingsPrivate
+{
+public:
+ DSettingsPrivate(DSettings *parent) : q_ptr(parent) {}
+
+ DSettingsBackend *backend = nullptr;
+ QMap <QString, OptionPtr> options;
+
+ QMap<QString, GroupPtr> childGroups;
+ QList<QString> childGroupKeys;
+
+ DSettings *q_ptr;
+ Q_DECLARE_PUBLIC(DSettings)
+};
+
+
+DSettings::DSettings(QObject *parent) :
+ QObject(parent), d_ptr(new DSettingsPrivate(this))
+{
+}
+
+DSettings::~DSettings()
+{
+
+}
+
+void DSettings::setBackend(DSettingsBackend *backend)
+{
+ Q_D(DSettings);
+ if (nullptr == backend) {
+ return;
+ }
+
+ if (d->backend != nullptr) {
+ qWarning() << "set backend to exist " << d->backend;
+ }
+
+ d->backend = backend;
+ auto backendWriteThread = new QThread;
+ d->backend->moveToThread(backendWriteThread);
+ backendWriteThread->start();
+
+ // load form backend
+ loadValue();
+}
+
+QPointer<DSettings> DSettings::fromJson(const QByteArray &json)
+{
+ auto settingsPtr = QPointer<DSettings>(new DSettings);
+ settingsPtr->parseJson(json);
+ return settingsPtr;
+}
+
+QPointer<DSettings> DSettings::fromJsonFile(const QString &filepath)
+{
+ QFile jsonFile(filepath);
+ jsonFile.open(QIODevice::ReadOnly);
+ auto jsonData = jsonFile.readAll();
+ jsonFile.close();
+
+ return DSettings::fromJson(jsonData);
+}
+
+QStringList DSettings::keys() const
+{
+ Q_D(const DSettings);
+ return d->options.keys();
+}
+
+QPointer<DSettingsOption> DSettings::option(const QString &key) const
+{
+ Q_D(const DSettings);
+ return d->options.value(key);
+}
+
+QVariant DSettings::value(const QString &key) const
+{
+ Q_D(const DSettings);
+ auto opt = d->options.value(key);
+ if (opt.isNull()) {
+ return QVariant();
+ }
+
+ return opt->value();
+}
+
+QStringList DSettings::groupKeys() const
+{
+ Q_D(const DSettings);
+ return d->childGroupKeys;
+}
+
+QList<QPointer<DSettingsGroup> > DSettings::groups() const
+{
+ Q_D(const DSettings);
+ return d->childGroups.values();
+}
+
+QPointer<DSettingsGroup> DSettings::group(const QString &key) const
+{
+ Q_D(const DSettings);
+ return d->childGroups.value(key);
+}
+
+QList<QPointer<DSettingsOption> > DSettings::options() const
+{
+ Q_D(const DSettings);
+ return d->options.values();
+}
+
+QVariant DSettings::getOption(const QString &key) const
+{
+ return option(key)->value();
+}
+
+void DSettings::setOption(const QString &key, const QVariant &value)
+{
+// Q_D(Settings);
+// qDebug() << "set" << key << value;
+ option(key)->setValue(value);
+}
+
+void DSettings::sync()
+{
+ Q_D(DSettings);
+ d->backend->doSync();
+}
+
+void DSettings::reset()
+{
+ Q_D(DSettings);
+
+ for (auto option : d->options) {
+ if (option->canReset()) {
+ setOption(option->key(), option->defaultValue());
+ }
+ }
+ d->backend->sync();
+}
+
+void DSettings::parseJson(const QByteArray &json)
+{
+ Q_D(DSettings);
+
+ auto jsonDoc = QJsonDocument::fromJson(json);
+ auto mainGroups = jsonDoc.object().value("groups");
+ for (auto groupJson : mainGroups.toArray()) {
+ auto group = DSettingsGroup::fromJson("", groupJson.toObject());
+ for (auto option : group->options()) {
+// qDebug() << "add option" << option->key();
+ d->options.insert(option->key(), option);
+ }
+ d->childGroupKeys << group->key();
+ d->childGroups.insert(group->key(), group);
+ }
+
+ for (auto option : d->options.values()) {
+ d->options.insert(option->key(), option);
+
+ connect(option.data(), &DSettingsOption::valueChanged,
+ this, [ = ](QVariant value) {
+ Q_EMIT d->backend->setOption(option->key(), value);
+// Q_EMIT d->backend->sync();
+ Q_EMIT valueChanged(option->key(), value);
+ });
+ }
+}
+
+void DSettings::loadValue()
+{
+ Q_D(DSettings);
+
+// qDebug() << d->backend;
+ for (auto key : d->backend->keys()) {
+ //qDebug() << "load value for key" << key;
+ auto value = d->backend->getOption(key);
+ auto opt = option(key);
+ if (!value.isValid() || opt.isNull()) {
+ continue;
+ }
+
+ opt->blockSignals(true);
+ opt->setValue(value);
+ opt->blockSignals(false);
+ }
+}
+
+DCORE_END_NAMESPACE
--- /dev/null
+/**
+ * Copyright (C) 2016 Deepin Technology Co., Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ **/
+
+#pragma once
+
+#include <QObject>
+#include <QPointer>
+#include <QScopedPointer>
+
+#include "dtkcore_global.h"
+
+DCORE_BEGIN_NAMESPACE
+
+class DSettingsBackend;
+class DSettingsOption;
+class DSettingsGroup;
+class DSettingsPrivate;
+class DSettings : public QObject
+{
+ Q_OBJECT
+public:
+ explicit DSettings(QObject *parent = 0);
+ ~DSettings();
+
+ void setBackend(DSettingsBackend *backend = nullptr);
+
+ static QPointer<DSettings> fromJson(const QByteArray &json);
+ static QPointer<DSettings> fromJsonFile(const QString &filepath);
+
+ QStringList keys() const;
+ QList<QPointer<DSettingsOption>> options() const;
+ QPointer<DSettingsOption> option(const QString &key) const;
+ QVariant value(const QString &key) const;
+
+ QStringList groupKeys() const;
+ QList<QPointer<DSettingsGroup>> groups() const;
+ QPointer<DSettingsGroup> group(const QString &key) const;
+
+ QVariant getOption(const QString &key) const;
+
+Q_SIGNALS:
+ void valueChanged(const QString &key, const QVariant &value);
+
+public Q_SLOTS:
+ //!
+ //! \brief sync
+ //! WARNING: sync will block
+ void sync() ;
+
+ void setOption(const QString &key, const QVariant &value);
+ void reset() ;
+
+private:
+ void parseJson(const QByteArray &json);
+ void loadValue();
+
+ QScopedPointer<DSettingsPrivate> d_ptr;
+ Q_DECLARE_PRIVATE_D(qGetPtrHelper(d_ptr), DSettings)
+};
+
+DCORE_END_NAMESPACE
--- /dev/null
+/**
+ * Copyright (C) 2016 Deepin Technology Co., Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ **/
+
+
+#pragma once
+
+#include <QObject>
+#include <QScopedPointer>
+
+#include "dtkcore_global.h"
+
+DCORE_BEGIN_NAMESPACE
+
+class DSettingsBackend : public QObject
+{
+ Q_OBJECT
+public:
+ explicit DSettingsBackend(QObject *parent = 0): QObject(parent)
+ {
+ connect(this, &DSettingsBackend::sync, this, &DSettingsBackend::doSync, Qt::QueuedConnection);
+ connect(this, &DSettingsBackend::setOption, this, &DSettingsBackend::doSetOption, Qt::QueuedConnection);
+ }
+ virtual ~DSettingsBackend() {}
+
+ virtual QStringList keys() const = 0;
+ virtual QVariant getOption(const QString &key) const = 0;
+
+ virtual void doSync() = 0;
+
+protected:
+ virtual void doSetOption(const QString &key, const QVariant &value) = 0;
+
+Q_SIGNALS:
+ void sync();
+ void setOption(const QString &key, const QVariant &value);
+ void optionChanged(const QString &key, const QVariant &value);
+};
+
+DCORE_END_NAMESPACE
--- /dev/null
+/**
+ * Copyright (C) 2016 Deepin Technology Co., Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ **/
+
+#include "dsettingsgroup.h"
+
+#include <QMap>
+#include <QJsonObject>
+#include <QJsonArray>
+
+DCORE_BEGIN_NAMESPACE
+
+class DSettingsGroupPrivate
+{
+public:
+ DSettingsGroupPrivate(DSettingsGroup *parent) : q_ptr(parent) {}
+
+ QString key;
+ QString name;
+
+ QMap<QString, OptionPtr> options;
+
+ QPointer<DSettingsGroup> parent;
+ QMap<QString, OptionPtr> childOptions;
+ QList<QString> childOptionKeys;
+
+ QMap<QString, GroupPtr> childGroups;
+ QList<QString> childGroupKeys;
+
+ void parseJson(const QString &prefixKey, const QJsonObject &group);
+
+ DSettingsGroup *q_ptr;
+ Q_DECLARE_PUBLIC(DSettingsGroup)
+};
+
+DSettingsGroup::DSettingsGroup(QObject *parent) :
+ QObject(parent), d_ptr(new DSettingsGroupPrivate(this))
+{
+
+}
+
+DSettingsGroup::~DSettingsGroup()
+{
+
+}
+
+QPointer<DSettingsGroup> DSettingsGroup::parentGroup() const
+{
+ Q_D(const DSettingsGroup);
+ return d->parent;
+}
+
+void DSettingsGroup::setParentGroup(QPointer<DSettingsGroup> parentGroup)
+{
+ Q_D(DSettingsGroup);
+ d->parent = parentGroup;
+}
+
+QString DSettingsGroup::key() const
+{
+ Q_D(const DSettingsGroup);
+ return d->key;
+}
+
+QString DSettingsGroup::name() const
+{
+ Q_D(const DSettingsGroup);
+ return d->name;
+}
+
+QList<QPointer<DSettingsGroup> > DSettingsGroup::childGroups() const
+{
+ Q_D(const DSettingsGroup);
+ QList<QPointer<DSettingsGroup> > grouplist;
+ for (auto groupKey : d->childGroupKeys) {
+ grouplist << d->childGroups.value(groupKey);
+ }
+ return grouplist;
+}
+
+QList<QPointer<DSettingsOption> > DSettingsGroup::childOptions() const
+{
+ Q_D(const DSettingsGroup);
+ QList<QPointer<DSettingsOption> > optionlist;
+ for (auto optionKey : d->childOptionKeys) {
+ optionlist << d->childOptions.value(optionKey);
+ }
+ return optionlist;
+}
+
+QList<QPointer<DSettingsOption> > DSettingsGroup::options() const
+{
+ Q_D(const DSettingsGroup);
+ return d->options.values();
+}
+
+QPointer<DSettingsGroup> DSettingsGroup::fromJson(const QString &prefixKey, const QJsonObject &group)
+{
+ auto groupPtr = QPointer<DSettingsGroup>(new DSettingsGroup);
+ groupPtr->parseJson(prefixKey, group);
+ return groupPtr;
+}
+
+void DSettingsGroup::parseJson(const QString &prefixKey, const QJsonObject &group)
+{
+ Q_D(DSettingsGroup);
+ d->parseJson(prefixKey, group);
+}
+
+void DSettingsGroupPrivate::parseJson(const QString &prefixKey, const QJsonObject &group)
+{
+ Q_Q(DSettingsGroup);
+ key = group.value("key").toString();
+ Q_ASSERT(!key.isEmpty());
+ key = prefixKey.isEmpty() ? key : prefixKey + "." + key;
+ name = group.value("name").toString();
+
+ for (auto optionJson : group.value("options").toArray()) {
+ auto optionObject = optionJson.toObject();
+ auto option = DSettingsOption::fromJson(key, optionObject);
+ options.insert(option->key(), option);
+ childOptions.insert(option->key(), option);
+ childOptionKeys << option->key();
+ }
+
+ auto subGroups = group.value("groups").toArray();
+ for (auto subGroup : subGroups) {
+ auto child = DSettingsGroup::fromJson(key, subGroup.toObject());
+ child->setParentGroup(q);
+ childGroups.insert(child->key(), child);
+ childGroupKeys << child->key();
+
+ for (auto option : child->options()) {
+ options.insert(option->key(), option);
+ }
+ }
+
+}
+
+DCORE_END_NAMESPACE
--- /dev/null
+/**
+ * Copyright (C) 2016 Deepin Technology Co., Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ **/
+
+#pragma once
+
+#include <QObject>
+#include <QPointer>
+
+#include "dsettingsoption.h"
+
+#include "dtkcore_global.h"
+
+DCORE_BEGIN_NAMESPACE
+
+class DSettingsGroupPrivate;
+class DSettingsGroup : public QObject
+{
+ Q_OBJECT
+public:
+ explicit DSettingsGroup(QObject *parent = 0);
+ ~DSettingsGroup();
+
+ QPointer<DSettingsGroup> parentGroup() const;
+ void setParentGroup(QPointer<DSettingsGroup> parentGroup);
+
+ QString key() const;
+ QString name() const;
+
+ QList<QPointer<DSettingsGroup> > childGroups() const;
+ QList<QPointer<DSettingsOption> > childOptions() const;
+ QList<QPointer<DSettingsOption> > options() const;
+
+ static QPointer<DSettingsGroup> fromJson(const QString &prefixKey, const QJsonObject &group);
+Q_SIGNALS:
+
+public Q_SLOTS:
+
+private:
+ void parseJson(const QString &prefixKey, const QJsonObject &group);
+
+ QScopedPointer<DSettingsGroupPrivate> d_ptr;
+ Q_DECLARE_PRIVATE_D(qGetPtrHelper(d_ptr), DSettingsGroup)
+};
+
+typedef QPointer<DSettingsGroup> GroupPtr;
+
+DCORE_END_NAMESPACE
--- /dev/null
+/**
+ * Copyright (C) 2016 Deepin Technology Co., Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ **/
+
+#include "dsettingsoption.h"
+
+#include <QVariant>
+#include <QJsonObject>
+#include <QJsonArray>
+
+DCORE_BEGIN_NAMESPACE
+
+class DSettingsOptionPrivate
+{
+public:
+ DSettingsOptionPrivate(DSettingsOption *parent) : q_ptr(parent) {}
+
+ void parseJson(const QString &prefixKey, const QJsonObject &option);
+
+ QPointer<DSettingsGroup> parent;
+
+ QString key;
+ QString name;
+ QString viewType;
+ QVariant defalutValue;
+ QVariant value;
+ QVariantMap datas;
+ bool canReset;
+ bool hidden;
+
+ DSettingsOption *q_ptr;
+ Q_DECLARE_PUBLIC(DSettingsOption)
+};
+
+DSettingsOption::DSettingsOption(QObject *parent) :
+ QObject(parent), d_ptr(new DSettingsOptionPrivate(this))
+{
+
+}
+
+DSettingsOption::~DSettingsOption()
+{
+
+}
+
+QPointer<DSettingsGroup> DSettingsOption::parentGroup() const
+{
+ Q_D(const DSettingsOption);
+ return d->parent;
+}
+
+void DSettingsOption::setParentGroup(QPointer<DSettingsGroup> parentGroup)
+{
+ Q_D(DSettingsOption);
+ d->parent = parentGroup;
+}
+
+QString DSettingsOption::key() const
+{
+ Q_D(const DSettingsOption);
+ return d->key;
+}
+
+QString DSettingsOption::name() const
+{
+ Q_D(const DSettingsOption);
+ return d->name;
+}
+
+bool DSettingsOption::canReset() const
+{
+ Q_D(const DSettingsOption);
+ return d->canReset;
+}
+
+QVariant DSettingsOption::defaultValue() const
+{
+ Q_D(const DSettingsOption);
+ return d->defalutValue;
+}
+
+QVariant DSettingsOption::value() const
+{
+ Q_D(const DSettingsOption);
+ return d->value;
+}
+
+QVariant DSettingsOption::data(const QString &dataType) const
+{
+ Q_D(const DSettingsOption);
+ return d->datas.value(dataType);
+}
+
+QString DSettingsOption::viewType() const
+{
+ Q_D(const DSettingsOption);
+ return d->viewType;
+}
+
+bool DSettingsOption::isHidden() const
+{
+ Q_D(const DSettingsOption);
+ return d->hidden;
+}
+
+QPointer<DSettingsOption> DSettingsOption::fromJson(const QString &prefixKey, const QJsonObject &group)
+{
+ auto optionPtr = QPointer<DSettingsOption>(new DSettingsOption);
+ optionPtr->parseJson(prefixKey, group);
+ return optionPtr;
+}
+
+void DSettingsOption::setValue(QVariant value)
+{
+ Q_D(DSettingsOption);
+
+ if (d->value == value) {
+ return;
+ }
+
+ d->value = value;
+ Q_EMIT valueChanged(value);
+}
+
+void DSettingsOption::setData(const QString &dataType, QVariant value)
+{
+ Q_D(DSettingsOption);
+
+ if (d->datas.value(dataType) == value) {
+ return;
+ }
+
+ d->datas.insert(dataType, value);
+
+ Q_EMIT dataChanged(dataType, value);
+}
+
+void DSettingsOption::parseJson(const QString &prefixKey, const QJsonObject &option)
+{
+ Q_D(DSettingsOption);
+ d->parseJson(prefixKey, option);
+}
+
+void DSettingsOptionPrivate::parseJson(const QString &prefixKey, const QJsonObject &option)
+{
+// Q_Q(Option);
+ key = option.value("key").toString();
+ Q_ASSERT(!key.isEmpty());
+ Q_ASSERT(!prefixKey.isEmpty());
+ key = prefixKey + "." + key;
+ name = option.value("name").toString();
+
+ canReset = !option.contains("reset") ? true : option.value("reset").toBool();
+ defalutValue = option.value("default").toVariant();
+ hidden = !option.contains("hide") ? false : option.value("hide").toBool();
+ viewType = option.value("type").toString();
+ value = defalutValue;
+
+ QStringList revserdKeys;
+ revserdKeys << "key" << "name" << "reset"
+ << "default" << "hide" << "type";
+
+ auto allKeys = option.keys();
+ for (auto key : revserdKeys) {
+ allKeys.removeAll(key);
+ }
+
+ for (auto key : allKeys) {
+ auto value = option.value(key);
+ if (value.isArray()) {
+ QStringList stringlist;
+ for (auto va : value.toArray()) {
+ stringlist << QString("%1").arg(va.toString());
+ }
+ datas.insert(key, stringlist);
+ } else {
+ datas.insert(key, value);
+ }
+ }
+}
+
+DCORE_END_NAMESPACE
+
+
--- /dev/null
+/**
+ * Copyright (C) 2016 Deepin Technology Co., Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ **/
+
+#pragma once
+
+#include <QVariant>
+#include <QObject>
+#include <QPointer>
+
+#include "dtkcore_global.h"
+
+DCORE_BEGIN_NAMESPACE
+
+class DSettingsGroup;
+class DSettingsOptionPrivate;
+class DSettingsOption : public QObject
+{
+ Q_OBJECT
+ Q_PROPERTY(QVariant value READ value WRITE setValue NOTIFY valueChanged)
+
+public:
+ explicit DSettingsOption(QObject *parent = 0);
+ ~DSettingsOption();
+
+ QPointer<DSettingsGroup> parentGroup() const;
+ void setParentGroup(QPointer<DSettingsGroup> parentGroup);
+
+ QString key() const;
+ QString name() const;
+ bool canReset() const;
+ QVariant defaultValue() const;
+ QVariant value() const;
+ QVariant data(const QString &dataType) const;
+
+ QString viewType() const;
+ bool isHidden() const;
+
+ static QPointer<DSettingsOption> fromJson(const QString &prefixKey, const QJsonObject &group);
+Q_SIGNALS:
+ void valueChanged(QVariant value);
+ void dataChanged(const QString &dataType, QVariant value);
+
+public Q_SLOTS:
+ void setValue(QVariant value);
+ void setData(const QString &dataType, QVariant value);
+
+private:
+ void parseJson(const QString &prefixKey, const QJsonObject &option);
+
+ QScopedPointer<DSettingsOptionPrivate> d_ptr;
+ Q_DECLARE_PRIVATE_D(qGetPtrHelper(d_ptr), DSettingsOption)
+};
+
+typedef QPointer<DSettingsOption> OptionPtr;
+
+DCORE_END_NAMESPACE
--- /dev/null
+INCLUDEPATH += $$PWD
+
+SOURCES += \
+ $$PWD/backend/qsettingbackend.cpp \
+ $$PWD/dsettings.cpp \
+ $$PWD/dsettingsoption.cpp \
+ $$PWD/dsettingsgroup.cpp
+
+HEADERS +=\
+ $$PWD/backend/qsettingbackend.h \
+ $$PWD/dsettings.h \
+ $$PWD/dsettingsoption.h \
+ $$PWD/dsettingsgroup.h \
+ $$PWD/dsettingsbackend.h
+
+includes.files += $${PWD}/*.h
+includes.files += $${PWD}/backend/*.h
+includes.files += \
+ $${PWD}/DSettings \
+ $${PWD}/DOption
DEFINES += LIBDTKCORE_LIBRARY
-
INCLUDEPATH += $$PWD
HEADERS += \
include($$PWD/base/base.pri)
include($$PWD/log/log.pri)
include($$PWD/filesystem/filesystem.pri)
+include($$PWD/settings/settings.pri)
+
+# ----------------------------------------------
+# install config
+
+includes.files += $$PWD/*.h
+includes.path = $${DTK_INCLUDEPATH}/DCore
+
+INSTALLS += includes target
+
+QMAKE_PKGCONFIG_LIBDIR = $$target.path
+QMAKE_PKGCONFIG_VERSION = $$VERSION
+QMAKE_PKGCONFIG_DESTDIR = pkgconfig
+
+QMAKE_PKGCONFIG_NAME = DTK_CORE
+QMAKE_PKGCONFIG_DESCRIPTION = Deepin Tool Kit Core Header Files
+QMAKE_PKGCONFIG_INCDIR = $$includes.path
-include($$PWD/install.pri)
projects / dtkcore.git / commitdiff