qt: Add Qt Wrapper library and QML module

8 files changed, 420 insertions, 0 deletions

diff --git a/qt/cmake/Config.cmake.in b/qt/cmake/Config.cmake.in
new file mode 100644
index 0000000..a0d89fc
--- /dev/null
+++ b/qt/cmake/Config.cmake.in
@@ -0,0 +1,9 @@
+@PACKAGE_INIT@
+
+include("${CMAKE_CURRENT_LIST_DIR}/@targets_export_name@.cmake")
+set(LIBKZQSETTINGS_INCLUDE_DIR "${PACKAGE_PREFIX_DIR}/KaZoe")
+find_package(Qt6 COMPONENTS Core REQUIRED)
+find_package(KzSettings REQUIRED)
+set(LIBKZQSETTINGS_LIBRARIES "KzQSettings" "Qt6::Core" "${LIBKZSETTINGS_LIBRARIES}")
+
+check_required_components("@PROJECT_NAME@")
diff --git a/qt/kzqproperty.cpp b/qt/kzqproperty.cpp
new file mode 100644
index 0000000..4290e8c
--- /dev/null
+++ b/qt/kzqproperty.cpp
@@ -0,0 +1,64 @@
+#include "kzqproperty.h"
+#include "kzqsettings.h"
+
+namespace KaZoe {
+class KzQPropertyPrivate
+{
+    Q_DISABLE_COPY(KzQPropertyPrivate)
+    Q_DECLARE_PUBLIC(KaZoe::KzQProperty)
+
+    KaZoe::KzQProperty * const q_ptr;
+    QString m_key;
+    QVariant m_value;
+    KaZoe::KzQSettings m_settings;
+
+    KzQPropertyPrivate(KaZoe::KzQProperty* systemprop): q_ptr(systemprop){}
+};
+};
+
+KaZoe::KzQProperty::KzQProperty(QObject *parent)
+    : QObject{parent}
+    , d_ptr(new KaZoe::KzQPropertyPrivate(this))
+{
+    Q_D(KzQProperty);
+    QObject::connect(&d->m_settings, &KaZoe::KzQSettings::valueChanged, [this](QString id, QVariant value){
+        Q_D(KzQProperty);
+        if(id == d->m_key)
+        {
+            setValue(value);
+        }
+    });
+}
+
+KaZoe::KzQProperty::~KzQProperty() = default;
+
+QString KaZoe::KzQProperty::key() const
+{
+    Q_D(const KzQProperty);
+    return d->m_key;
+}
+
+void KaZoe::KzQProperty::setKey(const QString &newKey)
+{
+    Q_D(KzQProperty);
+    if (d->m_key == newKey)
+        return;
+    d->m_key = newKey;
+    setValue(d->m_settings.get(d->m_key));
+    emit keyChanged();
+}
+
+QVariant KaZoe::KzQProperty::value() const
+{
+    Q_D(const KzQProperty);
+    return d->m_value;
+}
+
+void KaZoe::KzQProperty::setValue(const QVariant &newValue)
+{
+    Q_D(KzQProperty);
+    if (d->m_value == newValue)
+        return;
+    d->m_value = newValue;
+    emit valueChanged();
+}
diff --git a/qt/kzqproperty.h b/qt/kzqproperty.h
new file mode 100644
index 0000000..8bd1b08
--- /dev/null
+++ b/qt/kzqproperty.h
@@ -0,0 +1,38 @@
+#ifndef KZQPROPERTY_H
+#define KZQPROPERTY_H
+
+#include <QObject>
+#include <QVariant>
+#include <QScopedPointer>
+
+namespace KaZoe {
+
+class KzQPropertyPrivate;
+class KzQProperty : public QObject
+{
+    Q_OBJECT
+    Q_PROPERTY(QString key READ key WRITE setKey NOTIFY keyChanged)
+    Q_PROPERTY(QVariant value READ value WRITE setValue NOTIFY valueChanged)
+
+public:
+    explicit KzQProperty(QObject *parent = nullptr);
+    ~KzQProperty();
+
+    QString key() const;
+    void setKey(const QString &newKey);
+
+    QVariant value() const;
+    void setValue(const QVariant &newValue);
+
+signals:
+    void keyChanged();
+    void valueChanged();
+
+private:
+    Q_DISABLE_COPY(KzQProperty)
+    Q_DECLARE_PRIVATE(KzQProperty)
+    QScopedPointer<KzQPropertyPrivate> d_ptr;
+};
+};
+
+#endif // KZQPROPERTY_H
diff --git a/qt/kzqsettings.cpp b/qt/kzqsettings.cpp
new file mode 100644
index 0000000..9ad4674
--- /dev/null
+++ b/qt/kzqsettings.cpp
@@ -0,0 +1,246 @@
+#include "kzqsettings.h"
+#include "../src/kzsettings.h"
+#include <qdebug.h>
+
+class QFileSystemWatcher;
+
+
+QVariant toQVariant(const KzSettingValue &value, QVariant defvalue = QVariant())
+{
+    if(std::holds_alternative<std::string>(value))
+    {
+        return QString::fromStdString(std::get<std::string>(value));
+    }
+    if(std::holds_alternative<int>(value))
+    {
+        return  std::get<int>(value);
+    }
+    if(std::holds_alternative<bool>(value))
+    {
+        return  std::get<bool>(value);
+    }
+    if(std::holds_alternative<double>(value))
+    {
+        return  std::get<double>(value);
+    }
+    return QVariant(defvalue);
+}
+
+KzSettingValue fromQVariant(const QVariant &value)
+{
+    if(value.isNull())
+        return KzSettingValue();
+
+    switch (value.userType())
+    {
+    case QMetaType::Int:
+        return value.value<int>();
+
+    case QMetaType::QString:
+        return value.toString().toStdString();
+
+    case QMetaType::Bool:
+        return value.value<bool>();
+
+    case QMetaType::Double:
+        return value.value<double>();
+
+    default:
+        return false;
+    }
+}
+
+QString toKeyCombined(const std::string& category, const std::string& key)
+{
+    QString keysig;
+    if(category.size())
+    {
+        keysig.append("[");
+        keysig.append(QString::fromStdString(category));
+        keysig.append("]");
+    }
+    keysig.append(QString::fromStdString(key));
+    return keysig;
+}
+
+KaZoe::KzQSettings::KzQSettings(QObject *parent)
+    : QObject(parent)
+    , m_settings(new KaZoe::KzSettings())
+{
+    m_settings->setNotifier([this](const std::string& category, const std::string& key, KzSettingValue value) {
+        emit valueChanged(toKeyCombined(category, key), toQVariant(value));
+    });
+}
+
+KaZoe::KzQSettings::~KzQSettings()
+{
+}
+
+QVariant KaZoe::KzQSettings::getValue(const QString &id, QVariant defvalue)
+{
+    KaZoe::KzSettings settings;
+
+    QString category;
+    QString key = id;
+    if(id.contains("/"))
+    {
+        qWarning() << "OLD Syntax used for " << id;
+        QStringList tab = id.split("/");
+        category = tab[0];
+        tab.removeFirst();
+        key = tab.join("/");
+    }
+
+    KzSettingValue value = settings.get(key.toStdString(), category.toStdString(), fromQVariant(defvalue));
+    return toQVariant(value);
+}
+
+bool KaZoe::KzQSettings::setValue(const QString &id, const QVariant &value)
+{
+    KaZoe::KzSettings settings;
+    bool ret;
+    QString key = id;
+    QString category;
+
+    if(id.contains("/"))
+    {
+        qWarning() << "OLD Syntax used for " << id;
+        QStringList tab = id.split("/");
+        category = tab[0];
+        tab.removeFirst();
+        key = tab.join("/");
+    }
+
+    switch (value.userType())
+    {
+    case QMetaType::Int:
+        ret = settings.set(key.toStdString(), value.value<int>(), category.toStdString());
+        break;
+
+    case QMetaType::QString:
+        ret = settings.set(key.toStdString(), value.toString().toStdString(), category.toStdString());
+        break;
+
+    case QMetaType::Bool:
+        ret = settings.set(key.toStdString(), value.value<bool>(), category.toStdString());
+        break;
+
+    case QMetaType::Double:
+        ret = settings.set(key.toStdString(), value.value<double>(), category.toStdString());
+        break;
+    default:
+        ret = false;
+        break;
+    }
+
+    if(!ret)
+    {
+        qWarning() << "Settings ERROR: Write access not permitted for" << id << " with " << QString::fromStdString(settings.id());
+        return false;
+    }
+    return true;
+}
+
+
+int KaZoe::KzQSettings::count() const
+{
+    if(m_settings) return m_settings->size();
+    qWarning() << "Invalid object state for count";
+    return -1;
+}
+
+QVariant KaZoe::KzQSettings::get(const QString &id, const QVariant defvalue) const
+{
+    if(!m_settings)
+    {
+        qWarning() << "Invalid object state for get";
+        return QVariant();
+    }
+
+    QString category;
+    QString key = id;
+    if(id.contains("/"))
+    {
+        qWarning() << "OLD Syntax used for " << id;
+        QStringList tab = id.split("/");
+        category = tab[0];
+        tab.removeFirst();
+        key = tab.join("/");
+    }
+
+    KzSettingValue value = m_settings->get(key.toStdString(), category.toStdString(), fromQVariant(defvalue));
+    return toQVariant(value);
+}
+
+bool KaZoe::KzQSettings::set(const QString &id, const QVariant &value)
+{
+    if(!m_settings)
+    {
+        qWarning() << "Invalid object state for set";
+        return false;
+    }
+    bool ret;
+    QString key = id;
+    QString category;
+
+    if(id.contains("/"))
+    {
+        qWarning() << "OLD Syntax used for " << id;
+        QStringList tab = id.split("/");
+        category = tab[0];
+        tab.removeFirst();
+        key = tab.join("/");
+    }
+
+    switch (value.userType())
+    {
+    case QMetaType::Int:
+        ret = m_settings->set(key.toStdString(), value.value<int>(), category.toStdString());
+        break;
+
+    case QMetaType::QString:
+        ret = m_settings->set(key.toStdString(), value.toString().toStdString(), category.toStdString());
+        break;
+
+    case QMetaType::Bool:
+        ret = m_settings->set(key.toStdString(), value.value<bool>(), category.toStdString());
+        break;
+
+    case QMetaType::Double:
+        ret = m_settings->set(key.toStdString(), value.value<double>(), category.toStdString());
+        break;
+    default:
+        ret = false;
+        break;
+    }
+
+    if(!ret)
+    {
+        qWarning() << "Settings ERROR: Write access not permitted for" << id << " with " << QString::fromStdString(m_settings->id());
+        return false;
+    }
+
+    emit valueChanged(toKeyCombined(category.toStdString(), key.toStdString()), value);
+    return true;
+}
+
+QStringList KaZoe::KzQSettings::keys() const
+{
+    if(!m_settings)
+    {
+        qWarning() << "Invalid object state for keys";
+        return QStringList();
+    }
+
+    QStringList keys;
+    m_settings->forEach([&keys](const KzSettingKey& key, const KzSettingValue& value) {
+        std::string combined;
+        if(!key.first.empty())
+        {
+            combined = "[" + key.first + "]";
+        }
+        combined.append(key.second);
+        keys.append(QString::fromStdString(combined));
+    });
+    return keys;
+}
diff --git a/qt/kzqsettings.h b/qt/kzqsettings.h
new file mode 100644
index 0000000..6ab48a0
--- /dev/null
+++ b/qt/kzqsettings.h
@@ -0,0 +1,34 @@
+#ifndef KZQSETTINGS_H
+#define KZQSETTINGS_H
+
+#include <QObject>
+#include <QVariant>
+
+namespace KaZoe {
+
+class KzSettings;
+
+class KzQSettings : public QObject
+{
+    Q_OBJECT
+    QScopedPointer<KaZoe::KzSettings> m_settings;
+
+public:
+    explicit KzQSettings(QObject *parent = nullptr);
+    virtual ~KzQSettings();
+
+    static QVariant getValue(const QString &id, QVariant defvalue = QVariant());
+    static bool setValue(const QString &id, const QVariant &value);
+
+public slots:
+    int count() const;
+    QVariant get(const QString &id, const QVariant defvalue = QVariant()) const;
+    bool set(const QString &id, const QVariant &value);
+    QStringList keys() const;
+
+signals:
+    void valueChanged(QString id, QVariant value);
+};
+};
+
+#endif // KZQSETTINGS_H
diff --git a/qt/kzqsettings_plugin.cpp b/qt/kzqsettings_plugin.cpp
new file mode 100644
index 0000000..170324e
--- /dev/null
+++ b/qt/kzqsettings_plugin.cpp
@@ -0,0 +1,12 @@
+#include "kzqsettings_plugin.h"
+#include "kzqsettings.h"
+#include "kzqproperty.h"
+
+#include <qqml.h>
+
+void KzSettingsPlugin::registerTypes(const char *uri)
+{
+    // @uri kazoe
+    qmlRegisterType<KaZoe::KzQSettings>(uri, 1, 0, "KzSettings");
+    qmlRegisterType<KaZoe::KzQProperty>(uri, 1, 0, "KzProperty");
+}
diff --git a/qt/kzqsettings_plugin.h b/qt/kzqsettings_plugin.h
new file mode 100644
index 0000000..dcaf808
--- /dev/null
+++ b/qt/kzqsettings_plugin.h
@@ -0,0 +1,15 @@
+#ifndef KZSETTINGS_PLUGIN_H
+#define KZSETTINGS_PLUGIN_H
+
+#include <QQmlExtensionPlugin>
+
+class KzSettingsPlugin : public QQmlExtensionPlugin
+{
+    Q_OBJECT
+    Q_PLUGIN_METADATA(IID QQmlExtensionInterface_iid)
+
+public:
+    void registerTypes(const char *uri) override;
+};
+
+#endif // SYSTEMSETTINGS_PLUGIN_H
diff --git a/qt/qml/qmldir b/qt/qml/qmldir
new file mode 100644
index 0000000..d15e7a3
--- /dev/null
+++ b/qt/qml/qmldir
@@ -0,0 +1,2 @@
+module org.kazoe.settings
+plugin KzQSettingsPlugin