Analyzer: Rework the dock widget layout generation

Decouple layout generation from widget generation and
separate analyzer action description from menu action creation.

Tool specific layouts are named "Perspective" now.

Change-Id: I774efe77a07640c4cc26e4e566662c8a673c8831
Reviewed-by: Christian Stenger <christian.stenger@theqtcompany.com>

src/plugins/android/androidanalyzesupport.cpp

@@ -28,7 +28,6 @@
 #include "androidrunner.h"
 #include "androidmanager.h"
 
-#include <debugger/analyzer/ianalyzertool.h>
 #include <debugger/analyzer/analyzermanager.h>
 #include <debugger/analyzer/analyzerruncontrol.h>
 #include <debugger/analyzer/analyzerstartparameters.h>

src/plugins/clangstaticanalyzer/clangstaticanalyzerplugin.cpp

@@ -135,20 +135,24 @@ bool ClangStaticAnalyzerPlugin::initialize(const QStringList &arguments, QString
     const QString toolTip = tr("Clang Static Analyzer uses the analyzer from the clang project "
                                "to find bugs.");
 
-    auto action = new AnalyzerAction(this);
-    action->setRunMode(Constants::CLANGSTATICANALYZER_RUN_MODE);
-    action->setToolId(ClangStaticAnalyzerToolId);
-    action->setActionId("ClangStaticAnalyzer");
-    action->setWidgetCreator(widgetCreator);
-    action->setRunControlCreator(runControlCreator);
-    action->setCustomToolStarter([tool](ProjectExplorer::RunConfiguration *rc) {
+    Perspective perspective(ClangStaticAnalyzerPerspective);
+    perspective.addDock(ClangStaticAnalyzerDock, Core::Id(), Perspective::SplitVertical);
+    AnalyzerManager::addPerspective(perspective);
+
+    ActionDescription desc;
+    desc.setText(tr("Clang Static Analyzer"));
+    desc.setToolTip(toolTip);
+    desc.setEnabled(false);
+    desc.setRunMode(Constants::CLANGSTATICANALYZER_RUN_MODE);
+    desc.setPerspectiveId(ClangStaticAnalyzerPerspective);
+    desc.setActionId(ClangStaticAnalyzerAction);
+    desc.setWidgetCreator(widgetCreator);
+    desc.setRunControlCreator(runControlCreator);
+    desc.setCustomToolStarter([tool](ProjectExplorer::RunConfiguration *rc) {
         tool->startTool(rc);
     });
-    action->setText(tr("Clang Static Analyzer"));
-    action->setToolTip(toolTip);
-    action->setMenuGroup(Analyzer::Constants::G_ANALYZER_TOOLS);
-    action->setEnabled(false);
-    AnalyzerManager::addAction(action);
+    desc.setMenuGroup(Analyzer::Constants::G_ANALYZER_TOOLS);
+    AnalyzerManager::addAction(desc);
 
     return true;
 }

src/plugins/clangstaticanalyzer/clangstaticanalyzertool.cpp

@@ -45,6 +45,7 @@
 #include <utils/checkablemessagebox.h>
 #include <utils/fancymainwindow.h>
 
+#include <QAction>
 #include <QDockWidget>
 #include <QHBoxLayout>
 #include <QLabel>
@@ -103,11 +104,7 @@ QWidget *ClangStaticAnalyzerTool::createWidgets()
                 this, &ClangStaticAnalyzerTool::handleStateUpdate);
     }
 
-    QDockWidget *issuesDock = AnalyzerManager::createDockWidget(ClangStaticAnalyzerToolId,
-                                                                m_diagnosticView);
-    issuesDock->show();
-    Utils::FancyMainWindow *mw = AnalyzerManager::mainWindow();
-    mw->splitDockWidget(mw->toolBarDockWidget(), issuesDock, Qt::Vertical);
+    AnalyzerManager::createDockWidget(m_diagnosticView, ClangStaticAnalyzerDock);
 
     //
     // Toolbar widget
@@ -294,7 +291,7 @@ void ClangStaticAnalyzerTool::handleStateUpdate()
         message += tr("%n issues found (%1 suppressed).", 0, issuesFound)
                 .arg(issuesFound - issuesVisible);
     }
-    AnalyzerManager::showPermanentStatusMessage(ClangStaticAnalyzerToolId, message);
+    AnalyzerManager::showPermanentStatusMessage(ClangStaticAnalyzerPerspective, message);
 }
 
 } // namespace Internal

src/plugins/clangstaticanalyzer/clangstaticanalyzertool.h

@@ -26,14 +26,11 @@
 #ifndef CLANGSTATICANALYZERTOOL_H
 #define CLANGSTATICANALYZERTOOL_H
 
-#include <debugger/analyzer/ianalyzertool.h>
+#include <debugger/analyzer/analyzermanager.h>
 #include <cpptools/projectinfo.h>
 
 #include <QHash>
 
-namespace Analyzer { class DetailedErrorView; }
-namespace ProjectExplorer { class Target; }
-
 namespace ClangStaticAnalyzer {
 namespace Internal {
 
@@ -43,7 +40,9 @@ class ClangStaticAnalyzerDiagnosticView;
 class Diagnostic;
 class DummyRunConfiguration;
 
-const char ClangStaticAnalyzerToolId[] = "ClangStaticAnalyzer";
+const char ClangStaticAnalyzerPerspective[] = "ClangStaticAnalyzerPerspective";
+const char ClangStaticAnalyzerAction[] = "ClangStaticAnalyzerAction";
+const char ClangStaticAnalyzerDock[] = "ClangStaticAnalyzerDock";
 
 class ClangStaticAnalyzerTool : public QObject
 {

src/plugins/clangstaticanalyzer/clangstaticanalyzerunittests.cpp

@@ -89,7 +89,7 @@ void ClangStaticAnalyzerUnitTests::testProject()
     CppTools::Tests::ProjectOpenerAndCloser projectManager;
     const CppTools::ProjectInfo projectInfo = projectManager.open(projectFilePath, true);
     QVERIFY(projectInfo.isValid());
-    AnalyzerManager::selectAction(ClangStaticAnalyzerToolId, /* alsoRunIt = */ true);
+    AnalyzerManager::selectAction(ClangStaticAnalyzerPerspective, /* alsoRunIt = */ true);
     QSignalSpy waiter(m_analyzerTool, SIGNAL(finished(bool)));
     QVERIFY(waiter.wait(30000));
     const QList<QVariant> arguments = waiter.takeFirst();

src/plugins/debugger/analyzer/analyzer.pri

@@ -4,7 +4,6 @@ QT += network
 # AnalyzerBase files
 
 SOURCES += \
-    $$PWD/ianalyzertool.cpp \
     $$PWD/analyzerruncontrol.cpp \
     $$PWD/analyzermanager.cpp \
     $$PWD/analyzerrunconfigwidget.cpp \
@@ -14,7 +13,6 @@ SOURCES += \
     $$PWD/startremotedialog.cpp
 
 HEADERS += \
-    $$PWD/ianalyzertool.h \
     $$PWD/analyzerbase_global.h \
     $$PWD/analyzerconstants.h \
     $$PWD/analyzerruncontrol.h \

src/plugins/debugger/analyzer/analyzermanager.h

@@ -28,21 +28,154 @@
 #define ANALYZERMANAGER_H
 
 #include "analyzerbase_global.h"
+#include "analyzerconstants.h"
 
+#include <coreplugin/id.h>
+
+#include <projectexplorer/projectexplorerconstants.h>
 #include <projectexplorer/runconfiguration.h>
 
+#include <QCoreApplication>
+
+#include <functional>
+
 QT_BEGIN_NAMESPACE
 class QDockWidget;
 class QAction;
 QT_END_NAMESPACE
 
-namespace Utils { class FancyMainWindow; }
+namespace ProjectExplorer { class RunConfiguration; }
 
 namespace Analyzer {
 
-class AnalyzerAction;
 class AnalyzerRunControl;
 
+/**
+ * The mode in which this tool should preferably be run
+ *
+ * Debugging tools which try to show stack traces as close as possible to what the source code
+ * looks like will prefer SymbolsMode. Profiling tools which need optimized code for realistic
+ * performance, but still want to show analytical output that depends on debug symbols, will prefer
+ * ProfileMode.
+ */
+enum ToolMode {
+    DebugMode     = 0x1,
+    ProfileMode   = 0x2,
+    ReleaseMode   = 0x4,
+    SymbolsMode   = DebugMode   | ProfileMode,
+    OptimizedMode = ProfileMode | ReleaseMode,
+    AnyMode       = DebugMode   | ProfileMode | ReleaseMode
+};
+Q_DECLARE_FLAGS(ToolModes, ToolMode)
+
+/**
+ * This class represents an analyzation action, i.e. a tool that runs in a specific mode.
+ *
+*/
+
+class ANALYZER_EXPORT ActionDescription
+{
+    Q_DECLARE_TR_FUNCTIONS(Analyzer::AnalyzerAction)
+
+public:
+    ActionDescription() {}
+
+    Core::Id menuGroup() const { return m_menuGroup; }
+    void setMenuGroup(Core::Id menuGroup) { m_menuGroup = menuGroup; }
+
+    Core::Id actionId() const { return m_actionId; }
+    void setActionId(Core::Id id) { m_actionId = id; }
+
+    Core::Id perspectiveId() const { return m_perspective; }
+    void setPerspectiveId(Core::Id id) { m_perspective = id; }
+    void setToolMode(QFlags<ToolMode> mode) { m_toolMode = mode; }
+
+    Core::Id runMode() const { return m_runMode; }
+    void setRunMode(Core::Id mode) { m_runMode = mode; }
+    bool isRunnable(QString *reason = 0) const;
+
+    /// Creates all widgets used by the tool.
+    /// Returns a control widget which will be shown in the status bar when
+    /// this tool is selected.
+    typedef std::function<QWidget *()> WidgetCreator;
+    QWidget *createWidget() const { return m_widgetCreator(); }
+    void setWidgetCreator(const WidgetCreator &creator) { m_widgetCreator = creator; }
+
+    /// Returns a new engine for the given start parameters.
+    /// Called each time the tool is launched.
+    typedef std::function<AnalyzerRunControl *(ProjectExplorer::RunConfiguration *runConfiguration,
+                                               Core::Id runMode)> RunControlCreator;
+    RunControlCreator runControlCreator() const { return m_runControlCreator; }
+    void setRunControlCreator(const RunControlCreator &creator) { m_runControlCreator = creator; }
+
+    typedef std::function<bool()> ToolPreparer;
+    ToolPreparer toolPreparer() const { return m_toolPreparer; }
+    void setToolPreparer(const ToolPreparer &toolPreparer) { m_toolPreparer = toolPreparer; }
+
+    void startTool() const;
+
+    /// This is only used for setups not using the startup project.
+    typedef std::function<void(ProjectExplorer::RunConfiguration *runConfiguration)> ToolStarter;
+    void setCustomToolStarter(const ToolStarter &toolStarter) { m_customToolStarter = toolStarter; }
+
+    QString toolTip() const { return m_toolTip; }
+    void setToolTip(const QString &toolTip) { m_toolTip = toolTip; }
+
+    QString text() const { return m_text; }
+    void setText(const QString &text) { m_text = text; }
+
+    bool enabled() const { return m_enabled; }
+    void setEnabled(bool enabled) { m_enabled = enabled; }
+
+private:
+    bool m_enabled = false;
+    QString m_text;
+    QString m_toolTip;
+    Core::Id m_menuGroup;
+    Core::Id m_actionId;
+    Core::Id m_perspective;
+    QFlags<ToolMode> m_toolMode = AnyMode;
+    Core::Id m_runMode;
+    WidgetCreator m_widgetCreator;
+    RunControlCreator m_runControlCreator;
+    ToolStarter m_customToolStarter;
+    ToolPreparer m_toolPreparer;
+};
+
+class ANALYZER_EXPORT Perspective
+{
+public:
+    enum SplitType { SplitVertical, SplitHorizontal, AddToTab };
+
+    struct Split {
+        Split() = default;
+        Split(Core::Id e, Core::Id d, SplitType t, bool v, Qt::DockWidgetArea a)
+            : existing(e), dockId(d), splitType(t), visibleByDefault(v), area(a)
+        {}
+        Core::Id existing;
+        Core::Id dockId;
+        SplitType splitType;
+        bool visibleByDefault;
+        Qt::DockWidgetArea area;
+    };
+    typedef QVector<Split> Splits;
+
+    Perspective(Core::Id id = Core::Id()) : m_id(id) {}
+
+    Core::Id id() const { return m_id; }
+    void addDock(Core::Id dockId, Core::Id existing, SplitType splitType,
+                 bool visibleByDefault = true,
+                 Qt::DockWidgetArea area = Qt::BottomDockWidgetArea);
+
+    Splits splits() const { return m_splits; }
+    QList<Core::Id> docks() const { return m_docks; }
+
+private:
+    Core::Id m_id;
+    QList<Core::Id> m_docks;
+    Splits m_splits;
+};
+
 
 // FIXME: Merge with AnalyzerPlugin.
 class ANALYZER_EXPORT AnalyzerManager : public QObject
@@ -56,21 +189,21 @@ public:
     static void shutdown();
 
     // Register a tool for a given start mode.
-    static void addAction(AnalyzerAction *action);
+    static void addAction(const ActionDescription &desc);
+    static void addPerspective(const Perspective &perspective);
 
     // Dockwidgets are registered to the main window.
-    static QDockWidget *createDockWidget(Core::Id toolId,
-        QWidget *widget, Qt::DockWidgetArea area = Qt::BottomDockWidgetArea);
+    static QDockWidget *createDockWidget(QWidget *widget, Core::Id dockId);
 
-    static Utils::FancyMainWindow *mainWindow();
+    static void enableMainWindow(bool on);
 
     static void showMode();
     static void selectAction(Core::Id actionId, bool alsoRunIt = false);
     static void stopTool();
 
     // Convenience functions.
-    static void showStatusMessage(Core::Id toolId, const QString &message, int timeoutMS = 10000);
-    static void showPermanentStatusMessage(Core::Id toolId, const QString &message);
+    static void showStatusMessage(Core::Id perspective, const QString &message, int timeoutMS = 10000);
+    static void showPermanentStatusMessage(Core::Id perspective, const QString &message);
 
     static void handleToolStarted();
     static void handleToolFinished();

src/plugins/debugger/analyzer/analyzerruncontrol.cpp

@@ -25,9 +25,8 @@
 ****************************************************************************/
 
 #include "analyzericons.h"
-#include "analyzerruncontrol.h"
-#include "ianalyzertool.h"
 #include "analyzermanager.h"
+#include "analyzerruncontrol.h"
 
 #include <projectexplorer/project.h>
 #include <projectexplorer/runconfigurationaspects.h>

src/plugins/debugger/analyzer/ianalyzertool.cpp

-/****************************************************************************
-**
-** Copyright (C) 2016 The Qt Company Ltd.
-** Author: Nicolas Arnaud-Cormos, KDAB (nicolas.arnaud-cormos@kdab.com)
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of Qt Creator.
-**
-** Commercial License Usage
-** Licensees holding valid commercial Qt licenses may use this file in
-** accordance with the commercial license agreement provided with the
-** Software or, alternatively, in accordance with the terms contained in
-** a written agreement between you and The Qt Company. For licensing terms
-** and conditions see https://www.qt.io/terms-conditions. For further
-** information use the contact form at https://www.qt.io/contact-us.
-**
-** GNU General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU
-** General Public License version 3 as published by the Free Software
-** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
-** included in the packaging of this file. Please review the following
-** information to ensure the GNU General Public License requirements will
-** be met: https://www.gnu.org/licenses/gpl-3.0.html.
-**
-****************************************************************************/
-
-#include "ianalyzertool.h"
-
-#include "analyzermanager.h"
-#include "analyzerruncontrol.h"
-
-#include <coreplugin/icore.h>
-#include <coreplugin/imode.h>
-#include <coreplugin/modemanager.h>
-
-#include <projectexplorer/projectexplorer.h>
-#include <projectexplorer/project.h>
-#include <projectexplorer/buildconfiguration.h>
-#include <projectexplorer/session.h>
-#include <projectexplorer/target.h>
-#include <projectexplorer/taskhub.h>
-
-#include <utils/qtcassert.h>
-#include <utils/checkablemessagebox.h>
-
-#include <QAction>
-#include <QDialog>
-#include <QDialogButtonBox>
-#include <QSettings>
-
-using namespace Core;
-using namespace ProjectExplorer;
-
-namespace Analyzer {
-
-AnalyzerAction::AnalyzerAction(QObject *parent)
-    : QAction(parent), m_toolMode(AnyMode)
-{}
-
-bool AnalyzerAction::isRunnable(QString *reason) const
-{
-    if (m_customToolStarter) // Something special. Pretend we can always run it.
-        return true;
-
-    return ProjectExplorerPlugin::canRun(SessionManager::startupProject(), m_runMode, reason);
-}
-
-static bool buildTypeAccepted(QFlags<ToolMode> toolMode, BuildConfiguration::BuildType buildType)
-{
-    if (buildType == BuildConfiguration::Unknown)
-        return true;
-    if (buildType == BuildConfiguration::Debug && (toolMode & DebugMode))
-        return true;
-    if (buildType == BuildConfiguration::Release && (toolMode & ReleaseMode))
-        return true;
-    if (buildType == BuildConfiguration::Profile && (toolMode & ProfileMode))
-        return true;
-    return false;
-}
-
-void AnalyzerAction::startTool()
-{
-    // Make sure mode is shown.
-    AnalyzerManager::showMode();
-
-    TaskHub::clearTasks(Constants::ANALYZERTASK_ID);
-    AnalyzerManager::showPermanentStatusMessage(toolId(), QString());
-
-    if (m_toolPreparer && !m_toolPreparer())
-        return;
-
-    // ### not sure if we're supposed to check if the RunConFiguration isEnabled
-    Project *pro = SessionManager::startupProject();
-    RunConfiguration *rc = 0;
-    BuildConfiguration::BuildType buildType = BuildConfiguration::Unknown;
-    if (pro) {
-        if (const Target *target = pro->activeTarget()) {
-            // Build configuration is 0 for QML projects.
-            if (const BuildConfiguration *buildConfig = target->activeBuildConfiguration())
-                buildType = buildConfig->buildType();
-            rc = target->activeRunConfiguration();
-        }
-    }
-
-    // Custom start.
-    if (m_customToolStarter) {
-        if (rc) {
-            m_customToolStarter(rc);
-        } else {
-            const QString toolName = text();
-            QMessageBox *errorDialog = new QMessageBox(ICore::mainWindow());
-            errorDialog->setIcon(QMessageBox::Warning);
-            errorDialog->setWindowTitle(toolName);
-            errorDialog->setText(tr("Cannot start %1 without a project. Please open the project "
-                                    "and try again.").arg(toolName));
-            errorDialog->setStandardButtons(QMessageBox::Ok);
-            errorDialog->setDefaultButton(QMessageBox::Ok);
-            errorDialog->show();
-        }
-        return;
-    }
-
-    // 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(m_toolMode, buildType)) {
-        QString currentMode;
-        switch (buildType) {
-            case BuildConfiguration::Debug:
-                currentMode = AnalyzerManager::tr("Debug");
-                break;
-            case BuildConfiguration::Profile:
-                currentMode = AnalyzerManager::tr("Profile");
-                break;
-            case BuildConfiguration::Release:
-                currentMode = AnalyzerManager::tr("Release");
-                break;
-            default:
-                QTC_CHECK(false);
-        }
-
-        QString toolModeString;
-        switch (m_toolMode) {
-            case DebugMode:
-                toolModeString = AnalyzerManager::tr("in Debug mode");
-                break;
-            case ProfileMode:
-                toolModeString = AnalyzerManager::tr("in Profile mode");
-                break;
-            case ReleaseMode:
-                toolModeString = AnalyzerManager::tr("in Release mode");
-                break;
-            case SymbolsMode:
-                toolModeString = AnalyzerManager::tr("with debug symbols (Debug or Profile mode)");
-                break;
-            case OptimizedMode:
-                toolModeString = AnalyzerManager::tr("on optimized code (Profile or Release mode)");
-                break;
-            default:
-                QTC_CHECK(false);
-        }
-        const QString toolName = text(); // The action text is always the name of the tool
-        const QString title = AnalyzerManager::tr("Run %1 in %2 Mode?").arg(toolName).arg(currentMode);
-        const QString message = AnalyzerManager::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 %3.</p><p>"
-            "Run-time characteristics differ significantly between "
-            "optimized and non-optimized binaries. Analytical "
-            "findings for one mode may or may not be relevant for "
-            "the other.</p><p>"
-            "Running tools that need debug symbols on binaries that "
-            "don't provide any may lead to missing function names "
-            "or otherwise insufficient output.</p><p>"
-            "Do you want to continue and run the tool in %2 mode?</p></body></html>")
-                .arg(toolName).arg(currentMode).arg(toolModeString);
-        if (Utils::CheckableMessageBox::doNotAskAgainQuestion(ICore::mainWindow(),
-                title, message, ICore::settings(), QLatin1String("AnalyzerCorrectModeWarning"))
-                    != QDialogButtonBox::Yes)
-            return;
-    }
-
-    ProjectExplorerPlugin::runStartupProject(m_runMode);
-}
-
-} // namespace Analyzer

src/plugins/debugger/analyzer/ianalyzertool.h

-/****************************************************************************
-**
-** Copyright (C) 2016 The Qt Company Ltd.
-** Author: Nicolas Arnaud-Cormos, KDAB (nicolas.arnaud-cormos@kdab.com)
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of Qt Creator.
-**
-** Commercial License Usage
-** Licensees holding valid commercial Qt licenses may use this file in
-** accordance with the commercial license agreement provided with the
-** Software or, alternatively, in accordance with the terms contained in
-** a written agreement between you and The Qt Company. For licensing terms
-** and conditions see https://www.qt.io/terms-conditions. For further
-** information use the contact form at https://www.qt.io/contact-us.
-**
-** GNU General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU
-** General Public License version 3 as published by the Free Software
-** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
-** included in the packaging of this file. Please review the following
-** information to ensure the GNU General Public License requirements will
-** be met: https://www.gnu.org/licenses/gpl-3.0.html.
-**
-****************************************************************************/
-
-#ifndef IANALYZERTOOL_H
-#define IANALYZERTOOL_H
-
-#include "analyzerbase_global.h"
-#include "analyzerconstants.h"
-
-#include <coreplugin/id.h>
-#include <projectexplorer/projectexplorerconstants.h>
-
-#include <QObject>
-#include <QAction>
-
-#include <functional>
-
-namespace ProjectExplorer { class RunConfiguration; }
-
-namespace Analyzer {
-
-class AnalyzerRunControl;
-
-/**
- * The mode in which this tool should preferably be run
- *
- * Debugging tools which try to show stack traces as close as possible to what the source code
- * looks like will prefer SymbolsMode. Profiling tools which need optimized code for realistic
- * performance, but still want to show analytical output that depends on debug symbols, will prefer
- * ProfileMode.
- */
-enum ToolMode {
-    DebugMode     = 0x1,
-    ProfileMode   = 0x2,
-    ReleaseMode   = 0x4,
-    SymbolsMode   = DebugMode   | ProfileMode,
-    OptimizedMode = ProfileMode | ReleaseMode,
-    AnyMode       = DebugMode   | ProfileMode | ReleaseMode
-};
-Q_DECLARE_FLAGS(ToolModes, ToolMode)
-
-/**
- * This class represents an analyzation action, i.e. a tool that runs in a specific mode.
- *
-*/
-
-class ANALYZER_EXPORT AnalyzerAction : public QAction
-{
-    Q_OBJECT
-
-public:
-    explicit AnalyzerAction(QObject *parent = 0);