analyzer: finish split of tools into "tools-with-modes"

Change-Id: I82b61c07172a33b861a7d6db903ac2516019498b
Reviewed-on: http://codereview.qt.nokia.com/1054
Reviewed-by: hjk <qthjk@ovi.com>

18 files changed, 158 insertions, 134 deletions

diff --git a/src/plugins/analyzerbase/analyzermanager.cpp b/src/plugins/analyzerbase/analyzermanager.cpp
index 4cc96a059c..d74034c8ed 100644
--- a/src/plugins/analyzerbase/analyzermanager.cpp
+++ b/src/plugins/analyzerbase/analyzermanager.cpp
@@ -105,7 +105,7 @@ using namespace Analyzer::Internal;
 namespace Analyzer {
 namespace Internal {
 
-const char lastActiveToolC[] = "Analyzer.Plugin.LastActiveTool";
+const char LAST_ACTIVE_TOOL[] = "Analyzer.Plugin.LastActiveTool";
 const char INITIAL_DOCK_AREA[] = "initial_dock_area";
 
 AnalyzerStartParameters localStartParameters(ProjectExplorer::RunConfiguration *runConfiguration)
@@ -209,11 +209,13 @@ public:
 
     void addDock(Qt::DockWidgetArea area, QDockWidget *dockWidget);
     void addTool(IAnalyzerTool *tool, const StartModes &modes);
-    void stopTool(IAnalyzerTool *tool);
-    void handleToolFinished(IAnalyzerTool *tool);
-    void saveToolSettings(IAnalyzerTool *tool);
-    void loadToolSettings(IAnalyzerTool *tool);
+    void selectSavedTool();
     void selectTool(IAnalyzerTool *tool, StartMode mode);
+    void stopTool(IAnalyzerTool *tool, StartMode mode);
+    void handleToolFinished(IAnalyzerTool *tool, StartMode mode);
+    void saveToolSettings(IAnalyzerTool *tool, StartMode mode);
+    void loadToolSettings(IAnalyzerTool *tool);
+    QAction *actionFromToolAndMode(IAnalyzerTool *tool, StartMode mode);
 
     ProjectExplorer::RunControl *createRunControl
         (ProjectExplorer::RunConfiguration *runConfiguration, const QString &mode);
@@ -224,7 +226,7 @@ public:
 
 public slots:
     void startTool();
-    void stopTool() { stopTool(m_currentTool); }
+    void stopTool() { stopTool(m_currentTool, m_currentMode); }
 
     void selectAction();
     void selectAction(QAction *);
@@ -242,6 +244,7 @@ public:
     IAnalyzerTool *m_currentTool;
     StartMode m_currentMode;
     QHash<QAction *, IAnalyzerTool *> m_toolFromAction;
+    QHash<QAction *, StartMode> m_modeFromAction;
     QList<IAnalyzerTool *> m_tools;
     QList<QAction *> m_actions;
     QAction *m_startAction;
@@ -446,11 +449,12 @@ void AnalyzerManagerPrivate::addDock(Qt::DockWidgetArea area, QDockWidget *dockW
     ActionManager *am = ICore::instance()->actionManager();
     QAction *toggleViewAction = dockWidget->toggleViewAction();
     toggleViewAction->setText(dockWidget->windowTitle());
-    Command *cmd = am->registerAction(toggleViewAction, QString("Analyzer." + dockWidget->objectName()),
-                                      globalContext);
+    Command *cmd = am->registerAction(toggleViewAction,
+        QString("Analyzer." + dockWidget->objectName()), globalContext);
     cmd->setAttribute(Command::CA_Hide);
 
-    ActionContainer *viewsMenu = am->actionContainer(Core::Id(Core::Constants::M_WINDOW_VIEWS));
+    ActionContainer *viewsMenu =
+        am->actionContainer(Core::Id(Core::Constants::M_WINDOW_VIEWS));
     viewsMenu->addAction(cmd);
 }
 
@@ -492,14 +496,16 @@ ProjectExplorer::RunControl *AnalyzerManagerPrivate::createRunControl
 {
     Q_UNUSED(mode);
 
+    // FIXME: Move to tool implementations.
     AnalyzerStartParameters sp;
     if (qobject_cast<ProjectExplorer::LocalApplicationRunConfiguration *>(runConfiguration)) {
         sp = localStartParameters(runConfiguration);
     } else if (qobject_cast<RemoteLinux::RemoteLinuxRunConfiguration *>(runConfiguration)) {
         sp = remoteLinuxStartParameters(runConfiguration);
     } else {
-        // might be S60DeviceRunfiguration, or something else ...
-        sp.startMode = StartRemote;
+        // Might be S60DeviceRunfiguration, or something else ...
+        //sp.startMode = StartRemote;
+        sp.startMode = m_currentMode;
     }
 
     IAnalyzerTool *tool = m_currentTool;
@@ -524,12 +530,11 @@ void AnalyzerManagerPrivate::startRemoteTool(IAnalyzerTool *tool, StartMode mode
     sp.displayName = dlg.executable();
     sp.workingDirectory = dlg.workingDirectory();
 
-    AnalyzerRunControl *runControl = new AnalyzerRunControl(tool, sp, 0);
-
-    m_currentRunControl = runControl;
+    AnalyzerRunControl *rc = new AnalyzerRunControl(tool, sp, 0);
+    m_currentRunControl = rc;
 
     ProjectExplorer::ProjectExplorerPlugin::instance()
-        ->startRunControl(runControl, Constants::MODE_ANALYZE);
+        ->startRunControl(rc, Constants::MODE_ANALYZE);
 }
 
 void AnalyzerManagerPrivate::startLocalTool(IAnalyzerTool *tool, StartMode mode)
@@ -566,7 +571,7 @@ void AnalyzerManagerPrivate::startLocalTool(IAnalyzerTool *tool, StartMode mode)
         const QString msg = tr("<html><head/><body><center><i>%1</i> is still running. "
             "You have to quit the Analyzer before being able to run another instance."
             "<center/><center>Force it to quit?</center></body></html>")
-                .arg(m_currentRunControl->displayName());
+                .arg(m_currentTool->displayName());
         bool stopRequested = showPromptDialog(tr("Analyzer Still Running"), msg,
                                      tr("Stop Active Run"), tr("Keep Running"));
         if (!stopRequested)
@@ -574,17 +579,16 @@ void AnalyzerManagerPrivate::startLocalTool(IAnalyzerTool *tool, StartMode mode)
 
         // user selected to stop the active run. stop it, activate restart on stop
         m_restartOnStop = true;
-        stopTool(m_currentTool);
+        stopTool(m_currentTool, m_currentMode);
         return;
     }
 
-    IAnalyzerTool::ToolMode toolMode = tool->mode();
+    IAnalyzerTool::ToolMode toolMode = tool->toolMode();
 
     // Check the project for whether the build config is in the correct mode
     // if not, notify the user and urge him to use the correct mode.
     if (!buildTypeAccepted(toolMode, buildType)) {
         const QString toolName = tool->displayName();
-        const QString toolMode = IAnalyzerTool::modeString(tool->mode());
         const QString currentMode = buildType == ProjectExplorer::BuildConfiguration::Debug ? tr("Debug") : tr("Release");
 
         QSettings *settings = Core::ICore::instance()->settings();
@@ -593,11 +597,20 @@ void AnalyzerManagerPrivate::startLocalTool(IAnalyzerTool *tool, StartMode mode)
         if (settings->contains(configKey)) {
             ret = settings->value(configKey, QDialog::Accepted).toInt();
         } else {
+            QString toolModeString;
+            switch (toolMode) {
+                case IAnalyzerTool::DebugMode:
+                    toolModeString = tr("Debug");
+                case IAnalyzerTool::ReleaseMode:
+                    toolModeString = tr("Release");
+                case IAnalyzerTool::AnyMode:
+                    break;
+            }
             const QString title = tr("Run %1 in %2 Mode?").arg(toolName).arg(currentMode);
             const QString message = tr("<html><head/><body><p>You are trying to run the tool '%1' on an application in %2 mode. "
                                        "The tool is designed to be used in %3 mode.</p><p>"
                                        "Do you want to continue and run it in %2 mode?</p></body></html>").
-                                       arg(toolName).arg(currentMode).arg(toolMode);
+                                       arg(toolName).arg(currentMode).arg(toolModeString);
             const QString checkBoxText = tr("&Do not ask again");
             bool checkBoxSetting = false;
             const QDialogButtonBox::StandardButton button =
@@ -623,15 +636,16 @@ void AnalyzerManagerPrivate::startTool()
     m_currentTool->startTool(m_currentMode);
 }
 
-void AnalyzerManagerPrivate::stopTool(IAnalyzerTool *tool)
+void AnalyzerManagerPrivate::stopTool(IAnalyzerTool *tool, StartMode mode)
 {
     QTC_ASSERT(tool == m_currentTool, /**/);
+    QTC_ASSERT(mode == m_currentMode, /**/);
     if (m_currentRunControl)
         return;
 
     // be sure to call handleToolFinished only once, and only when the engine is really finished
     if (m_currentRunControl->stop() == ProjectExplorer::RunControl::StoppedSynchronously)
-        handleToolFinished(tool);
+        handleToolFinished(tool, mode);
     // else: wait for the finished() signal to trigger handleToolFinished()
 }
 
@@ -645,20 +659,68 @@ void AnalyzerManagerPrivate::modeChanged(IMode *mode)
     m_mainWindow->setDockActionsVisible(makeVisible);
 }
 
+QAction *AnalyzerManagerPrivate::actionFromToolAndMode(IAnalyzerTool *tool, StartMode mode)
+{
+    foreach (QAction *action, m_actions)
+        if (m_toolFromAction[action] == tool && m_modeFromAction[action] == mode)
+            return action;
+    QTC_ASSERT(false, /**/);
+    return 0;
+}
+
+void AnalyzerManagerPrivate::selectSavedTool()
+{
+    const QSettings *settings = Core::ICore::instance()->settings();
+    const QByteArray lastActiveAction =
+        settings->value(QLatin1String(LAST_ACTIVE_TOOL), QString()).toByteArray();
+    foreach (QAction *action, m_actions) {
+        IAnalyzerTool *tool = m_toolFromAction[action];
+        StartMode mode = m_modeFromAction[action];
+        if (tool->actionId(mode) == lastActiveAction) {
+            selectTool(tool, mode);
+            break;
+        }
+    }
+}
+
+void AnalyzerManagerPrivate::selectAction()
+{
+    selectAction(qobject_cast<QAction *>(sender()));
+}
+
+void AnalyzerManagerPrivate::selectAction(int index)
+{
+    selectAction(m_actions[index]);
+}
+
+void AnalyzerManagerPrivate::selectAction(QAction *action)
+{
+    selectTool(m_toolFromAction[action], m_modeFromAction[action]);
+}
+
 void AnalyzerManagerPrivate::selectTool(IAnalyzerTool *tool, StartMode mode)
 {
-    int idx = m_tools.indexOf(tool);
-    QTC_ASSERT(idx >= 0, return);
-    if (m_currentTool == tool)
+    if (m_currentTool == tool && m_currentMode == mode)
         return;
 
-    if (m_currentTool) {
-        IAnalyzerTool *oldTool = m_currentTool;
-        saveToolSettings(oldTool);
+    QAction *action = actionFromToolAndMode(tool, mode);
+    const int actionIndex = m_actions.indexOf(action);
+    QTC_ASSERT(actionIndex >= 0, return);
+
+    // Guard against recursion by m_toolBox->setCurrentIndex.
+    static bool inSelectTool = false;
+    if (inSelectTool)
+        return;
+    inSelectTool = true;
+
+    saveToolSettings(m_currentTool, m_currentMode);
 
+
+    // Clean up old tool.
+    if (m_currentTool) {
         ActionManager *am = ICore::instance()->actionManager();
 
-        foreach (QDockWidget *widget, m_toolWidgets.value(oldTool)) {
+        foreach (QDockWidget *widget, m_toolWidgets.value(m_currentTool)) {
             QAction *toggleViewAction = widget->toggleViewAction();
             am->unregisterAction(toggleViewAction,
                 QString("Analyzer." + widget->objectName()));
@@ -671,15 +733,13 @@ void AnalyzerManagerPrivate::selectTool(IAnalyzerTool *tool, StartMode mode)
             ///- ...
             widget->setParent(0);
         }
-        oldTool->toolDeselected();
+        m_currentTool->toolDeselected();
     }
 
+    // Now change the tool.
     m_currentTool = tool;
     m_currentMode = mode;
 
-    m_toolBox->setCurrentIndex(idx);
-    m_controlsWidget->setCurrentIndex(idx);
-
     const bool firstTime = !m_defaultSettings.contains(tool);
     if (firstTime) {
         tool->initializeDockWidgets();
@@ -690,23 +750,12 @@ void AnalyzerManagerPrivate::selectTool(IAnalyzerTool *tool, StartMode mode)
     }
 
     loadToolSettings(tool);
-    updateRunActions();
-}
-
-void AnalyzerManagerPrivate::selectAction()
-{
-    selectAction(qobject_cast<QAction *>(sender()));
-}
 
-void AnalyzerManagerPrivate::selectAction(int index)
-{
-    selectAction(m_actions[index]);
-}
+    m_toolBox->setCurrentIndex(actionIndex);
+    m_controlsWidget->setCurrentIndex(actionIndex);
 
-void AnalyzerManagerPrivate::selectAction(QAction *action)
-{
-    StartMode mode = StartMode(action->property("StartMode").toInt());
-    selectTool(m_toolFromAction[action], mode);
+    updateRunActions();
+    inSelectTool = false;
 }
 
 void AnalyzerManagerPrivate::addTool(IAnalyzerTool *tool, const StartModes &modes)
@@ -714,7 +763,6 @@ void AnalyzerManagerPrivate::addTool(IAnalyzerTool *tool, const StartModes &mode
     delayedInit(); // Make sure that there is a valid IMode instance.
 
     const bool blocked = m_toolBox->blockSignals(true); // Do not make current.
-
     m_controlsWidget->addWidget(tool->createControlWidget());
     ActionManager *am = Core::ICore::instance()->actionManager();
     foreach (StartMode mode, modes) {
@@ -722,24 +770,24 @@ void AnalyzerManagerPrivate::addTool(IAnalyzerTool *tool, const StartModes &mode
         QString menuGroup = tool->menuGroup(mode);
         QString actionId = tool->actionId(mode);
         QAction *action = new QAction(actionName, 0);
-        action->setProperty("StartMode", int(mode));
         Core::Command *command = am->registerAction(action, actionId,
             Core::Context(Core::Constants::C_GLOBAL));
         m_menu->addAction(command, menuGroup);
         m_actions.append(action);
         m_toolFromAction[action] = tool;
+        m_modeFromAction[action] = mode;
         m_toolBox->addItem(actionName);
         m_toolBox->blockSignals(blocked);
         connect(action, SIGNAL(triggered()), SLOT(selectAction()));
     }
-    m_toolBox->setEnabled(true);
-
     m_tools.append(tool);
+    m_toolBox->setEnabled(true);
 }
 
-void AnalyzerManagerPrivate::handleToolFinished(IAnalyzerTool *tool)
+void AnalyzerManagerPrivate::handleToolFinished(IAnalyzerTool *tool, StartMode mode)
 {
     QTC_ASSERT(tool == m_currentTool, /**/);
+    QTC_ASSERT(mode == m_currentMode, /**/);
     m_currentRunControl = 0;
     updateRunActions();
 
@@ -759,7 +807,7 @@ void AnalyzerManagerPrivate::loadToolSettings(IAnalyzerTool *tool)
     settings->endGroup();
 }
 
-void AnalyzerManagerPrivate::saveToolSettings(IAnalyzerTool *tool)
+void AnalyzerManagerPrivate::saveToolSettings(IAnalyzerTool *tool, StartMode mode)
 {
     if (!tool)
         return; // no active tool, do nothing
@@ -770,7 +818,7 @@ void AnalyzerManagerPrivate::saveToolSettings(IAnalyzerTool *tool)
     m_mainWindow->saveSettings(settings);
     settings->setValue("ToolSettingsSaved", true);
     settings->endGroup();
-    settings->setValue(QLatin1String(lastActiveToolC), tool->id());
+    settings->setValue(QLatin1String(LAST_ACTIVE_TOOL), tool->actionId(mode));
 }
 
 void AnalyzerManagerPrivate::updateRunActions()
@@ -781,7 +829,7 @@ void AnalyzerManagerPrivate::updateRunActions()
 
     bool startEnabled = !m_currentRunControl
         && pe->canRun(project, Constants::MODE_ANALYZE)
-        && m_currentTool >= 0;
+        && m_currentTool;
 
     QString disabledReason;
     if (m_currentRunControl)
@@ -822,24 +870,14 @@ void AnalyzerManager::extensionsInitialized()
     if (d->m_tools.isEmpty())
         return;
 
-    const QSettings *settings = Core::ICore::instance()->settings();
-    const QString lastActiveToolId =
-        settings->value(QLatin1String(lastActiveToolC), QString()).toString();
-
     foreach (IAnalyzerTool *tool, d->m_tools)
         tool->extensionsInitialized();
-
-    QAction *lastAction = 0;
-    foreach (QAction *action, d->m_actions)
-        if (d->m_toolFromAction[action]->id() == lastActiveToolId)
-            lastAction = action;
-    if (lastAction)
-        d->selectAction(lastAction);
+    d->selectSavedTool();
 }
 
 void AnalyzerManager::shutdown()
 {
-    d->saveToolSettings(d->m_currentTool);
+    d->saveToolSettings(d->m_currentTool, d->m_currentMode);
 }
 
 void AnalyzerManager::addTool(IAnalyzerTool *tool, const StartModes &modes)
@@ -910,30 +948,30 @@ void AnalyzerManager::showMode()
         ModeManager::instance()->activateMode(m_instance->d->m_mode->id());
 }
 
-void AnalyzerManager::stopTool(IAnalyzerTool *tool)
+void AnalyzerManager::stopTool(IAnalyzerTool *tool, StartMode mode)
 {
-    m_instance->stopTool(tool);
+    m_instance->d->stopTool(tool, mode);
 }
 
 void AnalyzerManager::startLocalTool(IAnalyzerTool *tool, StartMode mode)
 {
-    m_instance->startLocalTool(tool, mode);
+    m_instance->d->startLocalTool(tool, mode);
 }
 
 void AnalyzerManager::startRemoteTool(IAnalyzerTool *tool, StartMode mode)
 {
-    m_instance->startRemoteTool(tool, mode);
+    m_instance->d->startRemoteTool(tool, mode);
 }
 
 ProjectExplorer::RunControl *AnalyzerManager::createRunControl
         (ProjectExplorer::RunConfiguration *runConfiguration, const QString &mode)
 {
-    return m_instance->createRunControl(runConfiguration, mode);
+    return m_instance->d->createRunControl(runConfiguration, mode);
 }
 
-void AnalyzerManager::handleToolFinished(IAnalyzerTool *tool)
+void AnalyzerManager::handleToolFinished(IAnalyzerTool *tool, StartMode mode)
 {
-    m_instance->d->handleToolFinished(tool);
+    m_instance->d->handleToolFinished(tool, mode);
 }
 
 IAnalyzerTool *AnalyzerManager::toolById(const QByteArray &id)
diff --git a/src/plugins/analyzerbase/analyzermanager.h b/src/plugins/analyzerbase/analyzermanager.h
index cc5f4edd5d..0c66e9ff78 100644
--- a/src/plugins/analyzerbase/analyzermanager.h
+++ b/src/plugins/analyzerbase/analyzermanager.h
@@ -71,7 +71,7 @@ public:
         (ProjectExplorer::RunConfiguration *runConfiguration, const QString &mode);
 
     // Register a tool and initialize it.
-    static void addTool(Analyzer::IAnalyzerTool *tool, const StartModes &mode);
+    static void addTool(IAnalyzerTool *tool, const StartModes &mode);
     static IAnalyzerTool *toolById(const QByteArray &id);
 
     // Dockwidgets are registered to the main window.
@@ -83,9 +83,9 @@ public:
     static void showMode();
     static void selectTool(IAnalyzerTool *tool, StartMode mode);
     static void startTool(IAnalyzerTool *tool, StartMode mode);
-    static void stopTool(IAnalyzerTool *tool);
+    static void stopTool(IAnalyzerTool *tool, StartMode mode);
 
-    // Convienience functions.
+    // Convenience functions.
     static void startLocalTool(IAnalyzerTool *tool, StartMode mode);
     static void startRemoteTool(IAnalyzerTool *tool, StartMode mode);
 
@@ -95,7 +95,7 @@ public:
     static void showStatusMessage(const QString &message, int timeoutMS = 10000);
     static void showPermanentStatusMessage(const QString &message);
 
-    static void handleToolFinished(IAnalyzerTool *tool);
+    static void handleToolFinished(IAnalyzerTool *tool, StartMode mode);
 
 private:
     friend class AnalyzerManagerPrivate;
diff --git a/src/plugins/analyzerbase/analyzerruncontrol.cpp b/src/plugins/analyzerbase/analyzerruncontrol.cpp
index a9f42e5408..efa2ecebb0 100644
--- a/src/plugins/analyzerbase/analyzerruncontrol.cpp
+++ b/src/plugins/analyzerbase/analyzerruncontrol.cpp
@@ -131,7 +131,7 @@ void AnalyzerRunControl::engineFinished()
 
 void AnalyzerRunControl::runControlFinished()
 {
-    AnalyzerManager::handleToolFinished(d->m_engine->tool());
+    AnalyzerManager::handleToolFinished(d->m_engine->tool(), d->m_engine->mode());
 }
 
 bool AnalyzerRunControl::isRunning() const
diff --git a/src/plugins/analyzerbase/analyzerruncontrol.h b/src/plugins/analyzerbase/analyzerruncontrol.h
index a2d0c893d1..e066ccfac4 100644
--- a/src/plugins/analyzerbase/analyzerruncontrol.h
+++ b/src/plugins/analyzerbase/analyzerruncontrol.h
@@ -57,7 +57,7 @@ public:
         RunConfiguration *runConfiguration);
     ~AnalyzerRunControl();
 
-    // pure virtuals from ProjectExplorer::RunControl
+    // ProjectExplorer::RunControl
     void start();
     StopResult stop();
     bool isRunning() const;
diff --git a/src/plugins/analyzerbase/analyzerruncontrolfactory.cpp b/src/plugins/analyzerbase/analyzerruncontrolfactory.cpp
index a3a5258e9b..2c173cb593 100644
--- a/src/plugins/analyzerbase/analyzerruncontrolfactory.cpp
+++ b/src/plugins/analyzerbase/analyzerruncontrolfactory.cpp
@@ -45,6 +45,7 @@
 
 using namespace Analyzer;
 using namespace Analyzer::Internal;
+using namespace ProjectExplorer;
 
 /////////////////////////////////////////////////////////////////////////////////
 //
@@ -55,6 +56,7 @@ using namespace Analyzer::Internal;
 AnalyzerRunControlFactory::AnalyzerRunControlFactory(QObject *parent)
     : IRunControlFactory(parent)
 {
+    setObjectName(QLatin1String("AnalyzerRunControlFactory"));
 }
 
 bool AnalyzerRunControlFactory::canRun(RunConfiguration *runConfiguration, const QString &mode) const
@@ -62,8 +64,7 @@ bool AnalyzerRunControlFactory::canRun(RunConfiguration *runConfiguration, const
     return runConfiguration->isEnabled() && mode == Constants::MODE_ANALYZE;
 }
 
-ProjectExplorer::RunControl *AnalyzerRunControlFactory::create(RunConfiguration *runConfiguration,
-                                                               const QString &mode)
+RunControl *AnalyzerRunControlFactory::create(RunConfiguration *runConfiguration, const QString &mode)
 {
     QTC_ASSERT(canRun(runConfiguration, mode), return 0);
     return AnalyzerManager::createRunControl(runConfiguration, mode);
@@ -74,16 +75,15 @@ QString AnalyzerRunControlFactory::displayName() const
     return tr("Analyzer");
 }
 
-ProjectExplorer::IRunConfigurationAspect *AnalyzerRunControlFactory::createRunConfigurationAspect()
+IRunConfigurationAspect *AnalyzerRunControlFactory::createRunConfigurationAspect()
 {
     return new AnalyzerProjectSettings;
 }
 
-ProjectExplorer::RunConfigWidget *AnalyzerRunControlFactory::createConfigurationWidget(RunConfiguration
-                                                                                       *runConfiguration)
+RunConfigWidget *AnalyzerRunControlFactory::createConfigurationWidget(RunConfiguration *runConfiguration)
 {
-    ProjectExplorer::LocalApplicationRunConfiguration *localRc =
-        qobject_cast<ProjectExplorer::LocalApplicationRunConfiguration *>(runConfiguration);
+    LocalApplicationRunConfiguration *localRc =
+        qobject_cast<LocalApplicationRunConfiguration *>(runConfiguration);
     if (!localRc)
         return 0;
     AnalyzerProjectSettings *settings = runConfiguration->extraAspect<AnalyzerProjectSettings>();
diff --git a/src/plugins/analyzerbase/ianalyzerengine.h b/src/plugins/analyzerbase/ianalyzerengine.h
index d3191682fc..8596fbf53c 100644
--- a/src/plugins/analyzerbase/ianalyzerengine.h
+++ b/src/plugins/analyzerbase/ianalyzerengine.h
@@ -83,7 +83,8 @@ public:
     const AnalyzerStartParameters &startParameters() const { return m_sp; }
 
     /// The tool this engine is associated with.
-    IAnalyzerTool *tool() { return m_tool; }
+    IAnalyzerTool *tool() const { return m_tool; }
+    StartMode mode() const { return m_sp.startMode; }
 
 signals:
     /// Should be emitted when the debuggee outputted something.
diff --git a/src/plugins/analyzerbase/ianalyzertool.cpp b/src/plugins/analyzerbase/ianalyzertool.cpp
index eb0abbfd48..2e234cc11d 100644
--- a/src/plugins/analyzerbase/ianalyzertool.cpp
+++ b/src/plugins/analyzerbase/ianalyzertool.cpp
@@ -41,19 +41,6 @@ IAnalyzerTool::IAnalyzerTool(QObject *parent)
     : QObject(parent)
 {}
 
-QString IAnalyzerTool::modeString(ToolMode mode)
-{
-    switch (mode) {
-        case IAnalyzerTool::DebugMode:
-            return tr("Debug");
-        case IAnalyzerTool::ReleaseMode:
-            return tr("Release");
-        case IAnalyzerTool::AnyMode:
-            break;
-    }
-    return QString();
-}
-
 QByteArray IAnalyzerTool::defaultMenuGroup(StartMode mode)
 {
     if (mode == StartRemote)
@@ -61,15 +48,17 @@ QByteArray IAnalyzerTool::defaultMenuGroup(StartMode mode)
     return Analyzer::Constants::G_ANALYZER_TOOLS;
 }
 
-QByteArray IAnalyzerTool::defaultActionId(const QByteArray &id, StartMode mode)
+QByteArray IAnalyzerTool::defaultActionId(const IAnalyzerTool *tool, StartMode mode)
 {
+    QByteArray id = tool->id();
     if (mode == StartRemote)
         return "Action." + id + ".RemoteStart." + QByteArray::number(mode);
     return "Action." + id + ".LocalStart." + QByteArray::number(mode);
 }
 
-QString IAnalyzerTool::defaultActionName(const QString &base, StartMode mode)
+QString IAnalyzerTool::defaultActionName(const IAnalyzerTool *tool, StartMode mode)
 {
+    QString base = tool->displayName();
     if (mode == StartRemote)
         return base + tr(" (Remote)");
     return base;
diff --git a/src/plugins/analyzerbase/ianalyzertool.h b/src/plugins/analyzerbase/ianalyzertool.h
index 50e526ed2e..1f6f23a49c 100644
--- a/src/plugins/analyzerbase/ianalyzertool.h
+++ b/src/plugins/analyzerbase/ianalyzertool.h
@@ -78,12 +78,14 @@ public:
     /// Returns a user readable description name for this tool.
     virtual QString description() const = 0;
     /// Returns an id for the start action.
-    virtual QByteArray actionId(StartMode m) const { return defaultActionId(id(), m); }
+    virtual QByteArray actionId(StartMode mode) const
+        { return defaultActionId(this, mode); }
     /// Returns the menu group the start action should go to.
-    virtual QByteArray menuGroup(StartMode m) const { return defaultMenuGroup(m); }
+    virtual QByteArray menuGroup(StartMode mode) const
+        { return defaultMenuGroup(mode); }
     /// Returns a short user readable action name for this tool.
-    virtual QString actionName(StartMode m) const
-        { return defaultActionName(displayName(), m); }
+    virtual QString actionName(StartMode mode) const
+        { return defaultActionName(this, mode); }
 
     /**
      * The mode in which this tool should preferably be run
@@ -97,14 +99,12 @@ public:
         ReleaseMode,
         AnyMode
     };
-    virtual ToolMode mode() const = 0;
-
-    static QString modeString(ToolMode mode);
+    virtual ToolMode toolMode() const = 0;
 
     /// Convenience implementation.
-    static QByteArray defaultMenuGroup(StartMode m);
-    static QByteArray defaultActionId(const QByteArray &id, StartMode m);
-    static QString defaultActionName(const QString &base, StartMode m);
+    static QByteArray defaultMenuGroup(StartMode mode);
+    static QByteArray defaultActionId(const IAnalyzerTool *tool, StartMode mode);
+    static QString defaultActionName(const IAnalyzerTool *tool, StartMode mode);
     static void defaultStartTool(IAnalyzerTool *tool, StartMode mode);
 
     /// This gets called after all analyzation tools where initialized.
@@ -125,8 +125,8 @@ public:
     virtual IAnalyzerEngine *createEngine(const AnalyzerStartParameters &sp,
         ProjectExplorer::RunConfiguration *runConfiguration = 0) = 0;
 
-    virtual void startTool(StartMode m)
-        { return defaultStartTool(this, m); }
+    virtual void startTool(StartMode mode)
+        { return defaultStartTool(this, mode); }
 
     /// Called when tools gets selected.
     virtual void toolSelected() const {}
diff --git a/src/plugins/debugger/debuggerconstants.h b/src/plugins/debugger/debuggerconstants.h
index 7ff518a5b3..904d369606 100644
--- a/src/plugins/debugger/debuggerconstants.h
+++ b/src/plugins/debugger/debuggerconstants.h
@@ -48,7 +48,7 @@ const char * const C_QMLDEBUGGER        = "Qml/JavaScript Debugger";
 
 // Project Explorer run mode (RUN/DEBUG)
 const char * const DEBUGMODE            = "Debugger.DebugMode";
-const char * const DEBUGMODE2           = "Debugger.DebugMode2";
+const char * const DEBUGMODE2           = "Debugger.DebugMode2"; // Breaks on main.
 
 // Common actions (accessed by QML inspector)
 const char * const INTERRUPT            = "Debugger.Interrupt";
diff --git a/src/plugins/qmlprofiler/qmlprofilerengine.cpp b/src/plugins/qmlprofiler/qmlprofilerengine.cpp
index a1e700c394..93b87f3dfd 100644
--- a/src/plugins/qmlprofiler/qmlprofilerengine.cpp
+++ b/src/plugins/qmlprofiler/qmlprofilerengine.cpp
@@ -159,7 +159,7 @@ void QmlProfilerEngine::stop()
 void QmlProfilerEngine::stopped()
 {
     d->m_running = false;
-    AnalyzerManager::stopTool(tool());
+    AnalyzerManager::stopTool(tool(), mode());
     emit finished();
 }
 
diff --git a/src/plugins/qmlprofiler/qmlprofilertool.cpp b/src/plugins/qmlprofiler/qmlprofilertool.cpp
index f766a55512..372ceccc91 100644
--- a/src/plugins/qmlprofiler/qmlprofilertool.cpp
+++ b/src/plugins/qmlprofiler/qmlprofilertool.cpp
@@ -121,6 +121,7 @@ public:
 QmlProfilerTool::QmlProfilerTool(QObject *parent)
     : IAnalyzerTool(parent), d(new QmlProfilerToolPrivate(this))
 {
+    setObjectName("QmlProfilerTool");
     d->m_client = 0;
     d->m_connectionAttempts = 0;
     d->m_traceWindow = 0;
@@ -163,7 +164,7 @@ QString QmlProfilerTool::description() const
               "applications using QML.");
 }
 
-IAnalyzerTool::ToolMode QmlProfilerTool::mode() const
+IAnalyzerTool::ToolMode QmlProfilerTool::toolMode() const
 {
     return AnyMode;
 }
diff --git a/src/plugins/qmlprofiler/qmlprofilertool.h b/src/plugins/qmlprofiler/qmlprofilertool.h
index 15884b8948..50e3d1d55c 100644
--- a/src/plugins/qmlprofiler/qmlprofilertool.h
+++ b/src/plugins/qmlprofiler/qmlprofilertool.h
@@ -51,7 +51,7 @@ public:
     QByteArray id() const;
     QString displayName() const;
     QString description() const;
-    ToolMode mode() const;
+    ToolMode toolMode() const;
 
     void extensionsInitialized() {}
     void initializeDockWidgets();
diff --git a/src/plugins/qmlprofiler/qmlprojectanalyzerruncontrolfactory.cpp b/src/plugins/qmlprofiler/qmlprojectanalyzerruncontrolfactory.cpp
index e1171609dc..7d5bb34752 100644
--- a/src/plugins/qmlprofiler/qmlprojectanalyzerruncontrolfactory.cpp
+++ b/src/plugins/qmlprofiler/qmlprojectanalyzerruncontrolfactory.cpp
@@ -68,6 +68,7 @@ AnalyzerStartParameters localStartParameters(ProjectExplorer::RunConfiguration *
 QmlProjectAnalyzerRunControlFactory::QmlProjectAnalyzerRunControlFactory(QObject *parent)
     : IRunControlFactory(parent)
 {
+    setObjectName(QLatin1String("QmlProjectAnalyzerRunControlFactory"));
 }
 
 bool QmlProjectAnalyzerRunControlFactory::canRun(RunConfiguration *runConfiguration, const QString &mode) const
diff --git a/src/plugins/valgrind/callgrindtool.cpp b/src/plugins/valgrind/callgrindtool.cpp
index 70dc87a05a..88abedc536 100644
--- a/src/plugins/valgrind/callgrindtool.cpp
+++ b/src/plugins/valgrind/callgrindtool.cpp
@@ -501,9 +501,9 @@ CallgrindTool::CallgrindTool(QObject *parent)
     : Analyzer::IAnalyzerTool(parent)
 {
     d = new CallgrindToolPrivate(this);
-    Core::ICore *core = Core::ICore::instance();
+    setObjectName(QLatin1String("CallgrindTool"));
 
-    // EditorManager
+    Core::ICore *core = Core::ICore::instance();
     QObject *editorManager = core->editorManager();
     connect(editorManager, SIGNAL(editorOpened(Core::IEditor*)),
         d, SLOT(editorOpened(Core::IEditor*)));
@@ -530,7 +530,7 @@ QString CallgrindTool::description() const
               "record function calls when a program runs.");
 }
 
-IAnalyzerTool::ToolMode CallgrindTool::mode() const
+IAnalyzerTool::ToolMode CallgrindTool::toolMode() const
 {
     return ReleaseMode;
 }
diff --git a/src/plugins/valgrind/callgrindtool.h b/src/plugins/valgrind/callgrindtool.h
index 6aba3c7b14..517753287f 100644
--- a/src/plugins/valgrind/callgrindtool.h
+++ b/src/plugins/valgrind/callgrindtool.h
@@ -51,7 +51,7 @@ public:
     QByteArray id() const;
     QString displayName() const;
     QString description() const;
-    ToolMode mode() const;
+    ToolMode toolMode() const;
 
     void extensionsInitialized();
     void initializeDockWidgets();
diff --git a/src/plugins/valgrind/memchecktool.cpp b/src/plugins/valgrind/memchecktool.cpp
index 7b7094f290..b2b744ba95 100644
--- a/src/plugins/valgrind/memchecktool.cpp
+++ b/src/plugins/valgrind/memchecktool.cpp
@@ -229,11 +229,6 @@ void MemcheckTool::settingsDestroyed(QObject *settings)
     m_settings = AnalyzerGlobalSettings::instance();
 }
 
-void MemcheckTool::extensionsInitialized()
-{
-    //ensureWidgets(); // FIXME: Try to do that later.
-}
-
 void MemcheckTool::maybeActiveRunConfigurationChanged()
 {
     ensureWidgets();
@@ -308,7 +303,7 @@ QString MemcheckTool::description() const
         "memory leaks");
 }
 
-IAnalyzerTool::ToolMode MemcheckTool::mode() const
+IAnalyzerTool::ToolMode MemcheckTool::toolMode() const
 {
     return DebugMode;
 }
diff --git a/src/plugins/valgrind/memchecktool.h b/src/plugins/valgrind/memchecktool.h
index c83b4d6d84..3035c0d7c3 100644
--- a/src/plugins/valgrind/memchecktool.h
+++ b/src/plugins/valgrind/memchecktool.h
@@ -110,10 +110,10 @@ private slots:
     void suppressionActionTriggered();
 
 private:
-    ToolMode mode() const;
+    ToolMode toolMode() const;
     void ensureWidgets();
     void initializeDockWidgets();
-    void extensionsInitialized();
+    void extensionsInitialized() {}
     QWidget *createControlWidget();
 
     Analyzer::IAnalyzerEngine *createEngine(const Analyzer::AnalyzerStartParameters &sp,
@@ -122,7 +122,6 @@ private:
     void clearErrorView();
 
 private:
-    bool m_local;
     Analyzer::AnalyzerSettings *m_settings;
     QMenu *m_filterMenu;
 
diff --git a/src/plugins/valgrind/valgrindengine.cpp b/src/plugins/valgrind/valgrindengine.cpp
index d3a01fc7e4..26420cb65f 100644
--- a/src/plugins/valgrind/valgrindengine.cpp
+++ b/src/plugins/valgrind/valgrindengine.cpp
@@ -130,7 +130,7 @@ QString ValgrindEngine::executable() const
 
 void ValgrindEngine::handleProgressCanceled()
 {
-    AnalyzerManager::stopTool(tool());
+    AnalyzerManager::stopTool(tool(), mode());
 }
 
 void ValgrindEngine::handleProgressFinished()