Commit 931ee338 authored by hjk's avatar hjk

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: default avatarChristian Stenger <christian.stenger@theqtcompany.com>
parent 04cbf8b8
......@@ -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>
......
......@@ -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;
}
......
......@@ -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
......
......@@ -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
{
......
......@@ -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();
......
......@@ -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 \
......
......@@ -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();
......
......@@ -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>
......
/****************************************************************************
**
** 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
/****************************************************************************
**
** 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);
public:
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 toolId() const { return m_toolId; }
void setToolId(Core::Id id) { m_toolId = 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();
/// 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; }
protected:
Core::Id m_menuGroup;
Core::Id m_actionId;
Core::Id m_toolId;
QFlags<ToolMode> m_toolMode;
Core::Id m_runMode;
WidgetCreator m_widgetCreator;
RunControlCreator m_runControlCreator;
ToolStarter m_customToolStarter;
ToolPreparer m_toolPreparer;
};
} // namespace Analyzer
#endif // IANALYZERTOOL_H
......@@ -250,8 +250,6 @@ QtcPlugin {
"analyzer/detailederrorview.h",
"analyzer/diagnosticlocation.cpp",
"analyzer/diagnosticlocation.h",
"analyzer/ianalyzertool.cpp",
"analyzer/ianalyzertool.h",
"analyzer/startremotedialog.cpp",
"analyzer/startremotedialog.h",
]
......
......@@ -34,7 +34,6 @@
#include <debugger/debuggerruncontrol.h>
#include <debugger/debuggerstartparameters.h>
#include <debugger/debuggerrunconfigurationaspect.h>
#include <debugger/analyzer/ianalyzertool.h>
#include <debugger/analyzer/analyzermanager.h>
#include <debugger/analyzer/analyzerruncontrol.h>
#include <projectexplorer/toolchain.h>
......
......@@ -40,7 +40,10 @@ const char SETTINGS[] = "Analyzer.QmlProfiler.Settings";
const char ANALYZER[] = "Analyzer";
const char TraceFileExtension[] = ".qtd";
const char QmlProfilerToolId[] = "QmlProfiler";
const char QmlProfilerTimelineDock[] = "QmlProfilerTimelineDock";
const char QmlProfilerPerspective[] = "QmlProfilerPerspective";
const char QmlProfilerLocalActionId[] = "QmlProfiler.Local";
const char QmlProfilerRemoteActionId[] = "QmlProfiler.Remote";
......
......@@ -58,38 +58,35 @@ bool QmlProfilerPlugin::initialize(const QStringList &arguments, QString *errorS
return tool->createRunControl(runConfiguration);
};
AnalyzerAction *action = 0;
QString description = QmlProfilerTool::tr(
"The QML Profiler can be used to find performance bottlenecks in "
"applications using QML.");