Move settings keys to constants

autotest/display_test.cpp

@@ -1,6 +1,7 @@
 #include <libsnore/snore.h>
 #include <libsnore/snore_p.h>
 #include <libsnore/utils.h>
+#include <libsnore/snoreconstants.h>
 
 #include <QTextDocument>
 
@@ -17,7 +18,7 @@ class DisplayTest : public QObject
     {
         SnoreCore &instance = SnoreCore::instance();
         instance.loadPlugins(SnorePlugin::Backend);
-        instance.setSettingsValue(QStringLiteral("Timeout"), 10, LocalSetting);
+        instance.setSettingsValue(Snore::Constants::SettingsKeys::Timeout, 10);
         SnoreCore::instance().registerApplication(app);
     }
 
@@ -46,7 +47,7 @@ private Q_SLOTS:
             QString old = snore.primaryNotificationBackend();
             while (!backends.empty() && snore.primaryNotificationBackend() == old) {
                 QString p = backends.takeLast();
-                snore.setSettingsValue(QStringLiteral("PrimaryBackend"), p, LocalSetting);
+                snore.setSettingsValue(Snore::Constants::SettingsKeys::PrimaryBackend, p);
                 SnoreCorePrivate::instance()->syncSettings();
                 if (snore.primaryNotificationBackend() == p) {
                     for (const auto &message : messages) {

autotest/snorebenchmark.cpp

@@ -1,6 +1,7 @@
 #include <libsnore/snore.h>
 #include <libsnore/snore_p.h>
 #include <libsnore/utils.h>
+#include <libsnore/snoreconstants.h>
 
 #include <QTextDocument>
 
@@ -16,7 +17,7 @@ class SnoreBenchmark : public QObject
     {
         SnoreCore &instance = SnoreCore::instance();
         instance.loadPlugins(SnorePlugin::Backend);
-        instance.setSettingsValue(QStringLiteral("Timeout"), 1, LocalSetting);
+        instance.setSettingsValue(Snore::Constants::SettingsKeys::Timeout, 1);
     }
 
     // clazy is complaining about this string but QStringLiteral won't work for the multiline string, so use QStringBuilder to silence it.

src/libsnore/application_p.cpp

@@ -19,6 +19,7 @@
 #include "application_p.h"
 #include "lambdahint.h"
 #include "snore_p.h"
+#include "snoreconstants.h"
 
 #include <QGuiApplication>
 
@@ -36,7 +37,7 @@ ApplicationData::ApplicationData(const QString &key, const QString &name, const
     m_hint.setValue("pushover-token", QLatin1String("aFB1TPCyZkkr7mubCGEKy5vJEWak9t"));
     m_hint.setValue("use-markup", false);
     m_hint.setValue("silent", QVariant::fromValue(LambdaHint([]() {
-        return SnoreCore::instance().settingsValue(QStringLiteral("Silent"), LocalSetting);
+        return SnoreCore::instance().settingsValue(Snore::Constants::SettingsKeys::Silent);
     })));
 
 }

src/libsnore/notification/notification.cpp

@@ -18,6 +18,7 @@
 
 #include "notification.h"
 #include "snore.h"
+#include "snoreconstants.h"
 #include "notification/icon.h"
 #include "notification/notification_p.h"
 #include "plugins/plugincontainer.h"
@@ -181,7 +182,7 @@ NotificationData *Notification::data()
 
 int Notification::defaultTimeout()
 {
-    return SnoreCore::instance().settingsValue(QStringLiteral("Timeout"), LocalSetting).toInt();
+    return SnoreCore::instance().settingsValue(Snore::Constants::SettingsKeys::Timeout).toInt();
 }
 
 QDataStream &operator<< (QDataStream &stream, const Notification &noti)

src/libsnore/plugins/plugins.cpp

@@ -18,6 +18,7 @@
 
 #include "../snore.h"
 #include "../snore_p.h"
+#include "../snoreconstants.h"
 #include "snorebackend.h"
 #include "snorefrontend.h"
 #include "../notification/notification_p.h"
@@ -47,19 +48,19 @@ bool SnorePlugin::isEnabled() const
     return m_enabled;
 }
 
-QVariant SnorePlugin::settingsValue(const QString &key, SettingsType type) const
+QVariant SnorePlugin::settingsValue(const SettingsKey &key) const
 {
-    return SnoreCore::instance().settingsValue(normaliseKey(key), type);
+    return SnoreCore::instance().settingsValue(normaliseKey(key));
 }
 
-void SnorePlugin::setSettingsValue(const QString &key, const QVariant &value, SettingsType type)
+void SnorePlugin::setSettingsValue(const SettingsKey &key, const QVariant &value)
 {
-    SnoreCore::instance().setSettingsValue(normaliseKey(key), value, type);
+    SnoreCore::instance().setSettingsValue(normaliseKey(key), value);
 }
 
-void SnorePlugin::setDefaultSettingsValue(const QString &key, const QVariant &value, SettingsType type)
+void SnorePlugin::setDefaultSettingsValue(const SettingsKey &key, const QVariant &value)
 {
-    SnoreCore::instance().setDefaultSettingsValue(normaliseKey(key), value, type);
+    SnoreCore::instance().setDefaultSettingsValue(normaliseKey(key), value);
 }
 
 const Hint &SnorePlugin::constHints() const
@@ -72,9 +73,9 @@ Hint &SnorePlugin::hints()
     return m_hints;
 }
 
-QString SnorePlugin::normaliseKey(const QString &key) const
+SettingsKey SnorePlugin::normaliseKey(const SettingsKey &key) const
 {
-    return name() + QLatin1Char('-') + typeName() + QLatin1Char('/') + key + QLatin1Char('.') + settingsVersion();
+    return SettingsKey{name() + QLatin1Char('-') + typeName() + QLatin1Char('/') + key.key + QLatin1Char('.') + settingsVersion(), key.type};
 }
 
 const QString &SnorePlugin::name() const
@@ -104,7 +105,7 @@ QString SnorePlugin::settingsVersion() const
 
 void SnorePlugin::setDefaultSettings()
 {
-    setDefaultSettingsValue(QStringLiteral("Enabled"), false, LocalSetting);
+    setDefaultSettingsValue(Constants::SettingsKeys::Enabled, false);
 }
 
 void SnorePlugin::setErrorString(const QString &_error)

src/libsnore/plugins/plugins.h

@@ -133,9 +133,9 @@ class SNORE_EXPORT SnorePlugin : public QObject
      */
     QString errorString() const;
 
-    QVariant settingsValue(const QString &key, SettingsType type = GlobalSetting) const;
-    void setSettingsValue(const QString &key, const QVariant &settingsValue, SettingsType type = GlobalSetting);
-    void setDefaultSettingsValue(const QString &key, const QVariant &settingsValue, SettingsType type = GlobalSetting);
+    QVariant settingsValue(const SettingsKey &key) const;
+    void setSettingsValue(const SettingsKey &key, const QVariant &settingsValue);
+    void setDefaultSettingsValue(const SettingsKey &key, const QVariant &settingsValue);
 
     const Hint &constHints() const;
 
@@ -158,7 +158,7 @@ class SNORE_EXPORT SnorePlugin : public QObject
 
     Hint &hints();
 private:
-    QString normaliseKey(const QString &key) const;
+    SettingsKey normaliseKey(const SettingsKey &key) const;
     void setDefaultSettingsPlugin();
 
     bool m_enabled = false;

src/libsnore/settings/pluginsettingswidget.cpp

@@ -17,6 +17,7 @@
 */
 #include "pluginsettingswidget.h"
 #include "libsnore/plugins/plugins.h"
+#include "libsnore/snoreconstants.h"
 #include "snore.h"
 
 #include <QCheckBox>
@@ -61,15 +62,15 @@ void PluginSettingsWidget::addRow(const QString &label, QWidget *widget, const Q
 void PluginSettingsWidget::loadSettings()
 {
     if (m_snorePlugin->type() != SnorePlugin::Backend) {
-        m_enabled->setChecked(m_snorePlugin->settingsValue(QStringLiteral("Enabled"), LocalSetting).toBool());
+        m_enabled->setChecked(m_snorePlugin->settingsValue(Constants::SettingsKeys::Enabled).toBool());
     }
     load();
 }
 
 void PluginSettingsWidget::saveSettings()
 {
     if (m_snorePlugin->type() != SnorePlugin::Backend) {
-        m_snorePlugin->setSettingsValue(QStringLiteral("Enabled"), m_enabled->isChecked(), LocalSetting);
+        m_snorePlugin->setSettingsValue(Constants::SettingsKeys::Enabled, m_enabled->isChecked());
     }
     save();
 }
@@ -79,15 +80,15 @@ bool PluginSettingsWidget::isDirty()
     return m_dirty;
 }
 
-QVariant PluginSettingsWidget::settingsValue(const QString &key, SettingsType type) const
+QVariant PluginSettingsWidget::settingsValue(const SettingsKey &key) const
 {
-    return m_snorePlugin->settingsValue(key, type);
+    return m_snorePlugin->settingsValue(key);
 }
 
-void PluginSettingsWidget::setSettingsValue(const QString &key, const QVariant &value, SettingsType type)
+void PluginSettingsWidget::setSettingsValue(const SettingsKey &key, const QVariant &value)
 {
     if (this->settingsValue(key) != value) {
-        m_snorePlugin->setSettingsValue(key, value, type);
+        m_snorePlugin->setSettingsValue(key, value);
         m_dirty = true;
     }
 }

src/libsnore/settings/pluginsettingswidget.h

@@ -46,8 +46,8 @@ class SNORE_SETTINGS_EXPORT PluginSettingsWidget : public QWidget
     bool isDirty();
 
 protected:
-    QVariant settingsValue(const QString &key, Snore::SettingsType type = Snore::GlobalSetting) const;
-    void setSettingsValue(const QString &key, const QVariant &settingsValue, Snore::SettingsType type = Snore::GlobalSetting);
+    QVariant settingsValue(const SettingsKey &key) const;
+    void setSettingsValue(const SettingsKey &key, const QVariant &settingsValue);
 
     virtual void load();
     virtual void save();

src/libsnore/settings/settingsdialog.cpp

@@ -20,6 +20,7 @@
 #include "ui_settingsdialog.h"
 #include "snore.h"
 #include "snore_p.h"
+#include "snoreconstants.h"
 #include "settings.h"
 
 #include <QTabWidget>
@@ -42,7 +43,7 @@ SettingsDialog::~SettingsDialog()
 
 void SettingsDialog::initTabs()
 {
-    SnorePlugin::PluginTypes types = SnoreCore::instance().settingsValue(QStringLiteral("PluginTypes"), LocalSetting).value<SnorePlugin::PluginTypes>();
+    SnorePlugin::PluginTypes types = SnoreCore::instance().settingsValue(Snore::Constants::SettingsKeys::PluginTypes).value<SnorePlugin::PluginTypes>();
     if (types == SnorePlugin::None) {
         types = SnorePlugin::All;
     }
@@ -90,17 +91,17 @@ void SettingsDialog::on_pushButton_clicked()
 void SettingsDialog::load()
 {
     qCDebug(SNORE) << "loading";
-    loadPrimaryBackendBox(SnoreCore::instance().settingsValue(QStringLiteral("PrimaryBackend"), LocalSetting).toString());
-    ui->timeoutSpinBox->setValue(SnoreCore::instance().settingsValue(QStringLiteral("Timeout"), LocalSetting).toInt());
-    ui->disableNotificationSoundCheckBox->setChecked(SnoreCore::instance().settingsValue(QStringLiteral("Silent"), LocalSetting).toBool());
+    loadPrimaryBackendBox(SnoreCore::instance().settingsValue(Snore::Constants::SettingsKeys::PrimaryBackend).toString());
+    ui->timeoutSpinBox->setValue(SnoreCore::instance().settingsValue(Snore::Constants::SettingsKeys::Timeout).toInt());
+    ui->disableNotificationSoundCheckBox->setChecked(SnoreCore::instance().settingsValue(Snore::Constants::SettingsKeys::Silent).toBool());
     foreach(auto widget, m_tabs) {
         widget->loadSettings();
     }
 }
 
 void SettingsDialog::loadPrimaryBackendBox(const QString &backend)
 {
-    if (SnoreCore::instance().settingsValue(QStringLiteral("PluginTypes"), LocalSetting).value<SnorePlugin::PluginTypes>() & SnorePlugin::Backend) {
+    if (SnoreCore::instance().settingsValue(Snore::Constants::SettingsKeys::PluginTypes).value<SnorePlugin::PluginTypes>() & SnorePlugin::Backend) {
         ui->primaryBackendComboBox->clear();
         QStringList list = SnoreCore::instance().pluginNames(SnorePlugin::Backend);
         ui->primaryBackendComboBox->addItems(list);
@@ -121,13 +122,13 @@ void SettingsDialog::save()
         w->saveSettings();
         dirty |= w->isDirty();
     }
-    dirty |= SnoreCore::instance().settingsValue(QStringLiteral("PrimaryBackend"), LocalSetting).toString() != ui->primaryBackendComboBox->currentText();
-    dirty |= SnoreCore::instance().settingsValue(QStringLiteral("Timeout"), LocalSetting).toInt() != ui->timeoutSpinBox->value();
-    dirty |= SnoreCore::instance().settingsValue(QStringLiteral("Silent"), LocalSetting).toBool() != ui->disableNotificationSoundCheckBox->isChecked();
+    dirty |= SnoreCore::instance().settingsValue(Snore::Constants::SettingsKeys::PrimaryBackend).toString() != ui->primaryBackendComboBox->currentText();
+    dirty |= SnoreCore::instance().settingsValue(Snore::Constants::SettingsKeys::Timeout).toInt() != ui->timeoutSpinBox->value();
+    dirty |= SnoreCore::instance().settingsValue(Snore::Constants::SettingsKeys::Silent).toBool() != ui->disableNotificationSoundCheckBox->isChecked();
 
-    SnoreCore::instance().setSettingsValue(QStringLiteral("PrimaryBackend"), ui->primaryBackendComboBox->currentText(), LocalSetting);
-    SnoreCore::instance().setSettingsValue(QStringLiteral("Timeout"), ui->timeoutSpinBox->value(), LocalSetting);
-    SnoreCore::instance().setSettingsValue(QStringLiteral("Silent"), ui->disableNotificationSoundCheckBox->isChecked(), LocalSetting);
+    SnoreCore::instance().setSettingsValue(Snore::Constants::SettingsKeys::PrimaryBackend, ui->primaryBackendComboBox->currentText());
+    SnoreCore::instance().setSettingsValue(Snore::Constants::SettingsKeys::Timeout, ui->timeoutSpinBox->value());
+    SnoreCore::instance().setSettingsValue(Snore::Constants::SettingsKeys::Silent, ui->disableNotificationSoundCheckBox->isChecked());
 
     if (dirty) {
         SnoreCorePrivate::instance()->syncSettings();

src/libsnore/snore.cpp

@@ -18,6 +18,7 @@
 
 #include "snore.h"
 #include "snore_p.h"
+#include "snoreconstants.h"
 #include "lambdahint.h"
 #include "notification/notification.h"
 #include "notification/notification_p.h"
@@ -74,7 +75,7 @@ void SnoreCore::loadPlugins(SnorePlugin::PluginTypes types)
         return;
     }
     Q_D(SnoreCore);
-    setSettingsValue(QStringLiteral("PluginTypes"), QVariant::fromValue(types), LocalSetting);
+    setSettingsValue(Constants::SettingsKeys::PluginTypes, QVariant::fromValue(types));
     qCDebug(SNORE) << "Loading plugin types:" << types;
     foreach(const SnorePlugin::PluginTypes type, SnorePlugin::types()) {
         if (type != SnorePlugin::All && types & type) {
@@ -91,7 +92,7 @@ void SnoreCore::loadPlugins(SnorePlugin::PluginTypes types)
                 case SnorePlugin::Frontend:
                 case SnorePlugin::Plugin:
                 case SnorePlugin::Settings:
-                    plugin->setEnabled(plugin->settingsValue(QStringLiteral("Enabled"), LocalSetting).toBool());
+                    plugin->setEnabled(plugin->settingsValue(Constants::SettingsKeys::Enabled).toBool());
                     break;
                 default:
                     qCWarning(SNORE) << "Plugin Cache corrupted\n" << info->file() << info->type();
@@ -209,26 +210,26 @@ void SnoreCore::setDefaultApplication(const Application app)
     d->m_defaultApp = app;
 }
 
-QVariant SnoreCore::settingsValue(const QString &key, SettingsType type) const
+QVariant SnoreCore::settingsValue(const SettingsKey &key) const
 {
     Q_D(const SnoreCore);
-    QString nk = d->normalizeSettingsKey(key, type);
-    if (type == LocalSetting && !d->m_settings->contains(nk)) {
-        nk = d->normalizeSettingsKey(key + QStringLiteral("-SnoreDefault"), type);
+    QString nk = d->normalizeSettingsKey(key.key, key.type);
+    if (key.type == LocalSetting && !d->m_settings->contains(nk)) {
+        nk = d->normalizeSettingsKey(key.key + QStringLiteral("-SnoreDefault"), key.type);
     }
     return d->m_settings->value(nk);
 }
 
-void SnoreCore::setSettingsValue(const QString &key, const QVariant &value, SettingsType type)
+void SnoreCore::setSettingsValue(const SettingsKey &key, const QVariant &value)
 {
     Q_D(SnoreCore);
-    d->m_settings->setValue(d->normalizeSettingsKey(key, type), value);
+    d->m_settings->setValue(d->normalizeSettingsKey(key.key, key.type), value);
 }
 
-void SnoreCore::setDefaultSettingsValue(const QString &key, const QVariant &value, SettingsType type)
+void SnoreCore::setDefaultSettingsValue(const SettingsKey &key, const QVariant &value)
 {
     Q_D(SnoreCore);
-    QString nk = d->normalizeSettingsKey(key, type);
+    QString nk = d->normalizeSettingsKey(key.key, key.type);
     if (!d->m_settings->contains(nk)) {
         qCDebug(SNORE) <<  "Set default value" << nk << value;
         d->m_settings->setValue(nk, value);

src/libsnore/snore.h

@@ -138,9 +138,9 @@ class SNORE_EXPORT SnoreCore : public QObject
      */
     void setDefaultApplication(Application app);
 
-    QVariant settingsValue(const QString &key, SettingsType type = GlobalSetting) const;
-    void setSettingsValue(const QString &key, const QVariant &settingsValue, SettingsType type = GlobalSetting);
-    void setDefaultSettingsValue(const QString &key, const QVariant &settingsValue, SettingsType type = GlobalSetting);
+    QVariant settingsValue(const SettingsKey &key) const;
+    void setSettingsValue(const SettingsKey &key, const QVariant &value);
+    void setDefaultSettingsValue(const SettingsKey &key, const QVariant &settingsValue);
 
     Notification getActiveNotificationByID(uint id) const;
 

src/libsnore/snore_p.cpp

@@ -18,6 +18,7 @@
 
 #include "snore_p.h"
 #include "snore.h"
+#include "snoreconstants.h"
 #include "plugins/plugins.h"
 #include "plugins/snorebackend.h"
 #include "plugins/snorefrontend.h"
@@ -107,7 +108,7 @@ bool SnoreCorePrivate::setBackendIfAvailible(const QString &backend)
         }
         m_notificationBackend = b;
         m_notificationBackend->enable();
-        q->setSettingsValue(QStringLiteral("PrimaryBackend"), backend, LocalSetting);
+        q->setSettingsValue(Constants::SettingsKeys::PrimaryBackend, backend);
 
         connect(b, &SnoreBackend::error, [this, b](const QString &) {
             slotInitPrimaryNotificationBackend();
@@ -121,8 +122,8 @@ bool SnoreCorePrivate::setBackendIfAvailible(const QString &backend)
 bool SnoreCorePrivate::slotInitPrimaryNotificationBackend()
 {
     Q_Q(SnoreCore);
-    qCDebug(SNORE) << q->settingsValue(QStringLiteral("PrimaryBackend"), LocalSetting).toString();
-    if (setBackendIfAvailible(q->settingsValue(QStringLiteral("PrimaryBackend"), LocalSetting).toString())) {
+    qCDebug(SNORE) << q->settingsValue(Constants::SettingsKeys::PrimaryBackend).toString();
+    if (setBackendIfAvailible(q->settingsValue(Constants::SettingsKeys::PrimaryBackend).toString())) {
         return true;
     }
 #ifdef Q_OS_WIN
@@ -171,7 +172,7 @@ void SnoreCorePrivate::setDefaultSettingsValueIntern(const QString &key, const Q
 void SnoreCorePrivate::syncSettings()
 {
     Q_Q(SnoreCore);
-    QString newBackend = q->settingsValue(QStringLiteral("PrimaryBackend"), LocalSetting).toString();
+    QString newBackend = q->settingsValue(Constants::SettingsKeys::PrimaryBackend).toString();
     if (!newBackend.isEmpty()) {
         QString oldBackend;
         if (m_notificationBackend) {
@@ -180,7 +181,7 @@ void SnoreCorePrivate::syncSettings()
             m_notificationBackend = nullptr;
         }
         if (!setBackendIfAvailible(newBackend)) {
-            qCWarning(SNORE) << "Failed to set new backend" << q->settingsValue(QStringLiteral("PrimaryBackend"), LocalSetting).toString() << "restoring" << oldBackend;
+            qCWarning(SNORE) << "Failed to set new backend" << q->settingsValue(Constants::SettingsKeys::PrimaryBackend).toString() << "restoring" << oldBackend;
             setBackendIfAvailible(oldBackend);
         }
     }
@@ -191,7 +192,7 @@ void SnoreCorePrivate::syncSettings()
         foreach(auto & pluginName, m_pluginNames[type]) {
             auto key = qMakePair(type, pluginName);
             SnorePlugin *plugin = m_plugins.value(key);
-            bool enable = m_plugins[key]->settingsValue(QStringLiteral("Enabled"), LocalSetting).toBool();
+            bool enable = m_plugins[key]->settingsValue(Constants::SettingsKeys::Enabled).toBool();
             plugin->setEnabled(enable);
         }
     }