QmlDesigner: improve settings for easy adding new values

- move settings keys constants to the settings file
 - transform settings to a QHash

Change-Id: I1d41476421ce569cea3a4bd1c956d3bc0c6643f4
Reviewed-by: Thomas Hartmann <Thomas.Hartmann@theqtcompany.com>

src/plugins/qmldesigner/components/componentcore/crumblebar.cpp

@@ -139,7 +139,7 @@ void CrumbleBar::showSaveDialog()
 {
     DesignerSettings settings = QmlDesignerPlugin::instance()->settings();
 
-    if (settings.alwaysSaveInCrumbleBar) {
+    if (settings.value(DesignerSettingsKey::ALWAYS_SAFE_IN_CRUMBLEBAR).toBool()) {
         Core::DocumentManager::saveModifiedDocumentSilently(currentDesignDocument()->editor()->document());
     } else {
         bool alwaysSave;
@@ -151,7 +151,7 @@ void CrumbleBar::showSaveDialog()
                                                     tr("Always save when leaving subcomponent"),
                                                     &alwaysSave);
 
-        settings.alwaysSaveInCrumbleBar = alwaysSave;
+        settings.insert(DesignerSettingsKey::ALWAYS_SAFE_IN_CRUMBLEBAR, alwaysSave);
         QmlDesignerPlugin::instance()->setSettings(settings);
     }
 }

src/plugins/qmldesigner/components/debugview/debugview.cpp

@@ -40,12 +40,14 @@ const QString lineBreak = QStringLiteral("<br>");
 
 bool isDebugViewEnabled()
 {
-    return (QmlDesigner::QmlDesignerPlugin::instance()->settings().enableDebugView);
+    return QmlDesigner::QmlDesignerPlugin::instance()->settings().value(
+        QmlDesigner::DesignerSettingsKey::ENABLE_DEBUGVIEW).toBool();
 }
 
 bool isDebugViewShown()
 {
-    return (QmlDesigner::QmlDesignerPlugin::instance()->settings().showDebugView);
+    return QmlDesigner::QmlDesignerPlugin::instance()->settings().value(
+        QmlDesigner::DesignerSettingsKey::SHOW_DEBUGVIEW).toBool();
 }
 
 }

src/plugins/qmldesigner/components/debugview/debugviewwidget.cpp

@@ -89,7 +89,7 @@ void DebugViewWidget::setDebugViewEnabled(bool b)
 void DebugViewWidget::enabledCheckBoxToggled(bool b)
 {
     DesignerSettings settings = QmlDesignerPlugin::instance()->settings();
-    settings.warningsInDesigner = b;
+    settings.insert(DesignerSettingsKey::WARNING_FOR_FEATURES_IN_DESIGNER, b);
     QmlDesignerPlugin::instance()->setSettings(settings);
 }
 

src/plugins/qmldesigner/components/formeditor/formeditorscene.cpp

@@ -92,13 +92,13 @@ FormEditorItem* FormEditorScene::itemForQmlItemNode(const QmlItemNode &qmlItemNo
 double FormEditorScene::canvasWidth() const
 {
     DesignerSettings settings = QmlDesignerPlugin::instance()->settings();
-    return settings.canvasWidth;
+    return settings.value(DesignerSettingsKey::CANVASWIDTH).toDouble();
 }
 
 double FormEditorScene::canvasHeight() const
 {
     DesignerSettings settings = QmlDesignerPlugin::instance()->settings();
-    return settings.canvasHeight;
+    return settings.value(DesignerSettingsKey::CANVASHEIGHT).toDouble();
 }
 
 QList<FormEditorItem*> FormEditorScene::itemsForQmlItemNodes(const QList<QmlItemNode> &nodeList) const

src/plugins/qmldesigner/components/formeditor/formeditorwidget.cpp

@@ -282,13 +282,13 @@ ToolBox *FormEditorWidget::toolBox() const
 double FormEditorWidget::spacing() const
 {
     DesignerSettings settings = QmlDesignerPlugin::instance()->settings();
-    return settings.itemSpacing;
+    return settings.value(DesignerSettingsKey::ITEMSPACING).toDouble();
 }
 
 double FormEditorWidget::containerPadding() const
 {
     DesignerSettings settings = QmlDesignerPlugin::instance()->settings();
-    return settings.containerPadding;
+    return settings.value(DesignerSettingsKey::CONTAINERPADDING).toDouble();
 }
 
 

src/plugins/qmldesigner/components/propertyeditor/propertyeditorcontextobject.cpp

@@ -105,7 +105,8 @@ QColor PropertyEditorContextObject::colorFromString(const QString &colorString)
 
 QString PropertyEditorContextObject::translateFunction()
 {
-    if (QmlDesignerPlugin::instance()->settings().useQsTrFunction)
+    if (QmlDesignerPlugin::instance()->settings().value(
+            DesignerSettingsKey::USE_QSTR_FUNCTION).toBool())
         return QStringLiteral("qsTr");
     return QStringLiteral("qsTrId");
 }

src/plugins/qmldesigner/designercore/filemanager/qmlwarningdialog.cpp

@@ -75,13 +75,13 @@ void QmlWarningDialog::okButtonPressed()
 bool QmlWarningDialog::warningsEnabled() const
 {
     DesignerSettings settings = QmlDesignerPlugin::instance()->settings();
-    return settings.warningsInDesigner;
+    return settings.value(DesignerSettingsKey::WARNING_FOR_FEATURES_IN_DESIGNER).toBool();
 }
 
 void QmlWarningDialog::checkBoxToggled(bool b)
 {
     DesignerSettings settings = QmlDesignerPlugin::instance()->settings();
-    settings.warningsInDesigner = b;
+    settings.insert(DesignerSettingsKey::WARNING_FOR_FEATURES_IN_DESIGNER, b);
     QmlDesignerPlugin::instance()->setSettings(settings);
 }
 

src/plugins/qmldesigner/designercore/instances/puppetcreator.cpp

@@ -103,9 +103,8 @@ QDateTime PuppetCreator::puppetSourceLastModified() const
 
 bool PuppetCreator::useOnlyFallbackPuppet() const
 {
-    DesignerSettings settings = QmlDesignerPlugin::instance()->settings();
+    return m_designerSettings.value(DesignerSettingsKey::USE_ONLY_FALLBACK_PUPPET
-    return settings.useOnlyFallbackPuppet
+        ).toBool() || m_kit == 0 || !m_kit->isValid();
-            || !qgetenv("USE_ONLY_FALLBACK_PUPPET").isEmpty() || m_kit == 0 || !m_kit->isValid();
 }
 
 PuppetCreator::PuppetCreator(ProjectExplorer::Kit *kit, const QString &qtCreatorVersion, const Model *model)
@@ -277,9 +276,11 @@ QString PuppetCreator::defaultPuppetToplevelBuildDirectory()
 
 QString PuppetCreator::qmlPuppetToplevelBuildDirectory() const
 {
-    if (m_designerSettings.puppetToplevelBuildDirectory.isEmpty())
+    QString puppetToplevelBuildDirectory = m_designerSettings.value(
+        DesignerSettingsKey::PUPPET_TOPLEVEL_BUILD_DIRECTORY).toString();
+    if (puppetToplevelBuildDirectory.isEmpty())
         return defaultPuppetToplevelBuildDirectory();
-    return QmlDesignerPlugin::instance()->settings().puppetToplevelBuildDirectory;
+    return puppetToplevelBuildDirectory;
 }
 
 QString PuppetCreator::qmlPuppetDirectory(PuppetType puppetType) const
@@ -301,9 +302,11 @@ QString PuppetCreator::defaultPuppetFallbackDirectory()
 
 QString PuppetCreator::qmlPuppetFallbackDirectory() const
 {
-    if (m_designerSettings.puppetFallbackDirectory.isEmpty())
+    QString puppetFallbackDirectory = m_designerSettings.value(
+        DesignerSettingsKey::PUPPET_FALLBACK_DIRECTORY).toString();
+    if (puppetFallbackDirectory.isEmpty())
         return defaultPuppetFallbackDirectory();
-    return QmlDesignerPlugin::instance()->settings().puppetFallbackDirectory;
+    return puppetFallbackDirectory;
 }
 
 QString PuppetCreator::qml2PuppetPath(PuppetType puppetType) const
@@ -325,7 +328,8 @@ QProcessEnvironment PuppetCreator::processEnvironment() const
     environment.set(QLatin1String("QML_USE_MOCKUPS"), QLatin1String("true"));
     environment.set(QLatin1String("QML_PUPPET_MODE"), QLatin1String("true"));
 
-    const QString controlsStyle = QmlDesignerPlugin::instance()->settings().controlsStyle;
+    const QString controlsStyle = m_designerSettings.value(DesignerSettingsKey::
+            CONTROLS_STYLE).toString();
     if (!controlsStyle.isEmpty())
         environment.set(QLatin1String("QT_QUICK_CONTROLS_STYLE"), controlsStyle);
 

src/plugins/qmldesigner/designercore/model/qmlobjectnode.cpp

@@ -434,7 +434,8 @@ QVariant QmlObjectNode::instanceValue(const ModelNode &modelNode, const Property
 
 QString QmlObjectNode::generateTranslatableText(const QString &text)
 {
-    if (QmlDesignerPlugin::instance()->settings().useQsTrFunction)
+    if (QmlDesignerPlugin::instance()->settings().value(
+            DesignerSettingsKey::USE_QSTR_FUNCTION).toBool())
         return QString(QStringLiteral("qsTr(\"%1\")")).arg(text);
     else
         return QString(QStringLiteral("qsTrId(\"%1\")")).arg(text);

src/plugins/qmldesigner/designercore/model/viewmanager.cpp

@@ -190,7 +190,8 @@ void ViewManager::detachComponentView()
 
 void ViewManager::attachViewsExceptRewriterAndComponetView()
 {
-    if (QmlDesignerPlugin::instance()->settings().enableDebugView)
+    if (QmlDesignerPlugin::instance()->settings().value(
+            DesignerSettingsKey::ENABLE_DEBUGVIEW).toBool())
         currentModel()->attachView(&d->debugView);
 
     attachNodeInstanceView();

src/plugins/qmldesigner/designersettings.cpp

@@ -24,97 +24,69 @@
 ****************************************************************************/
 
 #include "designersettings.h"
-#include "qmldesignerconstants.h"
 
 #include <QSettings>
 
-using namespace QmlDesigner;
+namespace QmlDesigner {
+
+namespace DesignerSettingsGroupKey {
+    const char QML_SETTINGS_GROUP[] = "QML";
+    const char QML_DESIGNER_SETTINGS_GROUP[] = "Designer";
+}
 
 DesignerSettings::DesignerSettings()
-    : itemSpacing(0),
+{
-    containerPadding(0),
+}
-    canvasWidth(10000),
+
-    canvasHeight(10000),
+void DesignerSettings::restoreValue(QSettings *settings, const QByteArray &key, const QVariant &defaultValue)
-    warningsInDesigner(true),
+{
-    designerWarningsInEditor(false),
+    insert(key, settings->value(QString::fromLatin1(key), defaultValue));
-    showDebugView(false),
+}
-    enableDebugView(false),
-    alwaysSaveInCrumbleBar(false),
-    useOnlyFallbackPuppet(true)
-{}
 
 void DesignerSettings::fromSettings(QSettings *settings)
 {
-    settings->beginGroup(QLatin1String(QmlDesigner::Constants::QML_SETTINGS_GROUP));
+    settings->beginGroup(QLatin1String(DesignerSettingsGroupKey::QML_SETTINGS_GROUP));
-    settings->beginGroup(QLatin1String(QmlDesigner::Constants::QML_DESIGNER_SETTINGS_GROUP));
+    settings->beginGroup(QLatin1String(DesignerSettingsGroupKey::QML_DESIGNER_SETTINGS_GROUP));
-    itemSpacing = settings->value(
-            QLatin1String(QmlDesigner::Constants::QML_ITEMSPACING_KEY), QVariant(6)).toInt();
-    containerPadding = settings->value(
-            QLatin1String(QmlDesigner::Constants::QML_CONTAINERPADDING_KEY), QVariant(8)).toInt();
-    canvasWidth = settings->value(QLatin1String(QmlDesigner::Constants::QML_CANVASWIDTH_KEY), QVariant(10000)).toInt();
-    canvasHeight = settings->value(QLatin1String(QmlDesigner::Constants::QML_CANVASHEIGHT_KEY), QVariant(10000)).toInt();
-    warningsInDesigner = settings->value(
-            QLatin1String(QmlDesigner::Constants::QML_WARNIN_FOR_FEATURES_IN_DESIGNER_KEY), QVariant(true)).toBool();
-    designerWarningsInEditor = settings->value(
-            QLatin1String(QmlDesigner::Constants::QML_WARNIN_FOR_DESIGNER_FEATURES_IN_EDITOR_KEY), QVariant(false)).toBool();
-    showDebugView = settings->value(
-            QLatin1String(QmlDesigner::Constants::QML_SHOW_DEBUGVIEW), QVariant(false)).toBool();
-    enableDebugView = settings->value(
-            QLatin1String(QmlDesigner::Constants::QML_ENABLE_DEBUGVIEW), QVariant(false)).toBool();
-    alwaysSaveInCrumbleBar = settings->value(
-                QLatin1String(QmlDesigner::Constants::QML_ALWAYS_SAFE_IN_CRUMBLEBAR), QVariant(false)).toBool();
-    useOnlyFallbackPuppet = settings->value(
-                QLatin1String(QmlDesigner::Constants::QML_USE_ONLY_FALLBACK_PUPPET), QVariant(true)).toBool();
-    useQsTrFunction = settings->value(
-                QLatin1String(QmlDesigner::Constants::QML_USE_QSTR_FUNCTION), QVariant(true)).toBool();
-    puppetFallbackDirectory = settings->value(
-                QLatin1String(QmlDesigner::Constants::QML_PUPPET_FALLBACK_DIRECTORY)).toString();
-    puppetToplevelBuildDirectory = settings->value(
-                QLatin1String(QmlDesigner::Constants::QML_PUPPET_TOPLEVEL_BUILD_DIRECTORY)).toString();
-    controlsStyle = settings->value(
-                QLatin1String(QmlDesigner::Constants::QML_CONTROLS_STYLE)).toString();
 
+    restoreValue(settings, DesignerSettingsKey::ITEMSPACING, 6);
+    restoreValue(settings, DesignerSettingsKey::CONTAINERPADDING, 8);
+    restoreValue(settings, DesignerSettingsKey::CANVASWIDTH, 10000);
+    restoreValue(settings, DesignerSettingsKey::CANVASHEIGHT, 10000);
+    restoreValue(settings, DesignerSettingsKey::WARNING_FOR_FEATURES_IN_DESIGNER, true);
+    restoreValue(settings, DesignerSettingsKey::WARNING_FOR_DESIGNER_FEATURES_IN_EDITOR, false);
+    restoreValue(settings, DesignerSettingsKey::SHOW_DEBUGVIEW, false);
+    restoreValue(settings, DesignerSettingsKey::ENABLE_DEBUGVIEW, false);
+    restoreValue(settings, DesignerSettingsKey::ALWAYS_SAFE_IN_CRUMBLEBAR, false);
+    restoreValue(settings, DesignerSettingsKey::USE_ONLY_FALLBACK_PUPPET, true);
+    restoreValue(settings, DesignerSettingsKey::USE_QSTR_FUNCTION, true);
+    restoreValue(settings, DesignerSettingsKey::PUPPET_FALLBACK_DIRECTORY);
+    restoreValue(settings, DesignerSettingsKey::PUPPET_TOPLEVEL_BUILD_DIRECTORY);
+    restoreValue(settings, DesignerSettingsKey::CONTROLS_STYLE);
 
     settings->endGroup();
     settings->endGroup();
 }
 
+void DesignerSettings::storeValue(QSettings *settings, const QByteArray &key, const QVariant &value) const
+{
+    if (key.isEmpty())
+        return;
+    settings->setValue(QString::fromLatin1(key), value);
+}
+
 void DesignerSettings::toSettings(QSettings *settings) const
 {
-    settings->beginGroup(QLatin1String(QmlDesigner::Constants::QML_SETTINGS_GROUP));
+    settings->beginGroup(QLatin1String(DesignerSettingsGroupKey::QML_SETTINGS_GROUP));
-    settings->beginGroup(QLatin1String(QmlDesigner::Constants::QML_DESIGNER_SETTINGS_GROUP));
+    settings->beginGroup(QLatin1String(DesignerSettingsGroupKey::QML_DESIGNER_SETTINGS_GROUP));
-    settings->setValue(QLatin1String(QmlDesigner::Constants::QML_ITEMSPACING_KEY), itemSpacing);
+
-    settings->setValue(QLatin1String(QmlDesigner::Constants::QML_CONTAINERPADDING_KEY), containerPadding);
+    QHash<QByteArray, QVariant>::const_iterator i = constBegin();
-    settings->setValue(QLatin1String(QmlDesigner::Constants::QML_CANVASWIDTH_KEY), canvasWidth);
+    while (i != constEnd()) {
-    settings->setValue(QLatin1String(QmlDesigner::Constants::QML_CANVASHEIGHT_KEY), canvasHeight);
+        storeValue(settings, i.key(), i.value());
-    settings->setValue(QLatin1String(QmlDesigner::Constants::QML_WARNIN_FOR_FEATURES_IN_DESIGNER_KEY), warningsInDesigner);
+        ++i;
-    settings->setValue(QLatin1String(QmlDesigner::Constants::QML_WARNIN_FOR_DESIGNER_FEATURES_IN_EDITOR_KEY), designerWarningsInEditor);
+    }
-    settings->setValue(QLatin1String(QmlDesigner::Constants::QML_SHOW_DEBUGVIEW), showDebugView);
-    settings->setValue(QLatin1String(QmlDesigner::Constants::QML_ENABLE_DEBUGVIEW), enableDebugView);
-    settings->setValue(QLatin1String(QmlDesigner::Constants::QML_ALWAYS_SAFE_IN_CRUMBLEBAR), alwaysSaveInCrumbleBar);
-    settings->setValue(QLatin1String(QmlDesigner::Constants::QML_USE_ONLY_FALLBACK_PUPPET), useOnlyFallbackPuppet);
-    settings->setValue(QLatin1String(QmlDesigner::Constants::QML_USE_QSTR_FUNCTION), useQsTrFunction);
-    settings->setValue(QLatin1String(QmlDesigner::Constants::QML_PUPPET_FALLBACK_DIRECTORY), puppetFallbackDirectory);
-    settings->setValue(QLatin1String(QmlDesigner::Constants::QML_PUPPET_TOPLEVEL_BUILD_DIRECTORY), puppetToplevelBuildDirectory);
-    settings->setValue(QLatin1String(QmlDesigner::Constants::QML_CONTROLS_STYLE), controlsStyle);
 
     settings->endGroup();
     settings->endGroup();
 }
 
-bool DesignerSettings::equals(const DesignerSettings &other) const
+} // namespace QmlDesigner
-{
-    return containerPadding == other.containerPadding
-            && canvasWidth == other.canvasWidth
-            && canvasHeight == other.canvasHeight
-            && warningsInDesigner == other.warningsInDesigner
-            && designerWarningsInEditor == other.designerWarningsInEditor
-            && showDebugView == other.showDebugView
-            && enableDebugView == other.enableDebugView
-            && alwaysSaveInCrumbleBar == other.alwaysSaveInCrumbleBar
-            && useOnlyFallbackPuppet == other.useOnlyFallbackPuppet
-            && useQsTrFunction == other.useQsTrFunction
-            && puppetFallbackDirectory == other.puppetFallbackDirectory
-            && puppetToplevelBuildDirectory == other.puppetToplevelBuildDirectory
-            && controlsStyle == other.controlsStyle;
-}

src/plugins/qmldesigner/designersettings.h

@@ -27,7 +27,9 @@
 #define DESIGNERSETTINGS_H
 
 #include <QtGlobal>
-#include <QString>
+#include <QHash>
+#include <QVariant>
+#include <QByteArray>
 
 QT_BEGIN_NAMESPACE
 class QSettings;
@@ -35,35 +37,36 @@ QT_END_NAMESPACE
 
 namespace QmlDesigner {
 
-class DesignerSettings {
+namespace DesignerSettingsKey {
+const char ITEMSPACING[] = "ItemSpacing";
+const char CONTAINERPADDING[] = "ContainerPadding";
+const char CANVASWIDTH[] = "CanvasWidth";
+const char CANVASHEIGHT[] = "CanvasHeight";
+const char WARNING_FOR_FEATURES_IN_DESIGNER[] = "WarnAboutQtQuickFeaturesInDesigner";
+const char WARNING_FOR_DESIGNER_FEATURES_IN_EDITOR[] = "WarnAboutQtQuickDesignerFeaturesInCodeEditor";
+const char SHOW_DEBUGVIEW[] = "ShowQtQuickDesignerDebugView";
+const char ENABLE_DEBUGVIEW[] = "EnableQtQuickDesignerDebugView";
+const char ALWAYS_SAFE_IN_CRUMBLEBAR[] = "AlwaysSafeInCrumbleBar";
+const char USE_ONLY_FALLBACK_PUPPET[] = "UseOnlyFallbackPuppet";
+const char PUPPET_TOPLEVEL_BUILD_DIRECTORY[] = "PuppetToplevelBuildDirectory";
+const char PUPPET_FALLBACK_DIRECTORY[] = "PuppetFallbackDirectory";
+const char CONTROLS_STYLE[] = "ControlsStyle";
+const char USE_QSTR_FUNCTION[] = "UseQsTrFunction";
+}
+
+class DesignerSettings : public QHash<QByteArray, QVariant>
+{
 public:
     DesignerSettings();
 
     void fromSettings(QSettings *);
     void toSettings(QSettings *) const;
-
+private:
-    bool equals(const DesignerSettings &other) const;
+    void restoreValue(QSettings *settings, const QByteArray &key,
-    int itemSpacing;
+        const QVariant &defaultValue = QVariant());
-    int containerPadding;
+    void storeValue(QSettings *settings, const QByteArray &key, const QVariant &value) const;
-    int canvasWidth;
-    int canvasHeight;
-    bool warningsInDesigner;
-    bool designerWarningsInEditor;
-    bool showDebugView;
-    bool enableDebugView;
-    bool alwaysSaveInCrumbleBar;
-    bool useOnlyFallbackPuppet;
-    bool useQsTrFunction;
-    QString puppetFallbackDirectory;
-    QString puppetToplevelBuildDirectory;
-    QString controlsStyle;
 };
 
-inline bool operator==(const DesignerSettings &s1, const DesignerSettings &s2)
-{ return s1.equals(s2); }
-inline bool operator!=(const DesignerSettings &s1, const DesignerSettings &s2)
-{ return !s1.equals(s2); }
-
 } // namespace QmlDesigner
 
 #endif // DESIGNERSETTINGS_H

src/plugins/qmldesigner/qmldesignerconstants.h

@@ -47,24 +47,6 @@ const char TOGGLE_LEFT_SIDEBAR[] = "QmlDesigner.ToggleLeftSideBar";
 const char TOGGLE_RIGHT_SIDEBAR[] = "QmlDesigner.ToggleRightSideBar";
 const char GO_INTO_COMPONENT[] = "QmlDesigner.GoIntoComponent";
 
-// This setting is also accessed by the QMlJsEditor.
-const char QML_SETTINGS_GROUP[] = "QML";
-const char QML_DESIGNER_SETTINGS_GROUP[] = "Designer";
-const char QML_ITEMSPACING_KEY[] = "ItemSpacing";
-const char QML_CONTAINERPADDING_KEY[] = "ContainerPadding";
-const char QML_CANVASWIDTH_KEY[] = "CanvasWidth";
-const char QML_CANVASHEIGHT_KEY[] = "CanvasHeight";
-const char QML_WARNIN_FOR_FEATURES_IN_DESIGNER_KEY[] = "WarnAboutQtQuickFeaturesInDesigner";
-const char QML_WARNIN_FOR_DESIGNER_FEATURES_IN_EDITOR_KEY[] = "WarnAboutQtQuickDesignerFeaturesInCodeEditor";
-const char QML_SHOW_DEBUGVIEW[] = "ShowQtQuickDesignerDebugView";
-const char QML_ENABLE_DEBUGVIEW[] = "EnableQtQuickDesignerDebugView";
-const char QML_ALWAYS_SAFE_IN_CRUMBLEBAR[] = "AlwaysSafeInCrumbleBar";
-const char QML_USE_ONLY_FALLBACK_PUPPET[] = "UseOnlyFallbackPuppet";
-const char QML_PUPPET_TOPLEVEL_BUILD_DIRECTORY[] = "PuppetToplevelBuildDirectory";
-const char QML_PUPPET_FALLBACK_DIRECTORY[] = "PuppetFallbackDirectory";
-const char QML_CONTROLS_STYLE[] = "ControlsStyle";
-const char QML_USE_QSTR_FUNCTION[] = "UseQsTrFunction";
-
 const char QML_DESIGNER_SUBFOLDER[] = "/designer/";
 
 namespace Internal {

src/plugins/qmldesigner/settingspage.cpp

@@ -57,57 +57,82 @@ SettingsPageWidget::SettingsPageWidget(QWidget *parent) :
 
 DesignerSettings SettingsPageWidget::settings() const
 {
-    DesignerSettings designerSettings;
+    DesignerSettings settings = QmlDesignerPlugin::instance()->settings();
-    designerSettings.itemSpacing = m_ui.spinItemSpacing->value();
+    settings.insert(DesignerSettingsKey::ITEMSPACING, m_ui.spinItemSpacing->value());
-    designerSettings.containerPadding = m_ui.spinSnapMargin->value();
+    settings.insert(DesignerSettingsKey::CONTAINERPADDING, m_ui.spinSnapMargin->value());
-    designerSettings.canvasWidth = m_ui.spinCanvasWidth->value();
+    settings.insert(DesignerSettingsKey::CANVASWIDTH, m_ui.spinCanvasWidth->value());
-    designerSettings.canvasHeight = m_ui.spinCanvasHeight->value();
+    settings.insert(DesignerSettingsKey::CANVASHEIGHT, m_ui.spinCanvasHeight->value());
-    designerSettings.warningsInDesigner = m_ui.designerWarningsCheckBox->isChecked();
+    settings.insert(DesignerSettingsKey::WARNING_FOR_FEATURES_IN_DESIGNER,
-    designerSettings.designerWarningsInEditor = m_ui.designerWarningsInEditorCheckBox->isChecked();
+        m_ui.designerWarningsCheckBox->isChecked());
-    designerSettings.showDebugView = m_ui.designerShowDebuggerCheckBox->isChecked();
+    settings.insert(DesignerSettingsKey::WARNING_FOR_DESIGNER_FEATURES_IN_EDITOR,
-    designerSettings.enableDebugView = m_ui.designerEnableDebuggerCheckBox->isChecked();
+        m_ui.designerWarningsInEditorCheckBox->isChecked());
-    designerSettings.useOnlyFallbackPuppet = m_ui.useDefaultPuppetRadioButton->isChecked();
+    settings.insert(DesignerSettingsKey::SHOW_DEBUGVIEW,
-    designerSettings.useQsTrFunction = m_ui.useQsTrFunctionRadioButton->isChecked();
+        m_ui.designerShowDebuggerCheckBox->isChecked());
-    designerSettings.controlsStyle = m_ui.styleLineEdit->text();
+    settings.insert(DesignerSettingsKey::ENABLE_DEBUGVIEW,
+        m_ui.designerEnableDebuggerCheckBox->isChecked());
+    settings.insert(DesignerSettingsKey::USE_ONLY_FALLBACK_PUPPET,
+        m_ui.useDefaultPuppetRadioButton->isChecked());
+    settings.insert(DesignerSettingsKey::USE_QSTR_FUNCTION,
+        m_ui.useQsTrFunctionRadioButton->isChecked());
+    settings.insert(DesignerSettingsKey::CONTROLS_STYLE, m_ui.styleLineEdit->text());
 
     if (!m_ui.fallbackPuppetPathLineEdit->path().isEmpty() &&
         m_ui.fallbackPuppetPathLineEdit->path() != PuppetCreator::defaultPuppetFallbackDirectory()) {
-        designerSettings.puppetFallbackDirectory = m_ui.fallbackPuppetPathLineEdit->path();
+        settings.insert(DesignerSettingsKey::PUPPET_FALLBACK_DIRECTORY,
+            m_ui.fallbackPuppetPathLineEdit->path());
     }
 
     if (!m_ui.puppetBuildPathLineEdit->path().isEmpty() &&
         m_ui.puppetBuildPathLineEdit->path() != PuppetCreator::defaultPuppetToplevelBuildDirectory()) {
-        designerSettings.puppetToplevelBuildDirectory = m_ui.puppetBuildPathLineEdit->path();
+        settings.insert(DesignerSettingsKey::PUPPET_TOPLEVEL_BUILD_DIRECTORY,
+            m_ui.puppetBuildPathLineEdit->path());
     }
 
-    return designerSettings;
+    return settings;
 }
 
-void SettingsPageWidget::setSettings(const DesignerSettings &designerSettings)
+void SettingsPageWidget::setSettings(const DesignerSettings &settings)
 {
-    m_ui.spinItemSpacing->setValue(designerSettings.itemSpacing);
+    m_ui.spinItemSpacing->setValue(settings.value(
-    m_ui.spinSnapMargin->setValue(designerSettings.containerPadding);
+        DesignerSettingsKey::ITEMSPACING).toInt());
-    m_ui.spinCanvasWidth->setValue(designerSettings.canvasWidth);
+    m_ui.spinSnapMargin->setValue(settings.value(
-    m_ui.spinCanvasHeight->setValue(designerSettings.canvasHeight);
+        DesignerSettingsKey::CONTAINERPADDING).toInt());
-    m_ui.designerWarningsCheckBox->setChecked(designerSettings.warningsInDesigner);
+    m_ui.spinCanvasWidth->setValue(settings.value(
-    m_ui.designerWarningsInEditorCheckBox->setChecked(designerSettings.designerWarningsInEditor);
+        DesignerSettingsKey::CANVASWIDTH).toInt());
-    m_ui.designerShowDebuggerCheckBox->setChecked(designerSettings.showDebugView);
+    m_ui.spinCanvasHeight->setValue(settings.value(
-    m_ui.designerEnableDebuggerCheckBox->setChecked(designerSettings.enableDebugView);
+        DesignerSettingsKey::CANVASHEIGHT).toInt());
-    m_ui.useDefaultPuppetRadioButton->setChecked(designerSettings.useOnlyFallbackPuppet);
+    m_ui.designerWarningsCheckBox->setChecked(settings.value(
-    m_ui.useQtRelatedPuppetRadioButton->setChecked(!designerSettings.useOnlyFallbackPuppet);
+        DesignerSettingsKey::WARNING_FOR_FEATURES_IN_DESIGNER).toBool());
-    m_ui.useQsTrFunctionRadioButton->setChecked(designerSettings.useQsTrFunction);
+    m_ui.designerWarningsInEditorCheckBox->setChecked(settings.value(
-    m_ui.useQsTrIdFunctionRadioButton->setChecked(!designerSettings.useQsTrFunction);
+        DesignerSettingsKey::WARNING_FOR_DESIGNER_FEATURES_IN_EDITOR).toBool());
-    m_ui.styleLineEdit->setText(designerSettings.controlsStyle);
+    m_ui.designerShowDebuggerCheckBox->setChecked(settings.value(
+        DesignerSettingsKey::SHOW_DEBUGVIEW).toBool());
+    m_ui.designerEnableDebuggerCheckBox->setChecked(settings.value(
+        DesignerSettingsKey::ENABLE_DEBUGVIEW).toBool());
+    m_ui.useDefaultPuppetRadioButton->setChecked(settings.value(
+        DesignerSettingsKey::USE_ONLY_FALLBACK_PUPPET).toBool());
+    m_ui.useQtRelatedPuppetRadioButton->setChecked(!settings.value(
+        DesignerSettingsKey::USE_ONLY_FALLBACK_PUPPET).toBool());
+    m_ui.useQsTrFunctionRadioButton->setChecked(settings.value(
+        DesignerSettingsKey::USE_QSTR_FUNCTION).toBool());
+    m_ui.useQsTrIdFunctionRadioButton->setChecked(!settings.value(
+        DesignerSettingsKey::USE_QSTR_FUNCTION).toBool());
+    m_ui.styleLineEdit->setText(settings.value(
+        DesignerSettingsKey::CONTROLS_STYLE).toString());
 
-    if (designerSettings.puppetFallbackDirectory.isEmpty())
+    QString puppetFallbackDirectory = settings.value(
+        DesignerSettingsKey::PUPPET_FALLBACK_DIRECTORY).toString();
+    if (puppetFallbackDirectory.isEmpty())
         resetFallbackPuppetPath();
     else
-        m_ui.fallbackPuppetPathLineEdit->setPath(designerSettings.puppetFallbackDirectory);
+        m_ui.fallbackPuppetPathLineEdit->setPath(puppetFallbackDirectory);
 
-    if (designerSettings.puppetToplevelBuildDirectory.isEmpty())
+    QString puppetToplevelBuildDirectory = settings.value(
+        DesignerSettingsKey::PUPPET_TOPLEVEL_BUILD_DIRECTORY).toString();
+    if (puppetToplevelBuildDirectory.isEmpty())
         resetQmlPuppetBuildPath();
     else
-        m_ui.puppetBuildPathLineEdit->setPath(designerSettings.puppetToplevelBuildDirectory);
+        m_ui.puppetBuildPathLineEdit->setPath(puppetToplevelBuildDirectory);
 }
 
 void SettingsPageWidget::resetFallbackPuppetPath()
@@ -156,16 +181,20 @@ void SettingsPage::apply()
     if (!m_widget) // page was never shown
         return;
 
-    DesignerSettings currentDesignerSettings(QmlDesignerPlugin::instance()->settings());
+    DesignerSettings currentSettings(QmlDesignerPlugin::instance()->settings());
-    DesignerSettings newDesignerSettings(m_widget->settings());
+    DesignerSettings newSettings(m_widget->settings());
+
+    if (currentSettings.value(DesignerSettingsKey::PUPPET_FALLBACK_DIRECTORY) !=
+        newSettings.value(DesignerSettingsKey::PUPPET_FALLBACK_DIRECTORY) ||
+        currentSettings.value(DesignerSettingsKey::PUPPET_TOPLEVEL_BUILD_DIRECTORY) !=
+        newSettings.value(DesignerSettingsKey::PUPPET_TOPLEVEL_BUILD_DIRECTORY)) {
 
-    if (currentDesignerSettings.puppetFallbackDirectory != newDesignerSettings.puppetFallbackDirectory ||
-        currentDesignerSettings.puppetToplevelBuildDirectory != newDesignerSettings.puppetToplevelBuildDirectory) {
         QMessageBox::information(Core::ICore::mainWindow(), tr("Restart Required"),
-            tr("The QML emulation layer path changes will take effect after a restart of the QML Emulation layer or Qt Creator."));
+            tr("The QML emulation layer path changes will take effect after a "
+               "restart of the QML Emulation layer or Qt Creator."));
     }
 
-    QmlDesignerPlugin::instance()->setSettings(newDesignerSettings);
+    QmlDesignerPlugin::instance()->setSettings(newSettings);
 }
 
 void SettingsPage::finish()

src/plugins/qmldesigner/settingspage.h

@@ -51,7 +51,7 @@ public:
     explicit SettingsPageWidget(QWidget *parent = 0);
 
     DesignerSettings settings() const;
-    void setSettings(const DesignerSettings &designerSettings);
+    void setSettings(const DesignerSettings &settings);
 
 public slots:
     void debugViewEnabledToggled(bool b);