From: Iceyer Date: Wed, 26 Jul 2017 01:54:34 +0000 (+0800) Subject: Merge dsettings X-Git-Tag: archive/raspbian/5.7.12-2+rpi1^2~197 X-Git-Url: https://dgit.raspbian.org/?a=commitdiff_plain;h=881d855ffef2164fe3caa455380aceeae7fb7328;p=dtkcore.git Merge dsettings --- diff --git a/src/base/base.pri b/src/base/base.pri index a061868..39370ac 100644 --- a/src/base/base.pri +++ b/src/base/base.pri @@ -8,7 +8,6 @@ SOURCES += \ $$PWD/dobject.cpp includes.files += $$PWD/*.h -includes.files += $$PWD/*.cpp includes.files += \ $$PWD/DObject \ $$PWD/DSingleton diff --git a/src/filesystem/filesystem.pri b/src/filesystem/filesystem.pri index 01ff7b5..12a7ce5 100644 --- a/src/filesystem/filesystem.pri +++ b/src/filesystem/filesystem.pri @@ -28,7 +28,6 @@ linux { } includes.files += $$PWD/*.h -includes.files += $$PWD/*.cpp includes.files += \ $$PWD/DFileWatcher \ $$PWD/DBaseFileWatcher \ diff --git a/src/install.pri b/src/install.pri deleted file mode 100644 index f17f599..0000000 --- a/src/install.pri +++ /dev/null @@ -1,11 +0,0 @@ -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 diff --git a/src/log/log.pri b/src/log/log.pri index b263dfc..7e91ff9 100644 --- a/src/log/log.pri +++ b/src/log/log.pri @@ -1,6 +1,5 @@ include(cutelogger.pri) includes.files += $$PWD/*.h -includes.files += $$PWD/*.cpp includes.files += \ $$PWD/DLog diff --git a/src/settings/DOption b/src/settings/DOption new file mode 100644 index 0000000..08b6341 --- /dev/null +++ b/src/settings/DOption @@ -0,0 +1 @@ +#include "option.h" diff --git a/src/settings/DSettings b/src/settings/DSettings new file mode 100644 index 0000000..d90bd07 --- /dev/null +++ b/src/settings/DSettings @@ -0,0 +1 @@ +#include "settings.h" diff --git a/src/settings/backend/qsettingbackend.cpp b/src/settings/backend/qsettingbackend.cpp new file mode 100644 index 0000000..67bf941 --- /dev/null +++ b/src/settings/backend/qsettingbackend.cpp @@ -0,0 +1,76 @@ +/** + * 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 +#include +#include + +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 diff --git a/src/settings/backend/qsettingbackend.h b/src/settings/backend/qsettingbackend.h new file mode 100644 index 0000000..4f61d13 --- /dev/null +++ b/src/settings/backend/qsettingbackend.h @@ -0,0 +1,39 @@ +/** + * 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 +#include + +#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 d_ptr; + Q_DECLARE_PRIVATE_D(qGetPtrHelper(d_ptr), QSettingBackend) +}; + +DCORE_END_NAMESPACE diff --git a/src/settings/dsettings.cpp b/src/settings/dsettings.cpp new file mode 100644 index 0000000..a463aa1 --- /dev/null +++ b/src/settings/dsettings.cpp @@ -0,0 +1,215 @@ +/** + * 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 +#include +#include +#include +#include +#include +#include + +#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 options; + + QMap childGroups; + QList 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::fromJson(const QByteArray &json) +{ + auto settingsPtr = QPointer(new DSettings); + settingsPtr->parseJson(json); + return settingsPtr; +} + +QPointer 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 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 > DSettings::groups() const +{ + Q_D(const DSettings); + return d->childGroups.values(); +} + +QPointer DSettings::group(const QString &key) const +{ + Q_D(const DSettings); + return d->childGroups.value(key); +} + +QList > 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 diff --git a/src/settings/dsettings.h b/src/settings/dsettings.h new file mode 100644 index 0000000..e984e4a --- /dev/null +++ b/src/settings/dsettings.h @@ -0,0 +1,67 @@ +/** + * 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 +#include +#include + +#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 fromJson(const QByteArray &json); + static QPointer fromJsonFile(const QString &filepath); + + QStringList keys() const; + QList> options() const; + QPointer option(const QString &key) const; + QVariant value(const QString &key) const; + + QStringList groupKeys() const; + QList> groups() const; + QPointer 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 d_ptr; + Q_DECLARE_PRIVATE_D(qGetPtrHelper(d_ptr), DSettings) +}; + +DCORE_END_NAMESPACE diff --git a/src/settings/dsettingsbackend.h b/src/settings/dsettingsbackend.h new file mode 100644 index 0000000..de9f67f --- /dev/null +++ b/src/settings/dsettingsbackend.h @@ -0,0 +1,45 @@ +/** + * 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 +#include + +#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 diff --git a/src/settings/dsettingsgroup.cpp b/src/settings/dsettingsgroup.cpp new file mode 100644 index 0000000..6c24e49 --- /dev/null +++ b/src/settings/dsettingsgroup.cpp @@ -0,0 +1,145 @@ +/** + * 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 +#include +#include + +DCORE_BEGIN_NAMESPACE + +class DSettingsGroupPrivate +{ +public: + DSettingsGroupPrivate(DSettingsGroup *parent) : q_ptr(parent) {} + + QString key; + QString name; + + QMap options; + + QPointer parent; + QMap childOptions; + QList childOptionKeys; + + QMap childGroups; + QList 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::parentGroup() const +{ + Q_D(const DSettingsGroup); + return d->parent; +} + +void DSettingsGroup::setParentGroup(QPointer 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 > DSettingsGroup::childGroups() const +{ + Q_D(const DSettingsGroup); + QList > grouplist; + for (auto groupKey : d->childGroupKeys) { + grouplist << d->childGroups.value(groupKey); + } + return grouplist; +} + +QList > DSettingsGroup::childOptions() const +{ + Q_D(const DSettingsGroup); + QList > optionlist; + for (auto optionKey : d->childOptionKeys) { + optionlist << d->childOptions.value(optionKey); + } + return optionlist; +} + +QList > DSettingsGroup::options() const +{ + Q_D(const DSettingsGroup); + return d->options.values(); +} + +QPointer DSettingsGroup::fromJson(const QString &prefixKey, const QJsonObject &group) +{ + auto groupPtr = QPointer(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 diff --git a/src/settings/dsettingsgroup.h b/src/settings/dsettingsgroup.h new file mode 100644 index 0000000..68449c9 --- /dev/null +++ b/src/settings/dsettingsgroup.h @@ -0,0 +1,53 @@ +/** + * 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 +#include + +#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 parentGroup() const; + void setParentGroup(QPointer parentGroup); + + QString key() const; + QString name() const; + + QList > childGroups() const; + QList > childOptions() const; + QList > options() const; + + static QPointer fromJson(const QString &prefixKey, const QJsonObject &group); +Q_SIGNALS: + +public Q_SLOTS: + +private: + void parseJson(const QString &prefixKey, const QJsonObject &group); + + QScopedPointer d_ptr; + Q_DECLARE_PRIVATE_D(qGetPtrHelper(d_ptr), DSettingsGroup) +}; + +typedef QPointer GroupPtr; + +DCORE_END_NAMESPACE diff --git a/src/settings/dsettingsoption.cpp b/src/settings/dsettingsoption.cpp new file mode 100644 index 0000000..d0581af --- /dev/null +++ b/src/settings/dsettingsoption.cpp @@ -0,0 +1,189 @@ +/** + * 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 +#include +#include + +DCORE_BEGIN_NAMESPACE + +class DSettingsOptionPrivate +{ +public: + DSettingsOptionPrivate(DSettingsOption *parent) : q_ptr(parent) {} + + void parseJson(const QString &prefixKey, const QJsonObject &option); + + QPointer 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 DSettingsOption::parentGroup() const +{ + Q_D(const DSettingsOption); + return d->parent; +} + +void DSettingsOption::setParentGroup(QPointer 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::fromJson(const QString &prefixKey, const QJsonObject &group) +{ + auto optionPtr = QPointer(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 + + diff --git a/src/settings/dsettingsoption.h b/src/settings/dsettingsoption.h new file mode 100644 index 0000000..f055b54 --- /dev/null +++ b/src/settings/dsettingsoption.h @@ -0,0 +1,62 @@ +/** + * 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 +#include +#include + +#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 parentGroup() const; + void setParentGroup(QPointer 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 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 d_ptr; + Q_DECLARE_PRIVATE_D(qGetPtrHelper(d_ptr), DSettingsOption) +}; + +typedef QPointer OptionPtr; + +DCORE_END_NAMESPACE diff --git a/src/settings/settings.pri b/src/settings/settings.pri new file mode 100644 index 0000000..b7c7006 --- /dev/null +++ b/src/settings/settings.pri @@ -0,0 +1,20 @@ +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 diff --git a/src/src.pro b/src/src.pro index 9aa7dd1..d884720 100644 --- a/src/src.pro +++ b/src/src.pro @@ -7,7 +7,6 @@ TARGET = dtkcore DEFINES += LIBDTKCORE_LIBRARY - INCLUDEPATH += $$PWD HEADERS += \ @@ -16,6 +15,22 @@ 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)