Analyzer: Cleanup settings handling

More flexible, less over-engineered this way.

Change-Id: I3e224a6be85d3a187056d79fd506e8cf6a32c8a9
Reviewed-by: Daniel Teske <daniel.teske@digia.com>

src/plugins/valgrind/callgrindengine.cpp

@@ -64,19 +64,18 @@ QStringList CallgrindRunControl::toolArguments() const
 {
     QStringList arguments;
 
-    ValgrindBaseSettings *callgrindSettings = m_settings->subConfig<ValgrindBaseSettings>();
-    QTC_ASSERT(callgrindSettings, return arguments);
+    QTC_ASSERT(m_settings, return arguments);
 
-    if (callgrindSettings->enableCacheSim())
+    if (m_settings->enableCacheSim())
         arguments << QLatin1String("--cache-sim=yes");
 
-    if (callgrindSettings->enableBranchSim())
+    if (m_settings->enableBranchSim())
         arguments << QLatin1String("--branch-sim=yes");
 
-    if (callgrindSettings->collectBusEvents())
+    if (m_settings->collectBusEvents())
         arguments << QLatin1String("--collect-bus=yes");
 
-    if (callgrindSettings->collectSystime())
+    if (m_settings->collectSystime())
         arguments << QLatin1String("--collect-systime=yes");
 
     if (m_markAsPaused)

src/plugins/valgrind/callgrindtool.cpp

@@ -213,12 +213,6 @@ public:
 };
 
 
-static ValgrindGlobalSettings *globalSettings()
-{
-    return AnalyzerGlobalSettings::instance()->subConfig<ValgrindGlobalSettings>();
-}
-
-
 CallgrindToolPrivate::CallgrindToolPrivate(CallgrindTool *parent)
     : q(parent)
     , m_dataModel(new DataModel(this))
@@ -399,7 +393,7 @@ void CallgrindToolPrivate::updateCostFormat()
         m_calleesView->setCostFormat(format);
         m_callersView->setCostFormat(format);
     }
-    if (ValgrindGlobalSettings *settings = globalSettings())
+    if (ValgrindGlobalSettings *settings = ValgrindPlugin::globalSettings())
         settings->setCostFormat(format);
 }
 
@@ -583,8 +577,9 @@ AnalyzerRunControl *CallgrindToolPrivate::createRunControl(const AnalyzerStartPa
 
     // apply project settings
     if (runConfiguration) {
-        if (const AnalyzerRunConfigurationAspect *analyzerSettings = runConfiguration->extraAspect<AnalyzerRunConfigurationAspect>()) {
-            if (const ValgrindProjectSettings *settings = analyzerSettings->subConfig<ValgrindProjectSettings>()) {
+        if (AnalyzerRunConfigurationAspect *analyzerAspect
+                = runConfiguration->extraAspect<AnalyzerRunConfigurationAspect>(ANALYZER_VALGRIND_SETTINGS)) {
+            if (const ValgrindBaseSettings *settings = qobject_cast<ValgrindBaseSettings *>(analyzerAspect->currentConfig())) {
                 m_visualisation->setMinimumInclusiveCostRatio(settings->visualisationMinimumInclusiveCostRatio() / 100.0);
                 m_proxyModel->setMinimumInclusiveCostRatio(settings->minimumInclusiveCostRatio() / 100.0);
                 m_dataModel->setVerboseToolTipsEnabled(settings->enableEventToolTips());
@@ -785,7 +780,7 @@ QWidget *CallgrindToolPrivate::createWidgets()
     }
 
 
-    ValgrindGlobalSettings *settings = globalSettings();
+    ValgrindGlobalSettings *settings = ValgrindPlugin::globalSettings();
 
     // cycle detection
     //action = new QAction(QLatin1String("Cycle Detection"), this); ///FIXME: icon

src/plugins/valgrind/memcheckengine.cpp

@@ -99,22 +99,21 @@ QStringList MemcheckRunControl::toolArguments() const
     QStringList arguments;
     arguments << QLatin1String("--gen-suppressions=all");
 
-    ValgrindBaseSettings *memcheckSettings = m_settings->subConfig<ValgrindBaseSettings>();
-    QTC_ASSERT(memcheckSettings, return arguments);
+    QTC_ASSERT(m_settings, return arguments);
 
-    if (memcheckSettings->trackOrigins())
+    if (m_settings->trackOrigins())
         arguments << QLatin1String("--track-origins=yes");
 
-    foreach (const QString &file, memcheckSettings->suppressionFiles())
+    foreach (const QString &file, m_settings->suppressionFiles())
         arguments << QString::fromLatin1("--suppressions=%1").arg(file);
 
-    arguments << QString::fromLatin1("--num-callers=%1").arg(memcheckSettings->numCallers());
+    arguments << QString::fromLatin1("--num-callers=%1").arg(m_settings->numCallers());
     return arguments;
 }
 
 QStringList MemcheckRunControl::suppressionFiles() const
 {
-    return m_settings->subConfig<ValgrindBaseSettings>()->suppressionFiles();
+    return m_settings->suppressionFiles();
 }
 
 void MemcheckRunControl::status(const Status &status)

src/plugins/valgrind/memcheckerrorview.cpp

@@ -494,7 +494,7 @@ QString MemcheckErrorView::defaultSuppressionFile() const
 
 // slot, can (for now) be invoked either when the settings were modified *or* when the active
 // settings object has changed.
-void MemcheckErrorView::settingsChanged(Analyzer::AnalyzerSettings *settings)
+void MemcheckErrorView::settingsChanged(ValgrindBaseSettings *settings)
 {
     QTC_ASSERT(settings, return);
     m_settings = settings;

src/plugins/valgrind/memcheckerrorview.h

@@ -33,11 +33,11 @@
 
 #include <QListView>
 
-namespace Analyzer { class AnalyzerSettings; }
-
 namespace Valgrind {
 namespace Internal {
 
+class ValgrindBaseSettings;
+
 class MemcheckErrorView : public QListView
 {
     Q_OBJECT
@@ -52,10 +52,10 @@ public:
 
     void setDefaultSuppressionFile(const QString &suppFile);
     QString defaultSuppressionFile() const;
-    Analyzer::AnalyzerSettings *settings() const { return m_settings; }
+    ValgrindBaseSettings *settings() const { return m_settings; }
 
 public slots:
-    void settingsChanged(Analyzer::AnalyzerSettings *settings);
+    void settingsChanged(ValgrindBaseSettings *settings);
     void goNext();
     void goBack();
 
@@ -75,7 +75,7 @@ private:
     QAction *m_copyAction;
     QAction *m_suppressAction;
     QString m_defaultSuppFile;
-    Analyzer::AnalyzerSettings *m_settings;
+    ValgrindBaseSettings *m_settings;
 };
 
 } // namespace Internal

src/plugins/valgrind/memchecktool.cpp

@@ -37,6 +37,7 @@
 #include <analyzerbase/analyzermanager.h>
 #include <analyzerbase/analyzerconstants.h>
 
+#include <valgrind/valgrindsettings.h>
 #include <valgrind/xmlprotocol/errorlistmodel.h>
 #include <valgrind/xmlprotocol/stackmodel.h>
 #include <valgrind/xmlprotocol/error.h>
@@ -220,20 +221,21 @@ MemcheckTool::MemcheckTool(QObject *parent)
 void MemcheckTool::settingsDestroyed(QObject *settings)
 {
     QTC_ASSERT(m_settings == settings, return);
-    m_settings = AnalyzerGlobalSettings::instance();
+    m_settings = ValgrindPlugin::globalSettings();
 }
 
 void MemcheckTool::maybeActiveRunConfigurationChanged()
 {
-    AnalyzerSettings *settings = 0;
+    ValgrindBaseSettings *settings = 0;
     ProjectExplorerPlugin *pe = ProjectExplorerPlugin::instance();
     if (Project *project = pe->startupProject())
         if (Target *target = project->activeTarget())
             if (RunConfiguration *rc = target->activeRunConfiguration())
-                settings = rc->extraAspect<AnalyzerRunConfigurationAspect>();
+                if (AnalyzerRunConfigurationAspect *aspect = rc->extraAspect<AnalyzerRunConfigurationAspect>(ANALYZER_VALGRIND_SETTINGS))
+                    settings = qobject_cast<ValgrindBaseSettings *>(aspect->customSubConfig());
 
     if (!settings) // fallback to global settings
-        settings = AnalyzerGlobalSettings::instance();
+        settings = ValgrindPlugin::globalSettings();
 
     if (m_settings == settings)
         return;
@@ -247,33 +249,29 @@ void MemcheckTool::maybeActiveRunConfigurationChanged()
     // now make the new settings current, update and connect input widgets
     m_settings = settings;
     QTC_ASSERT(m_settings, return);
-
     connect(m_settings, SIGNAL(destroyed(QObject*)), SLOT(settingsDestroyed(QObject*)));
 
-    ValgrindBaseSettings *memcheckSettings = m_settings->subConfig<ValgrindBaseSettings>();
-    QTC_ASSERT(memcheckSettings, return);
-
     foreach (QAction *action, m_errorFilterActions) {
         bool contained = true;
         foreach (const QVariant &v, action->data().toList()) {
             bool ok;
             int kind = v.toInt(&ok);
-            if (ok && !memcheckSettings->visibleErrorKinds().contains(kind))
+            if (ok && !m_settings->visibleErrorKinds().contains(kind))
                 contained = false;
         }
         action->setChecked(contained);
     }
 
-    m_filterProjectAction->setChecked(!memcheckSettings->filterExternalIssues());
+    m_filterProjectAction->setChecked(!m_settings->filterExternalIssues());
     m_errorView->settingsChanged(m_settings);
 
-    connect(memcheckSettings, SIGNAL(visibleErrorKindsChanged(QList<int>)),
+    connect(m_settings, SIGNAL(visibleErrorKindsChanged(QList<int>)),
             m_errorProxyModel, SLOT(setAcceptedKinds(QList<int>)));
-    m_errorProxyModel->setAcceptedKinds(memcheckSettings->visibleErrorKinds());
+    m_errorProxyModel->setAcceptedKinds(m_settings->visibleErrorKinds());
 
-    connect(memcheckSettings, SIGNAL(filterExternalIssuesChanged(bool)),
+    connect(m_settings, SIGNAL(filterExternalIssuesChanged(bool)),
             m_errorProxyModel, SLOT(setFilterExternalIssues(bool)));
-    m_errorProxyModel->setFilterExternalIssues(memcheckSettings->filterExternalIssues());
+    m_errorProxyModel->setFilterExternalIssues(m_settings->filterExternalIssues());
 }
 
 RunMode MemcheckTool::runMode() const
@@ -498,9 +496,7 @@ void MemcheckTool::updateErrorFilter()
     QTC_ASSERT(m_errorView, return);
     QTC_ASSERT(m_settings, return);
 
-    ValgrindBaseSettings *memcheckSettings = m_settings->subConfig<ValgrindBaseSettings>();
-    QTC_ASSERT(memcheckSettings, return);
-    memcheckSettings->setFilterExternalIssues(!m_filterProjectAction->isChecked());
+    m_settings->setFilterExternalIssues(!m_filterProjectAction->isChecked());
 
     QList<int> errorKinds;
     foreach (QAction *a, m_errorFilterActions) {
@@ -513,7 +509,7 @@ void MemcheckTool::updateErrorFilter()
                 errorKinds << kind;
         }
     }
-    memcheckSettings->setVisibleErrorKinds(errorKinds);
+    m_settings->setVisibleErrorKinds(errorKinds);
 }
 
 void MemcheckTool::finished()

src/plugins/valgrind/memchecktool.h

@@ -48,15 +48,12 @@ class Error;
 }
 }
 
-namespace Analyzer {
-class AnalyzerSettings;
-}
-
 namespace Valgrind {
 namespace Internal {
 
-class MemcheckErrorView;
 class FrameFinder;
+class MemcheckErrorView;
+class ValgrindBaseSettings;
 
 class MemcheckErrorFilterProxyModel : public QSortFilterProxyModel
 {
@@ -109,7 +106,7 @@ private:
     void clearErrorView();
 
 private:
-    Analyzer::AnalyzerSettings *m_settings;
+    ValgrindBaseSettings *m_settings;
     QMenu *m_filterMenu;
 
     FrameFinder *m_frameFinder;

src/plugins/valgrind/suppressiondialog.cpp

@@ -222,7 +222,7 @@ void SuppressionDialog::accept()
         }
     }
 
-    m_settings->subConfig<ValgrindBaseSettings>()->addSuppressionFiles(QStringList(path));
+    m_settings->addSuppressionFiles(QStringList(path));
 
     QModelIndexList indices = m_view->selectionModel()->selectedRows();
     qSort(indices.begin(), indices.end(), sortIndizesReverse);

src/plugins/valgrind/suppressiondialog.h

@@ -42,12 +42,11 @@ class QPlainTextEdit;
 class QDialogButtonBox;
 QT_END_NAMESPACE
 
-namespace Analyzer { class AnalyzerSettings; }
-
 namespace Valgrind {
 namespace Internal {
 
 class MemcheckErrorView;
+class ValgrindBaseSettings;
 
 class SuppressionDialog : public QDialog
 {
@@ -66,7 +65,7 @@ private:
     void reject();
 
     MemcheckErrorView *m_view;
-    Analyzer::AnalyzerSettings *m_settings;
+    ValgrindBaseSettings *m_settings;
     bool m_cleanupIfCanceled;
     QList<XmlProtocol::Error> m_errors;
 

src/plugins/valgrind/valgrindconfigwidget.cpp

@@ -30,6 +30,7 @@
 
 #include "valgrindconfigwidget.h"
 #include "valgrindsettings.h"
+#include "valgrindplugin.h"
 
 #include "ui_valgrindconfigwidget.h"
 
@@ -173,7 +174,7 @@ void ValgrindConfigWidget::updateUi()
 
 void ValgrindConfigWidget::slotAddSuppression()
 {
-    ValgrindGlobalSettings *conf = Analyzer::AnalyzerGlobalSettings::instance()->subConfig<ValgrindGlobalSettings>();
+    ValgrindGlobalSettings *conf = ValgrindPlugin::globalSettings();
     QTC_ASSERT(conf, return);
     QStringList files = QFileDialog::getOpenFileNames(this,
         tr("Valgrind Suppression Files"),

src/plugins/valgrind/valgrindengine.cpp

@@ -30,13 +30,14 @@
 
 #include "valgrindengine.h"
 #include "valgrindsettings.h"
+#include "valgrindplugin.h"
 
 #include <coreplugin/icore.h>
 #include <coreplugin/ioutputpane.h>
 #include <coreplugin/progressmanager/progressmanager.h>
 #include <coreplugin/progressmanager/futureprogress.h>
 #include <extensionsystem/pluginmanager.h>
-#include <projectexplorer/localapplicationrunconfiguration.h>
+#include <projectexplorer/runconfiguration.h>
 #include <analyzerbase/analyzermanager.h>
 
 #include <QApplication>
@@ -47,6 +48,7 @@
 using namespace Analyzer;
 using namespace Core;
 using namespace Utils;
+using namespace ProjectExplorer;
 
 namespace Valgrind {
 namespace Internal {
@@ -62,10 +64,11 @@ ValgrindRunControl::ValgrindRunControl(const AnalyzerStartParameters &sp,
       m_isStopping(false)
 {
     if (runConfiguration)
-        m_settings = runConfiguration->extraAspect<AnalyzerRunConfigurationAspect>();
+        if (AnalyzerRunConfigurationAspect *aspect = runConfiguration->extraAspect<AnalyzerRunConfigurationAspect>(ANALYZER_VALGRIND_SETTINGS))
+            m_settings = qobject_cast<ValgrindBaseSettings *>(aspect->customSubConfig());
 
-    if  (!m_settings)
-        m_settings = AnalyzerGlobalSettings::instance();
+    if (!m_settings)
+        m_settings = ValgrindPlugin::globalSettings();
 
     connect(m_progressWatcher, SIGNAL(canceled()),
             this, SLOT(handleProgressCanceled()));
@@ -99,7 +102,7 @@ bool ValgrindRunControl::startEngine()
 
     ValgrindRunner *run = runner();
     run->setWorkingDirectory(sp.workingDirectory);
-    QString valgrindExe = m_settings->subConfig<ValgrindBaseSettings>()->valgrindExecutable();
+    QString valgrindExe = m_settings->valgrindExecutable();
     if (!sp.analyzerCmdPrefix.isEmpty())
         valgrindExe = sp.analyzerCmdPrefix + QLatin1Char(' ') + valgrindExe;
     run->setValgrindExecutable(valgrindExe);
@@ -173,7 +176,7 @@ void ValgrindRunControl::receiveProcessOutput(const QByteArray &output, OutputFo
 void ValgrindRunControl::receiveProcessError(const QString &message, QProcess::ProcessError error)
 {
     if (error == QProcess::FailedToStart) {
-        const QString &valgrind = m_settings->subConfig<ValgrindBaseSettings>()->valgrindExecutable();
+        const QString valgrind = m_settings->valgrindExecutable();
         if (!valgrind.isEmpty())
             appendMessage(tr("** Error: \"%1\" could not be started: %2 **\n").arg(valgrind).arg(message), ErrorMessageFormat);
         else

src/plugins/valgrind/valgrindengine.h

@@ -34,12 +34,11 @@
 #include <analyzerbase/analyzerruncontrol.h>
 #include <utils/environment.h>
 #include <valgrind/valgrindrunner.h>
+#include <valgrind/valgrindsettings.h>
 
 #include <QFutureInterface>
 #include <QFutureWatcher>
 
-namespace Analyzer { class AnalyzerSettings; }
-
 namespace Valgrind {
 namespace Internal {
 
@@ -62,7 +61,7 @@ protected:
     virtual QStringList toolArguments() const = 0;
     virtual Valgrind::ValgrindRunner *runner() = 0;
 
-    Analyzer::AnalyzerSettings *m_settings;
+    ValgrindBaseSettings *m_settings;
     QFutureInterface<void> *m_progress;
     QFutureWatcher<void> *m_progressWatcher;
 

src/plugins/valgrind/valgrindplugin.cpp

@@ -37,23 +37,42 @@
 #include <analyzerbase/analyzermanager.h>
 #include <analyzerbase/analyzersettings.h>
 
+#include <coreplugin/dialogs/ioptionspage.h>
+
 #include <valgrind/valgrindsettings.h>
 
 #include <utils/hostosinfo.h>
 
 #include <QtPlugin>
+#include <QCoreApplication>
 
 using namespace Analyzer;
 
 namespace Valgrind {
 namespace Internal {
 
-class ProjectSettingsFactory : public AnalyzerSubConfigFactory
+static ValgrindGlobalSettings *theGlobalSettings = 0;
+
+class ValgrindOptionsPage : public Core::IOptionsPage
 {
-    AbstractAnalyzerSubConfig *createProjectSettings()
+public:
+    explicit ValgrindOptionsPage()
     {
-        return new ValgrindProjectSettings();
+        setId(ANALYZER_VALGRIND_SETTINGS);
+        setDisplayName(tr("Valgrind"));
+        setCategory("T.Analyzer");
+        setDisplayCategory(QCoreApplication::translate("Analyzer", "Analyzer"));
+        setCategoryIcon(QLatin1String(":/images/analyzer_category.png"));
     }
+
+    QWidget *createPage(QWidget *parent) {
+        return theGlobalSettings->createConfigWidget(parent);
+    }
+
+    void apply() {
+        theGlobalSettings->writeSettings();
+    }
+    void finish() {}
 };
 
 class ValgrindAction : public AnalyzerAction
@@ -62,10 +81,19 @@ public:
     ValgrindAction() {}
 };
 
+
+ValgrindPlugin::~ValgrindPlugin()
+{
+    delete theGlobalSettings;
+    theGlobalSettings = 0;
+}
+
 bool ValgrindPlugin::initialize(const QStringList &, QString *)
 {
-    AnalyzerGlobalSettings::registerConfig(new ValgrindGlobalSettings());
-    AnalyzerRunConfigurationAspect::registerConfigFactory(new ProjectSettingsFactory());
+    theGlobalSettings = new ValgrindGlobalSettings();
+    theGlobalSettings->readSettings();
+
+    addAutoReleasedObject(new ValgrindOptionsPage());
 
     IAnalyzerTool *memcheckTool = new MemcheckTool(this);
     IAnalyzerTool *callgrindTool = new CallgrindTool(this);
@@ -122,6 +150,11 @@ bool ValgrindPlugin::initialize(const QStringList &, QString *)
     return true;
 }
 
+ValgrindGlobalSettings *ValgrindPlugin::globalSettings()
+{
+   return theGlobalSettings;
+}
+
 } // namespace Internal
 } // namespace Valgrind
 

src/plugins/valgrind/valgrindplugin.h

@@ -37,6 +37,8 @@
 namespace Valgrind {
 namespace Internal {
 
+class ValgrindGlobalSettings;
+
 class ValgrindPlugin : public ExtensionSystem::IPlugin
 {
     Q_OBJECT
@@ -44,9 +46,12 @@ class ValgrindPlugin : public ExtensionSystem::IPlugin
 
 public:
     ValgrindPlugin() {}
+    ~ValgrindPlugin();
 
-    virtual bool initialize(const QStringList &arguments, QString *errorString);
-    virtual void extensionsInitialized() {}
+    bool initialize(const QStringList &arguments, QString *errorString);
+    void extensionsInitialized() {}
+
+    static ValgrindGlobalSettings *globalSettings();
 };
 
 } // namespace Internal

src/plugins/valgrind/valgrindruncontrolfactory.cpp

@@ -28,6 +28,8 @@
 ****************************************************************************/
 
 #include "valgrindruncontrolfactory.h"
+#include "valgrindsettings.h"
+#include "valgrindplugin.h"
 
 #include <analyzerbase/ianalyzertool.h>
 #include <analyzerbase/analyzermanager.h>
@@ -109,7 +111,11 @@ RunControl *ValgrindRunControlFactory::create(RunConfiguration *runConfiguration
 IRunConfigurationAspect *ValgrindRunControlFactory::createRunConfigurationAspect(RunConfiguration *rc)
 {
     Q_UNUSED(rc);
-    return new AnalyzerRunConfigurationAspect;
+    IRunConfigurationAspect *aspect
+        = new AnalyzerRunConfigurationAspect(new ValgrindProjectSettings(), ValgrindPlugin::globalSettings());
+    aspect->setId(ANALYZER_VALGRIND_SETTINGS);
+    aspect->setDisplayName(tr("Valgrind Settings"));
+    return aspect;
 }
 
 } // namespace Internal

src/plugins/valgrind/valgrindsettings.cpp

@@ -29,6 +29,7 @@
 ****************************************************************************/
 
 #include "valgrindsettings.h"
+#include "valgrindplugin.h"
 #include "valgrindconfigwidget.h"
 
 #include <coreplugin/icore.h>
@@ -75,34 +76,6 @@ namespace Internal {
 //
 //////////////////////////////////////////////////////////////////
 
-QVariantMap ValgrindBaseSettings::defaults() const
-{
-    QVariantMap map;
-
-    // General
-    map.insert(QLatin1String(valgrindExeC), QLatin1String("valgrind"));
-
-    // Memcheck
-    map.insert(QLatin1String(numCallersC), 25);
-    map.insert(QLatin1String(trackOriginsC), true);
-    map.insert(QLatin1String(filterExternalIssuesC), true);
-    QVariantList defaultErrorKinds;
-    for (int i = 0; i < Valgrind::XmlProtocol::MemcheckErrorKindCount; ++i)
-        defaultErrorKinds << i;
-    map.insert(QLatin1String(visibleErrorKindsC), defaultErrorKinds);
-
-    // Callgrind
-    map.insert(QLatin1String(callgrindEnableCacheSimC), false);
-    map.insert(QLatin1String(callgrindEnableBranchSimC), false);
-    map.insert(QLatin1String(callgrindCollectSystimeC), false);
-    map.insert(QLatin1String(callgrindCollectBusEventsC), false);
-    map.insert(QLatin1String(callgrindEnableEventToolTipsC), true);
-    map.insert(QLatin1String(callgrindMinimumCostRatioC), 0.01);
-    map.insert(QLatin1String(callgrindVisualisationMinimumCostRatioC), 10.0);
-
-    return map;
-}
-
 void ValgrindBaseSettings::fromMap(const QVariantMap &map)
 {
     // General
@@ -172,11 +145,6 @@ QString ValgrindBaseSettings::valgrindExecutable() const
     return m_valgrindExecutable;
 }
 
-Core::Id ValgrindBaseSettings::id() const
-{
-    return "Analyzer.Valgrind.Settings";
-}
-
 QString ValgrindBaseSettings::displayName() const
 {
     return tr("Valgrind");
@@ -286,27 +254,16 @@ void ValgrindBaseSettings::setVisualisationMinimumInclusiveCostRatio(
 //
 //////////////////////////////////////////////////////////////////
 
+ValgrindGlobalSettings::ValgrindGlobalSettings()
+{
+    readSettings();
+}
+
 QWidget *ValgrindGlobalSettings::createConfigWidget(QWidget *parent)
 {
     return new ValgrindConfigWidget(this, parent, true);
 }
 
-QVariantMap ValgrindGlobalSettings::defaults() const
-{
-    QVariantMap map = ValgrindBaseSettings::defaults();
-
-    // Memcheck
-    map.insert(QLatin1String(suppressionFilesC), QStringList());
-    map.insert(QLatin1String(lastSuppressionDirectoryC), QString());
-    map.insert(QLatin1String(lastSuppressionHistoryC), QStringList());
-
-    // Callgrind
-    map.insert(QLatin1String(callgrindCostFormatC), CostDelegate::FormatRelative);
-    map.insert(QLatin1String(callgrindCycleDetectionC), true);
-
-    return map;
-}
-
 void ValgrindGlobalSettings::fromMap(const QVariantMap &map)
 {
     ValgrindBaseSettings::fromMap(map);
@@ -390,6 +347,61 @@ void ValgrindGlobalSettings::setLastSuppressionDialogHistory(const QStringList &
     m_lastSuppressionHistory = history;
 }
 
+static const char groupC[] = "Analyzer";
+
+void ValgrindGlobalSettings::readSettings()
+{
+    QVariantMap defaults;
+
+    // General
+    defaults.insert(QLatin1String(valgrindExeC), QLatin1String("valgrind"));
+
+    // Memcheck
+    defaults.insert(QLatin1String(numCallersC), 25);
+    defaults.insert(QLatin1String(trackOriginsC), true);
+    defaults.insert(QLatin1String(filterExternalIssuesC), true);
+    QVariantList defaultErrorKinds;
+    for (int i = 0; i < Valgrind::XmlProtocol::MemcheckErrorKindCount; ++i)
+        defaultErrorKinds << i;
+    defaults.insert(QLatin1String(visibleErrorKindsC), defaultErrorKinds);
+
+    defaults.insert(QLatin1String(suppressionFilesC), QStringList());
+    defaults.insert(QLatin1String(lastSuppressionDirectoryC), QString());
+    defaults.insert(QLatin1String(lastSuppressionHistoryC), QStringList());
+
+    // Callgrind
+    defaults.insert(QLatin1String(callgrindEnableCacheSimC), false);
+    defaults.insert(QLatin1String(callgrindEnableBranchSimC), false);
+    defaults.insert(QLatin1String(callgrindCollectSystimeC), false);
+    defaults.insert(QLatin1String(callgrindCollectBusEventsC), false);
+    defaults.insert(QLatin1String(callgrindEnableEventToolTipsC), true);
+    defaults.insert(QLatin1String(callgrindMinimumCostRatioC), 0.01);
+    defaults.insert(QLatin1String(callgrindVisualisationMinimumCostRatioC), 10.0);
+
+    defaults.insert(QLatin1String(callgrindCostFormatC), CostDelegate::FormatRelative);
+    defaults.insert(QLatin1String(callgrindCycleDetectionC), true);
+
+    // Read stored values
+    QSettings *settings = Core::ICore::settings();
+    settings->beginGroup(QLatin1String(groupC));
+    QVariantMap map = defaults;
+    for (QVariantMap::ConstIterator it = defaults.constBegin(); it != defaults.constEnd(); ++it)
+        map.insert(it.key(), settings->value(it.key(), it.value()));
+    settings->endGroup();
+
+    fromMap(map);
+}
+
+void ValgrindGlobalSettings::writeSettings() const
+{
+    QSettings *settings = Core::ICore::settings();
+    settings->beginGroup(QLatin1String(groupC));
+    const QVariantMap map = toMap();
+    for (QVariantMap::ConstIterator it = map.begin(); it != map.end(); ++it)
+        settings->setValue(it.key(), it.value());
+    settings->endGroup();
+}
+
 //
 // Callgrind
 //
@@ -401,7 +413,7 @@ CostDelegate::CostFormat ValgrindGlobalSettings::costFormat() const
 void ValgrindGlobalSettings::setCostFormat(CostDelegate::CostFormat format)
 {
     m_costFormat = format;
-    AnalyzerGlobalSettings::instance()->writeSettings();
+    writeSettings();
 }
 
 bool ValgrindGlobalSettings::detectCycles() const
@@ -412,7 +424,7 @@ bool ValgrindGlobalSettings::detectCycles() const
 void ValgrindGlobalSettings::setDetectCycles(bool on)
 {
     m_detectCycles = on;
-    AnalyzerGlobalSettings::instance()->writeSettings();
+    writeSettings();
 }
 
 bool ValgrindGlobalSettings::shortenTemplates() const
@@ -423,15 +435,9 @@ bool ValgrindGlobalSettings::shortenTemplates() const
 void ValgrindGlobalSettings::setShortenTemplates(bool on)
 {
     m_shortenTemplates = on;
-    AnalyzerGlobalSettings::instance()->writeSettings();
+    writeSettings();
 }
 
-ValgrindGlobalSettings *globalValgrindSettings()
-{
-    ValgrindGlobalSettings *ret = AnalyzerGlobalSettings::instance()->subConfig<ValgrindGlobalSettings>();
-    QTC_ASSERT(ret, return 0);
-    return ret;
-}
 
 //////////////////////////////////////////////////////////////////
 //
@@ -444,17 +450,6 @@ QWidget *ValgrindProjectSettings::createConfigWidget(QWidget *parent)
     return new ValgrindConfigWidget(this, parent, false);
 }
 
-QVariantMap ValgrindProjectSettings::defaults() const
-{
-    QVariantMap map = ValgrindBaseSettings::defaults();
-
-    // Memcheck
-    map.insert(QLatin1String(addedSuppressionFilesC), QStringList());
-    map.insert(QLatin1String(removedSuppressionFilesC), QStringList());
-
-    return map;
-}
-
 void ValgrindProjectSettings::fromMap(const QVariantMap &map)
 {
     ValgrindBaseSettings::fromMap(map);
@@ -488,7 +483,7 @@ QVariantMap ValgrindProjectSettings::toMap() const
 
 void ValgrindProjectSettings::addSuppressionFiles(const QStringList &suppressions)
 {
-    QStringList globalSuppressions = globalValgrindSettings()->suppressionFiles();
+    QStringList globalSuppressions = ValgrindPlugin::globalSettings()->suppressionFiles();
     foreach (const QString &s, suppressions) {
         if (m_addedSuppressionFiles.contains(s))
             continue;
@@ -500,7 +495,7 @@ void ValgrindProjectSettings::addSuppressionFiles(const QStringList &suppression
 
 void ValgrindProjectSettings::removeSuppressionFiles(const QStringList &suppressions)
 {
-    QStringList globalSuppressions = globalValgrindSettings()->suppressionFiles();
+    QStringList globalSuppressions = ValgrindPlugin::globalSettings()->suppressionFiles();
     foreach (const QString &s, suppressions) {
         m_addedSuppressionFiles.removeAll(s);
         if (globalSuppressions.contains(s))
@@ -510,7 +505,7 @@ void ValgrindProjectSettings::removeSuppressionFiles(const QStringList &suppress
 
 QStringList ValgrindProjectSettings::suppressionFiles() const
 {
-    QStringList ret = globalValgrindSettings()->suppressionFiles();
+    QStringList ret = ValgrindPlugin::globalSettings()->suppressionFiles();
     foreach (const QString &s, m_disabledGlobalSuppressionFiles)
         ret.removeAll(s);
     ret.append(m_addedSuppressionFiles);

src/plugins/valgrind/valgrindsettings.h

@@ -41,6 +41,8 @@
 namespace Valgrind {
 namespace Internal {
 
+const char ANALYZER_VALGRIND_SETTINGS[] = "Analyzer.Valgrind.Settings";
+
 /**
  * Valgrind settings shared for global and per-project.
  */
@@ -52,10 +54,7 @@ public:
     ValgrindBaseSettings() {}
 
     virtual QVariantMap toMap() const;
-    virtual QVariantMap defaults() const;
     virtual void fromMap(const QVariantMap &map);
-
-    virtual Core::Id id() const;
     virtual QString displayName() const;
 
 signals:
@@ -167,11 +166,10 @@ class ValgrindGlobalSettings : public ValgrindBaseSettings
     Q_OBJECT
 
 public:
-    ValgrindGlobalSettings() {}
+    ValgrindGlobalSettings();
 
     QWidget *createConfigWidget(QWidget *parent);
     QVariantMap toMap() const;
-    QVariantMap defaults() const;
     void fromMap(const QVariantMap &map);
     virtual AbstractAnalyzerSubConfig *clone();
 
@@ -191,6 +189,9 @@ public:
     void setLastSuppressionDialogHistory(const QStringList &history);
     QStringList lastSuppressionDialogHistory() const;
 
+    void writeSettings() const;
+    void readSettings();
+
 private:
     QStringList m_suppressionFiles;
     QString m_lastSuppressionDirectory;
@@ -229,7 +230,6 @@ public:
 
     QWidget *createConfigWidget(QWidget *parent);
     QVariantMap toMap() const;
-    QVariantMap defaults() const;
     void fromMap(const QVariantMap &map);
     virtual AbstractAnalyzerSubConfig *clone();