diff options
Diffstat (limited to 'src/plugins/analyzerbase')
18 files changed, 471 insertions, 702 deletions
diff --git a/src/plugins/analyzerbase/analyzerbase.pro b/src/plugins/analyzerbase/analyzerbase.pro index ad33056b15..e42ee34fa8 100644 --- a/src/plugins/analyzerbase/analyzerbase.pro +++ b/src/plugins/analyzerbase/analyzerbase.pro @@ -15,7 +15,6 @@ SOURCES += \ ianalyzertool.cpp \ analyzerplugin.cpp \ analyzerruncontrol.cpp \ - analyzerruncontrolfactory.cpp \ analyzermanager.cpp \ analyzersettings.cpp \ analyzeroptionspage.cpp \ @@ -30,7 +29,6 @@ HEADERS += \ analyzerconstants.h \ analyzerplugin.h \ analyzerruncontrol.h \ - analyzerruncontrolfactory.h \ analyzermanager.h \ analyzersettings.h \ analyzerstartparameters.h \ diff --git a/src/plugins/analyzerbase/analyzerconstants.h b/src/plugins/analyzerbase/analyzerconstants.h index 883f77b9cf..23f15e7b80 100644 --- a/src/plugins/analyzerbase/analyzerconstants.h +++ b/src/plugins/analyzerbase/analyzerconstants.h @@ -39,16 +39,22 @@ namespace Analyzer { -enum AnalyzerStartMode +// Special values for currently used modes. +// Their meaning is interpreted by the individual tools. +// FIXME: The plan is to remove this entirely from the +// public interface and let the tools handle that internally. + +enum StartMode { - StartLocal, - StartRemote + StartLocal = -1, + StartRemote = -2, + StartQml = -3 }; namespace Constants { // modes and their priorities -const char * const MODE_ANALYZE = "Analyzer.Mode.Analyze"; +const char * const MODE_ANALYZE = "Mode.Analyze"; const int P_MODE_ANALYZE = 76; // context @@ -61,6 +67,10 @@ const char * const START = "Analyzer.Start"; const char * const STARTREMOTE = "Analyzer.StartRemote"; const char * const STOP = "Analyzer.Stop"; +const char * const G_ANALYZER_CONTROL = "Menu.Group.Analyzer.Control"; +const char * const G_ANALYZER_TOOLS = "Menu.Group.Analyzer.Tools"; +const char * const G_ANALYZER_REMOTE_TOOLS = "Menu.Group.Analyzer.RemoteTools"; + // options dialog const char * const ANALYZER_SETTINGS_CATEGORY = "T.Analyzer"; const char * const ANALYZER_SETTINGS_TR_CATEGORY = @@ -76,9 +86,6 @@ const char * const ANALYZER_CONTROL_STOP_ICON = const char * const ANALYZERTASK_ID = "Analyzer.TaskId"; -// private -const char * const ANALYZER_DUMMYWIDGET_ID = "Analyzer.DummyWidget"; - } // namespace Constants } // namespace Analyzer diff --git a/src/plugins/analyzerbase/analyzermanager.cpp b/src/plugins/analyzerbase/analyzermanager.cpp index 8553afab86..cdf4e5d167 100644 --- a/src/plugins/analyzerbase/analyzermanager.cpp +++ b/src/plugins/analyzerbase/analyzermanager.cpp @@ -37,12 +37,10 @@ #include "analyzerconstants.h" #include "analyzerplugin.h" #include "analyzerruncontrol.h" -#include "analyzerruncontrolfactory.h" #include "analyzeroptionspage.h" #include "analyzerstartparameters.h" #include "analyzerutils.h" #include "ianalyzertool.h" -#include "startremotedialog.h" #include <coreplugin/coreconstants.h> #include <coreplugin/findplaceholder.h> @@ -76,8 +74,6 @@ #include <utils/statuslabel.h> #include <utils/ssh/sshconnection.h> -#include <cmakeprojectmanager/cmakeprojectconstants.h> - #include <QtCore/QVariant> #include <QtCore/QDebug> #include <QtGui/QHBoxLayout> @@ -98,18 +94,20 @@ #include <QtGui/QPushButton> using namespace Core; -using namespace Analyzer; using namespace Analyzer::Internal; +using namespace ProjectExplorer; namespace Analyzer { namespace Internal { -const char lastActiveToolC[] = "Analyzer.Plugin.LastActiveTool"; -const char G_ANALYZER_TOOLS[] = "Menu.Group.Analyzer.Tools"; -const char G_ANALYZER_REMOTE_TOOLS[] = "Menu.Group.Analyzer.RemoteTools"; +const char LAST_ACTIVE_TOOL[] = "Analyzer.Plugin.LastActiveTool"; const char INITIAL_DOCK_AREA[] = "initial_dock_area"; -// AnalyzerMode //////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////// +// +// AnalyzerMode +// +//////////////////////////////////////////////////////////////////// class AnalyzerMode : public Core::IMode { @@ -142,7 +140,6 @@ public: }; } // namespace Internal -} // namespace Analyzer //////////////////////////////////////////////////////////////////// // @@ -150,7 +147,7 @@ public: // //////////////////////////////////////////////////////////////////// -class AnalyzerManager::AnalyzerManagerPrivate : public QObject +class AnalyzerManagerPrivate : public QObject { Q_OBJECT @@ -169,60 +166,52 @@ public: void delayedInit(); void setupActions(); - QWidget *createModeContents(); - QWidget *createModeMainWindow(); + void createModeMainWindow(); bool showPromptDialog(const QString &title, const QString &text, const QString &stopButtonText, const QString &cancelButtonText) const; - void addDock(Qt::DockWidgetArea area, QDockWidget *dockWidget); - void startAction(int tool); - void addTool(IAnalyzerTool *tool); - void addToolAction(IAnalyzerTool *tool, bool local); - int indexOf(IAnalyzerTool *tool) const; - int indexOf(QAction *action) const; - IAnalyzerTool *toolAt(int idx) const; + void activateDock(Qt::DockWidgetArea area, QDockWidget *dockWidget); + void deactivateDock(QDockWidget *dockWidget); + void addTool(IAnalyzerTool *tool, const StartModes &modes); + void selectSavedTool(); + void selectTool(IAnalyzerTool *tool, StartMode mode); + void handleToolStarted(); + void handleToolFinished(); + void saveToolSettings(IAnalyzerTool *tool, StartMode mode); + void loadToolSettings(IAnalyzerTool *tool); + QAction *actionFromToolAndMode(IAnalyzerTool *tool, StartMode mode); + + // Convenience. + void startLocalTool(IAnalyzerTool *tool, StartMode mode); public slots: - void startAction() { startAction(m_currentIndex); } - void startToolRemote(); - void stopTool(); - - void handleToolFinished(); - void selectAction(); - void selectAction(int); - void selectAction(QAction *); + void startTool(); + void selectToolboxAction(int); + void selectMenuAction(); void modeChanged(Core::IMode *mode); - void runControlCreated(Analyzer::AnalyzerRunControl *); void resetLayout(); - void saveToolSettings(Analyzer::IAnalyzerTool *tool); - void loadToolSettings(Analyzer::IAnalyzerTool *tool); void updateRunActions(); - void registerRunControlFactory(ProjectExplorer::IRunControlFactory *factory); public: - struct ToolData { - IAnalyzerTool *tool; - QAction *action; - bool local; - }; - AnalyzerManager *q; AnalyzerMode *m_mode; - AnalyzerRunControlFactory *m_runControlFactory; - ProjectExplorer::RunControl *m_currentRunControl; + bool m_isRunning; Utils::FancyMainWindow *m_mainWindow; - int m_currentIndex; - QList<ToolData> m_actions; + 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; QAction *m_stopAction; ActionContainer *m_menu; QComboBox *m_toolBox; - QStackedWidget *m_controlsWidget; - ActionContainer *m_viewsMenu; + QStackedWidget *m_controlsStackWidget; Utils::StatusLabel *m_statusLabel; typedef QMap<IAnalyzerTool *, FancyMainWindowSettings> MainWindowSettingsMap; - QMap<IAnalyzerTool *, QList<QDockWidget *> > m_toolWidgets; + QHash<IAnalyzerTool *, QList<QDockWidget *> > m_toolWidgets; + QHash<IAnalyzerTool *, QWidget *> m_controlsWidgetFromTool; MainWindowSettingsMap m_defaultSettings; // list of dock widgets to prevent memory leak @@ -230,42 +219,35 @@ public: QList<DockPtr> m_dockWidgets; bool m_restartOnStop; - bool m_initialized; }; -AnalyzerManager::AnalyzerManagerPrivate::AnalyzerManagerPrivate(AnalyzerManager *qq): +AnalyzerManagerPrivate::AnalyzerManagerPrivate(AnalyzerManager *qq): q(qq), m_mode(0), - m_runControlFactory(0), - m_currentRunControl(0), + m_isRunning(false), m_mainWindow(0), - m_currentIndex(-1), + m_currentTool(0), + m_currentMode(), m_startAction(0), m_stopAction(0), m_menu(0), m_toolBox(new QComboBox), - m_controlsWidget(new QStackedWidget), - m_viewsMenu(0), + m_controlsStackWidget(new QStackedWidget), m_statusLabel(new Utils::StatusLabel), - m_restartOnStop(false), - m_initialized(false) + m_restartOnStop(false) { m_toolBox->setObjectName(QLatin1String("AnalyzerManagerToolBox")); - connect(m_toolBox, SIGNAL(currentIndexChanged(int)), SLOT(selectAction(int))); - - m_runControlFactory = new AnalyzerRunControlFactory(); - registerRunControlFactory(m_runControlFactory); + connect(m_toolBox, SIGNAL(activated(int)), SLOT(selectToolboxAction(int))); setupActions(); connect(ModeManager::instance(), SIGNAL(currentModeChanged(Core::IMode*)), this, SLOT(modeChanged(Core::IMode*))); - ProjectExplorer::ProjectExplorerPlugin *pe = - ProjectExplorer::ProjectExplorerPlugin::instance(); + ProjectExplorerPlugin *pe = ProjectExplorerPlugin::instance(); connect(pe, SIGNAL(updateRunActions()), SLOT(updateRunActions())); } -AnalyzerManager::AnalyzerManagerPrivate::~AnalyzerManagerPrivate() +AnalyzerManagerPrivate::~AnalyzerManagerPrivate() { // as we have to setParent(0) on dock widget that are not selected, // we keep track of all and make sure we don't leak any @@ -275,15 +257,7 @@ AnalyzerManager::AnalyzerManagerPrivate::~AnalyzerManagerPrivate() } } -void AnalyzerManager::AnalyzerManagerPrivate::registerRunControlFactory - (ProjectExplorer::IRunControlFactory *factory) -{ - AnalyzerPlugin::instance()->addAutoReleasedObject(factory); - connect(factory, SIGNAL(runControlCreated(Analyzer::AnalyzerRunControl*)), - this, SLOT(runControlCreated(Analyzer::AnalyzerRunControl*))); -} - -void AnalyzerManager::AnalyzerManagerPrivate::setupActions() +void AnalyzerManagerPrivate::setupActions() { Core::ICore *core = Core::ICore::instance(); Core::ActionManager *am = core->actionManager(); @@ -295,8 +269,9 @@ void AnalyzerManager::AnalyzerManagerPrivate::setupActions() m_menu->menu()->setTitle(tr("&Analyze")); m_menu->menu()->setEnabled(true); - m_menu->appendGroup(G_ANALYZER_TOOLS); - m_menu->appendGroup(G_ANALYZER_REMOTE_TOOLS); + m_menu->appendGroup(Constants::G_ANALYZER_CONTROL); + m_menu->appendGroup(Constants::G_ANALYZER_TOOLS); + m_menu->appendGroup(Constants::G_ANALYZER_REMOTE_TOOLS); Core::ActionContainer *menubar = am->actionContainer(Core::Constants::MENU_BAR); @@ -307,52 +282,52 @@ void AnalyzerManager::AnalyzerManagerPrivate::setupActions() m_startAction = new QAction(tr("Start"), m_menu); m_startAction->setIcon(QIcon(Constants::ANALYZER_CONTROL_START_ICON)); command = am->registerAction(m_startAction, Constants::START, globalcontext); - connect(m_startAction, SIGNAL(triggered()), this, SLOT(startAction())); + connect(m_startAction, SIGNAL(triggered()), this, SLOT(startTool())); m_stopAction = new QAction(tr("Stop"), m_menu); m_stopAction->setEnabled(false); m_stopAction->setIcon(QIcon(Constants::ANALYZER_CONTROL_STOP_ICON)); command = am->registerAction(m_stopAction, Constants::STOP, globalcontext); - connect(m_stopAction, SIGNAL(triggered()), this, SLOT(stopTool())); + m_menu->addAction(command, Constants::G_ANALYZER_CONTROL); - QAction *separatorAction = new QAction(m_menu); - separatorAction->setSeparator(true); - command = am->registerAction(separatorAction, - "Menu.Action.Analyzer.Tools.Separator", globalcontext); - m_menu->addAction(command, G_ANALYZER_REMOTE_TOOLS); + QAction *separatorAction1 = new QAction(m_menu); + separatorAction1->setSeparator(true); + command = am->registerAction(separatorAction1, + "Menu.Action.Analyzer.Tools.Separator1", globalcontext); + m_menu->addAction(command, Constants::G_ANALYZER_TOOLS); - m_viewsMenu = am->actionContainer(Core::Id(Core::Constants::M_WINDOW_VIEWS)); + QAction *separatorAction2 = new QAction(m_menu); + separatorAction2->setSeparator(true); + command = am->registerAction(separatorAction2, + "Menu.Action.Analyzer.Tools.Separator2", globalcontext); + m_menu->addAction(command, Constants::G_ANALYZER_REMOTE_TOOLS); } -void AnalyzerManager::AnalyzerManagerPrivate::delayedInit() +void AnalyzerManagerPrivate::delayedInit() { - if (m_initialized) + if (m_mode) return; m_mode = new AnalyzerMode(q); - m_mode->setWidget(createModeContents()); - AnalyzerPlugin::instance()->addAutoReleasedObject(m_mode); - - m_initialized = true; -} + createModeMainWindow(); -QWidget *AnalyzerManager::AnalyzerManagerPrivate::createModeContents() -{ - // right-side window with editor, output etc. + // Right-side window with editor, output etc. MiniSplitter *mainWindowSplitter = new MiniSplitter; - mainWindowSplitter->addWidget(createModeMainWindow()); + mainWindowSplitter->addWidget(m_mainWindow); mainWindowSplitter->addWidget(new OutputPanePlaceHolder(m_mode, mainWindowSplitter)); mainWindowSplitter->setStretchFactor(0, 10); mainWindowSplitter->setStretchFactor(1, 0); mainWindowSplitter->setOrientation(Qt::Vertical); - // navigation + right-side window + // Navigation + right-side window. MiniSplitter *splitter = new MiniSplitter; splitter->addWidget(new NavigationWidgetPlaceHolder(m_mode)); splitter->addWidget(mainWindowSplitter); splitter->setStretchFactor(0, 0); splitter->setStretchFactor(1, 1); - return splitter; + m_mode->setWidget(splitter); + + AnalyzerPlugin::instance()->addAutoReleasedObject(m_mode); } static QToolButton *toolButton(QAction *action) @@ -362,14 +337,13 @@ static QToolButton *toolButton(QAction *action) return button; } -QWidget *AnalyzerManager::AnalyzerManagerPrivate::createModeMainWindow() +void AnalyzerManagerPrivate::createModeMainWindow() { m_mainWindow = new Utils::FancyMainWindow(); m_mainWindow->setObjectName(QLatin1String("AnalyzerManagerMainWindow")); m_mainWindow->setDocumentMode(true); m_mainWindow->setDockNestingEnabled(true); - m_mainWindow->setDockActionsVisible(ModeManager::instance()->currentMode()->id() == - Constants::MODE_ANALYZE); + m_mainWindow->setDockActionsVisible(false); connect(m_mainWindow, SIGNAL(resetLayout()), SLOT(resetLayout())); QBoxLayout *editorHolderLayout = new QVBoxLayout; @@ -396,7 +370,7 @@ QWidget *AnalyzerManager::AnalyzerManagerPrivate::createModeMainWindow() analyzeToolBarLayout->addWidget(toolButton(m_stopAction)); analyzeToolBarLayout->addWidget(new Utils::StyledSeparator); analyzeToolBarLayout->addWidget(m_toolBox); - analyzeToolBarLayout->addWidget(m_controlsWidget); + analyzeToolBarLayout->addWidget(m_controlsStackWidget); analyzeToolBarLayout->addWidget(m_statusLabel); analyzeToolBarLayout->addStretch(); @@ -421,12 +395,9 @@ QWidget *AnalyzerManager::AnalyzerManagerPrivate::createModeMainWindow() centralLayout->addWidget(documentAndRightPane); centralLayout->setStretch(0, 1); centralLayout->setStretch(1, 0); - - return m_mainWindow; } -void AnalyzerManager::AnalyzerManagerPrivate::addDock(Qt::DockWidgetArea area, - QDockWidget *dockWidget) +void AnalyzerManagerPrivate::activateDock(Qt::DockWidgetArea area, QDockWidget *dockWidget) { dockWidget->setParent(m_mainWindow); m_mainWindow->addDockWidget(area, dockWidget); @@ -436,32 +407,44 @@ void AnalyzerManager::AnalyzerManagerPrivate::addDock(Qt::DockWidgetArea area, 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); - m_viewsMenu->addAction(cmd); + + ActionContainer *viewsMenu = + am->actionContainer(Core::Id(Core::Constants::M_WINDOW_VIEWS)); + viewsMenu->addAction(cmd); +} + +void AnalyzerManagerPrivate::deactivateDock(QDockWidget *dockWidget) +{ + ActionManager *am = ICore::instance()->actionManager(); + QAction *toggleViewAction = dockWidget->toggleViewAction(); + am->unregisterAction(toggleViewAction, QString("Analyzer." + dockWidget->objectName())); + m_mainWindow->removeDockWidget(dockWidget); + dockWidget->hide(); + // Prevent saveState storing the data of the wrong children. + dockWidget->setParent(0); } bool buildTypeAccepted(IAnalyzerTool::ToolMode toolMode, - ProjectExplorer::BuildConfiguration::BuildType buildType) + BuildConfiguration::BuildType buildType) { if (toolMode == IAnalyzerTool::AnyMode) return true; - if (buildType == ProjectExplorer::BuildConfiguration::Unknown) + if (buildType == BuildConfiguration::Unknown) return true; - if (buildType == ProjectExplorer::BuildConfiguration::Debug + if (buildType == BuildConfiguration::Debug && toolMode == IAnalyzerTool::DebugMode) return true; - if (buildType == ProjectExplorer::BuildConfiguration::Release + if (buildType == BuildConfiguration::Release && toolMode == IAnalyzerTool::ReleaseMode) return true; return false; } -bool AnalyzerManager::AnalyzerManagerPrivate::showPromptDialog(const QString &title, - const QString &text, - const QString &stopButtonText, - const QString &cancelButtonText) const +bool AnalyzerManagerPrivate::showPromptDialog(const QString &title, const QString &text, + const QString &stopButtonText, const QString &cancelButtonText) const { Utils::CheckableMessageBox messageBox(Core::ICore::instance()->mainWindow()); messageBox.setWindowTitle(title); @@ -477,52 +460,27 @@ bool AnalyzerManager::AnalyzerManagerPrivate::showPromptDialog(const QString &ti return messageBox.clickedStandardButton() == QDialogButtonBox::Yes; } -void AnalyzerManager::AnalyzerManagerPrivate::startToolRemote() -{ - StartRemoteDialog dlg; - if (dlg.exec() != QDialog::Accepted) - return; - - AnalyzerStartParameters sp; - sp.connParams = dlg.sshParams(); - sp.debuggee = dlg.executable(); - sp.debuggeeArgs = dlg.arguments(); - sp.displayName = dlg.executable(); - sp.startMode = StartRemote; - sp.workingDirectory = dlg.workingDirectory(); - - AnalyzerRunControl *runControl = m_runControlFactory->create(sp, 0); - - QTC_ASSERT(runControl, return); - ProjectExplorer::ProjectExplorerPlugin::instance() - ->startRunControl(runControl, Constants::MODE_ANALYZE); -} - -void AnalyzerManager::AnalyzerManagerPrivate::startAction(int index) +void AnalyzerManagerPrivate::startLocalTool(IAnalyzerTool *tool, StartMode) { + int index = m_tools.indexOf(tool); QTC_ASSERT(index >= 0, return); - QTC_ASSERT(index < m_actions.size(), return); - QTC_ASSERT(index == m_currentIndex, return); + QTC_ASSERT(index < m_tools.size(), return); + QTC_ASSERT(tool == m_currentTool, return); - if (!m_actions.at(index).local) { - startToolRemote(); - return; - } - - // make sure mode is shown + // Make sure mode is shown. q->showMode(); - ProjectExplorer::ProjectExplorerPlugin *pe = ProjectExplorer::ProjectExplorerPlugin::instance(); + ProjectExplorerPlugin *pe = ProjectExplorerPlugin::instance(); // ### not sure if we're supposed to check if the RunConFiguration isEnabled - ProjectExplorer::Project *pro = pe->startupProject(); - const ProjectExplorer::RunConfiguration *runConfig = 0; - ProjectExplorer::BuildConfiguration::BuildType buildType = ProjectExplorer::BuildConfiguration::Unknown; + Project *pro = pe->startupProject(); + const RunConfiguration *runConfig = 0; + BuildConfiguration::BuildType buildType = BuildConfiguration::Unknown; if (pro) { - if (const ProjectExplorer::Target *target = pro->activeTarget()) { + if (const Target *target = pro->activeTarget()) { runConfig = target->activeRunConfiguration(); // Build configuration is 0 for QML projects. - if (const ProjectExplorer::BuildConfiguration *buildConfig = target->activeBuildConfiguration()) + if (const BuildConfiguration *buildConfig = target->activeBuildConfiguration()) buildType = buildConfig->buildType(); } } @@ -530,12 +488,12 @@ void AnalyzerManager::AnalyzerManagerPrivate::startAction(int index) return; // Check if there already is an analyzer run. - if (m_currentRunControl) { + if (m_isRunning) { // ask if user wants to restart the analyzer 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) @@ -543,37 +501,47 @@ void AnalyzerManager::AnalyzerManagerPrivate::startAction(int index) // user selected to stop the active run. stop it, activate restart on stop m_restartOnStop = true; - stopTool(); + q->stopTool(); return; } - IAnalyzerTool *tool = toolAt(index); - 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"); + const QString toolName = tool->displayName(); + const QString currentMode = + buildType == BuildConfiguration::Debug ? tr("Debug") : tr("Release"); QSettings *settings = Core::ICore::instance()->settings(); - const QString configKey = QLatin1String(Constants::MODE_ANALYZE) + QLatin1Char('/') + QLatin1String("AnalyzeCorrectMode"); + const QString configKey = QLatin1String("Analyzer.AnalyzeCorrectMode"); int ret; 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); + 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(toolModeString); const QString checkBoxText = tr("&Do not ask again"); bool checkBoxSetting = false; const QDialogButtonBox::StandardButton button = - Utils::CheckableMessageBox::question(Core::ICore::instance()->mainWindow(), title, message, checkBoxText, - &checkBoxSetting, QDialogButtonBox::Yes|QDialogButtonBox::Cancel, - QDialogButtonBox::Cancel); + Utils::CheckableMessageBox::question(Core::ICore::instance()->mainWindow(), + title, message, checkBoxText, + &checkBoxSetting, QDialogButtonBox::Yes|QDialogButtonBox::Cancel, + QDialogButtonBox::Cancel); ret = button == QDialogButtonBox::Yes ? QDialog::Accepted : QDialog::Rejected; if (checkBoxSetting && ret == QDialog::Accepted) @@ -583,173 +551,154 @@ void AnalyzerManager::AnalyzerManagerPrivate::startAction(int index) return; } - pe->runProject(pro, Constants::MODE_ANALYZE); - + m_isRunning = true; + pe->runProject(pro, tool->id()); updateRunActions(); } - -void AnalyzerManager::AnalyzerManagerPrivate::stopTool() +void AnalyzerManagerPrivate::startTool() { - 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(); - // else: wait for the finished() signal to trigger handleToolFinished() + m_currentTool->startTool(m_currentMode); } -void AnalyzerManager::AnalyzerManagerPrivate::modeChanged(IMode *mode) +void AnalyzerManagerPrivate::modeChanged(IMode *mode) { - if (!m_mainWindow) - return; - const bool makeVisible = mode->id() == Constants::MODE_ANALYZE; - if (!makeVisible) - return; - m_mainWindow->setDockActionsVisible(makeVisible); -} - -void AnalyzerManager::AnalyzerManagerPrivate::selectAction(int idx) -{ - QTC_ASSERT(idx >= 0, return); - if (m_currentIndex == idx) - return; - - if (m_currentIndex != -1) { - IAnalyzerTool *oldTool = toolAt(m_currentIndex); - saveToolSettings(oldTool); - - ActionManager *am = ICore::instance()->actionManager(); - - foreach (QDockWidget *widget, m_toolWidgets.value(oldTool)) { - QAction *toggleViewAction = widget->toggleViewAction(); - am->unregisterAction(toggleViewAction, - QString("Analyzer." + widget->objectName())); - m_mainWindow->removeDockWidget(widget); - ///NOTE: QMainWindow (and FancyMainWindow) just look at - /// @c findChildren<QDockWidget*>() - ///if we don't do this, all kind of havoc might happen, including: - ///- improper saveState/restoreState - ///- improper list of qdockwidgets in popup menu - ///- ... - widget->setParent(0); - } - oldTool->toolDeselected(); - } - - m_currentIndex = idx; - - m_toolBox->setCurrentIndex(idx); - m_controlsWidget->setCurrentIndex(idx); - - IAnalyzerTool *newTool = toolAt(idx); - - const bool firstTime = !m_defaultSettings.contains(newTool); - if (firstTime) { - newTool->initializeDockWidgets(); - m_defaultSettings.insert(newTool, m_mainWindow->saveSettings()); + if (mode && mode == m_mode) { + m_mainWindow->setDockActionsVisible(true); + static bool firstTime = true; + if (firstTime) + selectSavedTool(); + firstTime = false; + updateRunActions(); } else { - foreach (QDockWidget *widget, m_toolWidgets.value(newTool)) - addDock(Qt::DockWidgetArea(widget->property(INITIAL_DOCK_AREA).toInt()), widget); + m_mainWindow->setDockActionsVisible(false); } - - loadToolSettings(newTool); - updateRunActions(); } -void AnalyzerManager::AnalyzerManagerPrivate::selectAction() +QAction *AnalyzerManagerPrivate::actionFromToolAndMode(IAnalyzerTool *tool, StartMode mode) { - selectAction(qobject_cast<QAction *>(sender())); + foreach (QAction *action, m_actions) + if (m_toolFromAction.value(action) == tool && m_modeFromAction[action] == mode) + return action; + QTC_ASSERT(false, /**/); + return 0; } -void AnalyzerManager::AnalyzerManagerPrivate::selectAction(QAction *action) +void AnalyzerManagerPrivate::selectSavedTool() { - selectAction(indexOf(action)); + 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.value(action); + StartMode mode = m_modeFromAction.value(action); + if (tool->actionId(mode) == lastActiveAction) { + selectTool(tool, mode); + break; + } + } } -int AnalyzerManager::AnalyzerManagerPrivate::indexOf(QAction *action) const +void AnalyzerManagerPrivate::selectMenuAction() { - for (int i = 0; i != m_actions.size(); ++i) - if (m_actions.at(i).action == action) - return i; - return -1; + QAction *action = qobject_cast<QAction *>(sender()); + QTC_ASSERT(action, return); + IAnalyzerTool *tool = m_toolFromAction.value(action); + StartMode mode = m_modeFromAction.value(action); + selectTool(tool, mode); + tool->startTool(mode); } -int AnalyzerManager::AnalyzerManagerPrivate::indexOf(IAnalyzerTool *tool) const +void AnalyzerManagerPrivate::selectToolboxAction(int index) { - for (int i = 0; i != m_actions.size(); ++i) - if (toolAt(i) == tool) - return i; - return -1; + QAction *action = m_actions[index]; + selectTool(m_toolFromAction.value(action), m_modeFromAction.value(action)); } -IAnalyzerTool *AnalyzerManager::AnalyzerManagerPrivate::toolAt(int idx) const +void AnalyzerManagerPrivate::selectTool(IAnalyzerTool *tool, StartMode mode) { - QTC_ASSERT(idx >= 0, return 0); - QTC_ASSERT(idx < m_actions.size(), return 0); - return m_actions.at(idx).tool; -} + if (m_currentTool == tool && m_currentMode == mode) + return; -void AnalyzerManager::AnalyzerManagerPrivate::addToolAction(IAnalyzerTool *tool, bool local) -{ - ActionManager *am = Core::ICore::instance()->actionManager(); + QAction *action = actionFromToolAndMode(tool, mode); + const int actionIndex = m_actions.indexOf(action); + QTC_ASSERT(actionIndex >= 0, return); - QString actionId = QString("Action.Analyzer.Tools.%1").arg(m_actions.size()); - QString displayName = tool->displayName() + (local ? QString() : tr(" (Remote)")); - QAction *action = new QAction(displayName, 0); + // Clean up old tool. + if (m_currentTool) { + saveToolSettings(m_currentTool, m_currentMode); + foreach (QDockWidget *widget, m_toolWidgets.value(m_currentTool)) + deactivateDock(widget); + m_currentTool->toolDeselected(); + } - ToolData data; - data.tool = tool; - data.local = local; - data.action = action; - m_actions.append(data); + // Now change the tool. + m_currentTool = tool; + m_currentMode = mode; + + if (!m_defaultSettings.contains(tool)) { + QWidget *widget = tool->createWidgets(); + QTC_ASSERT(widget, /**/); + m_defaultSettings.insert(tool, m_mainWindow->saveSettings()); + QTC_ASSERT(!m_controlsWidgetFromTool.contains(tool), /**/); + m_controlsWidgetFromTool[tool] = widget; + m_controlsStackWidget->addWidget(widget); + } + foreach (QDockWidget *widget, m_toolWidgets.value(tool)) + activateDock(Qt::DockWidgetArea(widget->property(INITIAL_DOCK_AREA).toInt()), widget); - Core::Command *command = am->registerAction(action, actionId, - Core::Context(Core::Constants::C_GLOBAL)); - m_menu->addAction(command, local ? G_ANALYZER_TOOLS : G_ANALYZER_REMOTE_TOOLS); - connect(action, SIGNAL(triggered()), SLOT(selectAction())); + loadToolSettings(tool); - const bool blocked = m_toolBox->blockSignals(true); // Do not make current. - m_toolBox->addItem(displayName); - m_toolBox->blockSignals(blocked); - m_toolBox->setEnabled(true); + QTC_ASSERT(m_controlsWidgetFromTool.contains(tool), /**/); + m_controlsStackWidget->setCurrentWidget(m_controlsWidgetFromTool.value(tool)); + m_toolBox->setCurrentIndex(actionIndex); + + updateRunActions(); } -void AnalyzerManager::AnalyzerManagerPrivate::addTool(IAnalyzerTool *tool) +void AnalyzerManagerPrivate::addTool(IAnalyzerTool *tool, const StartModes &modes) { - delayedInit(); // be sure that there is a valid IMode instance + delayedInit(); // Make sure that there is a valid IMode instance. + + const bool blocked = m_toolBox->blockSignals(true); // Do not make current. + ActionManager *am = Core::ICore::instance()->actionManager(); + foreach (StartMode mode, modes) { + QString actionName = tool->actionName(mode); + QString menuGroup = tool->menuGroup(mode); + QString actionId = tool->actionId(mode); + QAction *action = new QAction(actionName, 0); + 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(selectMenuAction())); + } m_tools.append(tool); - if (tool->canRunLocally()) - addToolAction(tool, true); - if (tool->canRunRemotely()) - addToolAction(tool, false); - // Populate controls widget. - QWidget *controlWidget = tool->createControlWidget(); // might be 0 - m_controlsWidget->addWidget(controlWidget - ? controlWidget : AnalyzerUtils::createDummyWidget()); - tool->initialize(); + m_toolBox->setEnabled(true); } -void AnalyzerManager::AnalyzerManagerPrivate::runControlCreated(AnalyzerRunControl *rc) +void AnalyzerManagerPrivate::handleToolStarted() { - QTC_ASSERT(!m_currentRunControl, /**/); - m_currentRunControl = rc; - connect(rc, SIGNAL(finished()), this, SLOT(handleToolFinished())); + m_isRunning = true; // FIXME: Make less global. + updateRunActions(); } -void AnalyzerManager::AnalyzerManagerPrivate::handleToolFinished() +void AnalyzerManagerPrivate::handleToolFinished() { - m_currentRunControl = 0; + m_isRunning = false; updateRunActions(); if (m_restartOnStop) { - startAction(m_currentIndex); + m_currentTool->startTool(m_currentMode); m_restartOnStop = false; } } -void AnalyzerManager::AnalyzerManagerPrivate::loadToolSettings(IAnalyzerTool *tool) +void AnalyzerManagerPrivate::loadToolSettings(IAnalyzerTool *tool) { QTC_ASSERT(m_mainWindow, return); QSettings *settings = Core::ICore::instance()->settings(); @@ -759,7 +708,7 @@ void AnalyzerManager::AnalyzerManagerPrivate::loadToolSettings(IAnalyzerTool *to settings->endGroup(); } -void AnalyzerManager::AnalyzerManagerPrivate::saveToolSettings(IAnalyzerTool *tool) +void AnalyzerManagerPrivate::saveToolSettings(IAnalyzerTool *tool, StartMode mode) { if (!tool) return; // no active tool, do nothing @@ -770,31 +719,38 @@ void AnalyzerManager::AnalyzerManagerPrivate::saveToolSettings(IAnalyzerTool *to 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 AnalyzerManager::AnalyzerManagerPrivate::updateRunActions() +void AnalyzerManagerPrivate::updateRunActions() { - ProjectExplorer::ProjectExplorerPlugin *pe = - ProjectExplorer::ProjectExplorerPlugin::instance(); - ProjectExplorer::Project *project = pe->startupProject(); + static bool previousRunning = true; + static IAnalyzerTool *previousTool = 0; + if (previousRunning == m_isRunning && previousTool == m_currentTool) + return; + previousTool = m_currentTool; + previousRunning = m_isRunning; + + ProjectExplorerPlugin *pe = ProjectExplorerPlugin::instance(); + Project *project = pe->startupProject(); - bool startEnabled = !m_currentRunControl - && pe->canRun(project, Constants::MODE_ANALYZE) - && m_currentIndex >= 0; + bool startEnabled = !m_isRunning + && m_currentTool && pe->canRun(project, m_currentTool->id()); QString disabledReason; - if (m_currentRunControl) + if (m_isRunning) disabledReason = tr("An analysis is still in progress."); - else if (m_currentIndex == -1) + else if (!m_currentTool) disabledReason = tr("No analyzer tool selected."); else - disabledReason = pe->cannotRunReason(project, Constants::MODE_ANALYZE); + disabledReason = pe->cannotRunReason(project, m_currentTool->id()); m_startAction->setEnabled(startEnabled); m_startAction->setToolTip(disabledReason); - m_toolBox->setEnabled(!m_currentRunControl); - m_stopAction->setEnabled(m_currentRunControl); + m_toolBox->setEnabled(!m_isRunning); + m_stopAction->setEnabled(m_isRunning); + foreach (QAction *action, m_actions) + action->setEnabled(!m_isRunning); } //////////////////////////////////////////////////////////////////// @@ -822,85 +778,57 @@ 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(); - int lastAction = 0; - - foreach (IAnalyzerTool *tool, d->m_tools) { + foreach (IAnalyzerTool *tool, d->m_tools) tool->extensionsInitialized(); - if (tool->id() == lastActiveToolId) - lastAction = d->indexOf(tool); - } - - d->selectAction(lastAction); } void AnalyzerManager::shutdown() { - d->saveToolSettings(d->m_actions[d->m_currentIndex].tool); + d->saveToolSettings(d->m_currentTool, d->m_currentMode); } -AnalyzerManager *AnalyzerManager::instance() +void AnalyzerManager::addTool(IAnalyzerTool *tool, const StartModes &modes) { - return m_instance; -} - -void AnalyzerManager::registerRunControlFactory(ProjectExplorer::IRunControlFactory *factory) -{ - d->registerRunControlFactory(factory); -} - -void AnalyzerManager::addTool(IAnalyzerTool *tool) -{ - d->addTool(tool); + m_instance->d->addTool(tool, modes); } QDockWidget *AnalyzerManager::createDockWidget(IAnalyzerTool *tool, const QString &title, QWidget *widget, Qt::DockWidgetArea area) { - QTC_ASSERT(!widget->objectName().isEmpty(), return 0;); - + QTC_ASSERT(!widget->objectName().isEmpty(), return 0); + AnalyzerManagerPrivate *d = m_instance->d; QDockWidget *dockWidget = d->m_mainWindow->addDockForWidget(widget); dockWidget->setProperty(INITIAL_DOCK_AREA, int(area)); d->m_dockWidgets.append(AnalyzerManagerPrivate::DockPtr(dockWidget)); dockWidget->setWindowTitle(title); d->m_toolWidgets[tool].push_back(dockWidget); - d->addDock(area, dockWidget); return dockWidget; } -IAnalyzerEngine *AnalyzerManager::createEngine(const AnalyzerStartParameters &sp, - ProjectExplorer::RunConfiguration *runConfiguration) +void AnalyzerManager::selectTool(IAnalyzerTool *tool, StartMode mode) { - IAnalyzerTool *tool = d->toolAt(d->m_currentIndex); - QTC_ASSERT(tool, return 0); - return tool->createEngine(sp, runConfiguration); + m_instance->d->selectTool(tool, mode); } -void AnalyzerManager::selectTool(IAnalyzerTool *tool) +void AnalyzerManager::startTool(IAnalyzerTool *tool, StartMode mode) { - d->selectAction(d->indexOf(tool)); + QTC_ASSERT(tool == m_instance->d->m_currentTool, return); + tool->startTool(mode); } -void AnalyzerManager::startTool(IAnalyzerTool *tool) +Utils::FancyMainWindow *AnalyzerManager::mainWindow() { - d->startAction(d->indexOf(tool)); + return m_instance->d->m_mainWindow; } -Utils::FancyMainWindow *AnalyzerManager::mainWindow() const +void AnalyzerManagerPrivate::resetLayout() { - return d->m_mainWindow; -} - -void AnalyzerManager::AnalyzerManagerPrivate::resetLayout() -{ - m_mainWindow->restoreSettings(m_defaultSettings.value(toolAt(m_currentIndex))); + m_mainWindow->restoreSettings(m_defaultSettings.value(m_currentTool)); } void AnalyzerManager::showStatusMessage(const QString &message, int timeoutMS) { - d->m_statusLabel->showStatusMessage(message, timeoutMS); + m_instance->d->m_statusLabel->showStatusMessage(message, timeoutMS); } void AnalyzerManager::showPermanentStatusMessage(const QString &message) @@ -922,13 +850,44 @@ QString AnalyzerManager::msgToolFinished(const QString &name, int issuesFound) void AnalyzerManager::showMode() { - if (d->m_mode) - ModeManager::instance()->activateMode(d->m_mode->id()); + if (m_instance->d->m_mode) + ModeManager::instance()->activateMode(m_instance->d->m_mode->id()); } void AnalyzerManager::stopTool() { - d->stopTool(); + stopAction()->trigger(); } +void AnalyzerManager::startLocalTool(IAnalyzerTool *tool, StartMode mode) +{ + m_instance->d->startLocalTool(tool, mode); +} + +QAction *AnalyzerManager::stopAction() +{ + return m_instance->d->m_stopAction; +} + +void AnalyzerManager::handleToolStarted() +{ + m_instance->d->handleToolStarted(); +} + +void AnalyzerManager::handleToolFinished() +{ + m_instance->d->handleToolFinished(); +} + +IAnalyzerTool *AnalyzerManager::toolFromId(const QByteArray &id) +{ + foreach (IAnalyzerTool *tool, m_instance->d->m_tools) + if (id.startsWith(tool->id())) + return tool; + QTC_ASSERT(false, qDebug() << "NO ANAYLYZER TOOL FOUND FOR ID" << id); + return 0; +} + +} // namespace Analyzer + #include "analyzermanager.moc" diff --git a/src/plugins/analyzerbase/analyzermanager.h b/src/plugins/analyzerbase/analyzermanager.h index a46ce59cb1..42700cac90 100644 --- a/src/plugins/analyzerbase/analyzermanager.h +++ b/src/plugins/analyzerbase/analyzermanager.h @@ -36,6 +36,7 @@ #define ANALYZERMANAGER_H #include "analyzerbase_global.h" +#include "analyzerconstants.h" #include "projectexplorer/runconfiguration.h" #include <QtCore/QObject> @@ -48,14 +49,12 @@ namespace Utils { class FancyMainWindow; } -namespace ProjectExplorer { -class RunConfiguration; -} - namespace Analyzer { + +typedef QList<StartMode> StartModes; + class IAnalyzerTool; -class IAnalyzerEngine; -class AnalyzerStartParameters; +class AnalyzerManagerPrivate; class ANALYZER_EXPORT AnalyzerManager : public QObject { @@ -65,40 +64,39 @@ public: explicit AnalyzerManager(QObject *parent = 0); ~AnalyzerManager(); - static AnalyzerManager *instance(); - void registerRunControlFactory(ProjectExplorer::IRunControlFactory *factory); - void extensionsInitialized(); void shutdown(); - /** - * Register a tool and initialize it. - */ - void addTool(Analyzer::IAnalyzerTool *tool); + // Register a tool and initialize it. + static void addTool(IAnalyzerTool *tool, const StartModes &mode); + static IAnalyzerTool *toolFromId(const QByteArray &id); + static StartMode modeFromId(const QByteArray &id); // Dockwidgets are registered to the main window. - QDockWidget *createDockWidget(IAnalyzerTool *tool, const QString &title, + static QDockWidget *createDockWidget(IAnalyzerTool *tool, const QString &title, QWidget *widget, Qt::DockWidgetArea area = Qt::TopDockWidgetArea); - Utils::FancyMainWindow *mainWindow() const; + static Utils::FancyMainWindow *mainWindow(); + + static void showMode(); + static void selectTool(IAnalyzerTool *tool, StartMode mode); + static void startTool(IAnalyzerTool *tool, StartMode mode); + static void stopTool(); - void showMode(); - void selectTool(IAnalyzerTool *tool); - void startTool(IAnalyzerTool *tool); - void stopTool(); + // Convenience functions. + static void startLocalTool(IAnalyzerTool *tool, StartMode mode); static QString msgToolStarted(const QString &name); static QString msgToolFinished(const QString &name, int issuesFound); - IAnalyzerEngine *createEngine(const AnalyzerStartParameters &sp, - ProjectExplorer::RunConfiguration *runConfiguration); + static void showStatusMessage(const QString &message, int timeoutMS = 10000); + static void showPermanentStatusMessage(const QString &message); -public slots: - void showStatusMessage(const QString &message, int timeoutMS = 10000); - void showPermanentStatusMessage(const QString &message); + static void handleToolStarted(); + static void handleToolFinished(); + static QAction *stopAction(); private: - class AnalyzerManagerPrivate; friend class AnalyzerManagerPrivate; AnalyzerManagerPrivate *const d; }; diff --git a/src/plugins/analyzerbase/analyzerruncontrol.cpp b/src/plugins/analyzerbase/analyzerruncontrol.cpp index 920c62ef10..889b2a911b 100644 --- a/src/plugins/analyzerbase/analyzerruncontrol.cpp +++ b/src/plugins/analyzerbase/analyzerruncontrol.cpp @@ -48,9 +48,15 @@ #include <QtCore/QDebug> -using namespace Analyzer; +using namespace ProjectExplorer; -// AnalyzerRunControl::Private /////////////////////////////////////////// +////////////////////////////////////////////////////////////////////////// +// +// AnalyzerRunControl::Private +// +////////////////////////////////////////////////////////////////////////// + +namespace Analyzer { class AnalyzerRunControl::Private { @@ -66,13 +72,18 @@ AnalyzerRunControl::Private::Private() {} -// AnalyzerRunControl //////////////////////////////////////////////////// -AnalyzerRunControl::AnalyzerRunControl(const AnalyzerStartParameters &sp, - RunConfiguration *runConfiguration) - : RunControl(runConfiguration, Constants::MODE_ANALYZE), +////////////////////////////////////////////////////////////////////////// +// +// AnalyzerRunControl +// +////////////////////////////////////////////////////////////////////////// + +AnalyzerRunControl::AnalyzerRunControl(IAnalyzerTool *tool, + const AnalyzerStartParameters &sp, RunConfiguration *runConfiguration) + : RunControl(runConfiguration, tool->id()), d(new Private) { - d->m_engine = AnalyzerManager::instance()->createEngine(sp, runConfiguration); + d->m_engine = tool->createEngine(sp, runConfiguration); if (!d->m_engine) return; @@ -83,6 +94,7 @@ AnalyzerRunControl::AnalyzerRunControl(const AnalyzerStartParameters &sp, SLOT(addTask(ProjectExplorer::Task::TaskType,QString,QString,int))); connect(d->m_engine, SIGNAL(finished()), SLOT(engineFinished())); + connect(this, SIGNAL(finished()), SLOT(runControlFinished()), Qt::QueuedConnection); } AnalyzerRunControl::~AnalyzerRunControl() @@ -92,6 +104,7 @@ AnalyzerRunControl::~AnalyzerRunControl() delete d->m_engine; d->m_engine = 0; + delete d; } void AnalyzerRunControl::start() @@ -103,7 +116,7 @@ void AnalyzerRunControl::start() // clear about-to-be-outdated tasks ExtensionSystem::PluginManager *pm = ExtensionSystem::PluginManager::instance(); - ProjectExplorer::TaskHub *hub = pm->getObject<ProjectExplorer::TaskHub>(); + TaskHub *hub = pm->getObject<TaskHub>(); hub->clearTasks(Constants::ANALYZERTASK_ID); d->m_isRunning = true; @@ -111,7 +124,7 @@ void AnalyzerRunControl::start() d->m_engine->start(); } -ProjectExplorer::RunControl::StopResult AnalyzerRunControl::stop() +RunControl::StopResult AnalyzerRunControl::stop() { if (!d->m_engine || !d->m_isRunning) return StoppedSynchronously; @@ -121,12 +134,23 @@ ProjectExplorer::RunControl::StopResult AnalyzerRunControl::stop() return AsynchronousStop; } +void AnalyzerRunControl::stopIt() +{ + if (stop() == RunControl::StoppedSynchronously) + AnalyzerManager::handleToolFinished(); +} + void AnalyzerRunControl::engineFinished() { d->m_isRunning = false; emit finished(); } +void AnalyzerRunControl::runControlFinished() +{ + AnalyzerManager::handleToolFinished(); +} + bool AnalyzerRunControl::isRunning() const { return d->m_isRunning; @@ -149,12 +173,12 @@ void AnalyzerRunControl::receiveOutput(const QString &text, Utils::OutputFormat appendMessage(text, format); } -void AnalyzerRunControl::addTask(ProjectExplorer::Task::TaskType type, const QString &description, +void AnalyzerRunControl::addTask(Task::TaskType type, const QString &description, const QString &file, int line) { ExtensionSystem::PluginManager *pm = ExtensionSystem::PluginManager::instance(); - ProjectExplorer::TaskHub *hub = pm->getObject<ProjectExplorer::TaskHub>(); - hub->addTask(ProjectExplorer::Task(type, description, file, line, Constants::ANALYZERTASK_ID)); + TaskHub *hub = pm->getObject<TaskHub>(); + hub->addTask(Task(type, description, file, line, Constants::ANALYZERTASK_ID)); ///FIXME: get a better API for this into Qt Creator QList<Core::IOutputPane *> panes = pm->getObjects<Core::IOutputPane>(); @@ -165,3 +189,5 @@ void AnalyzerRunControl::addTask(ProjectExplorer::Task::TaskType type, const QSt } } } + +} // namespace Analyzer diff --git a/src/plugins/analyzerbase/analyzerruncontrol.h b/src/plugins/analyzerbase/analyzerruncontrol.h index 59a2a2e720..ff320a4e2b 100644 --- a/src/plugins/analyzerbase/analyzerruncontrol.h +++ b/src/plugins/analyzerbase/analyzerruncontrol.h @@ -45,18 +45,18 @@ namespace Analyzer { class AnalyzerStartParameters; +class IAnalyzerTool; -class ANALYZER_EXPORT AnalyzerRunControl: public ProjectExplorer::RunControl +class ANALYZER_EXPORT AnalyzerRunControl : public ProjectExplorer::RunControl { Q_OBJECT public: - typedef ProjectExplorer::RunConfiguration RunConfiguration; - // the constructor is likely to gain more arguments later - explicit AnalyzerRunControl(const AnalyzerStartParameters &sp, RunConfiguration *runConfiguration); + AnalyzerRunControl(IAnalyzerTool *tool, const AnalyzerStartParameters &sp, + ProjectExplorer::RunConfiguration *runConfiguration); ~AnalyzerRunControl(); - // pure virtuals from ProjectExplorer::RunControl + // ProjectExplorer::RunControl void start(); StopResult stop(); bool isRunning() const; @@ -64,16 +64,18 @@ public: QIcon icon() const; private slots: + void stopIt(); void receiveOutput(const QString &, Utils::OutputFormat format); void addTask(ProjectExplorer::Task::TaskType type, const QString &description, const QString &file, int line); void engineFinished(); + void runControlFinished(); private: class Private; - QScopedPointer<Private> d; + Private *d; }; } // namespace Analyzer diff --git a/src/plugins/analyzerbase/analyzerruncontrolfactory.cpp b/src/plugins/analyzerbase/analyzerruncontrolfactory.cpp deleted file mode 100644 index 3e7efb81e8..0000000000 --- a/src/plugins/analyzerbase/analyzerruncontrolfactory.cpp +++ /dev/null @@ -1,149 +0,0 @@ -/************************************************************************** -** -** This file is part of Qt Creator -** -** Copyright (c) 2011 Nokia Corporation and/or its subsidiary(-ies). -** -** Contact: Nokia Corporation (info@qt.nokia.com) -** -** -** GNU Lesser General Public License Usage -** -** This file may be used under the terms of the GNU Lesser General Public -** License version 2.1 as published by the Free Software Foundation and -** appearing in the file LICENSE.LGPL included in the packaging of this file. -** Please review the following information to ensure the GNU Lesser General -** Public License version 2.1 requirements will be met: -** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. -** -** In addition, as a special exception, Nokia gives you certain additional -** rights. These rights are described in the Nokia Qt LGPL Exception -** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. -** -** Other Usage -** -** Alternatively, this file may be used in accordance with the terms and -** conditions contained in a signed written agreement between you and Nokia. -** -** If you have questions regarding the use of this file, please contact -** Nokia at info@qt.nokia.com. -** -**************************************************************************/ - -#include "analyzerruncontrolfactory.h" -#include "analyzerruncontrol.h" -#include "analyzerconstants.h" -#include "analyzerrunconfigwidget.h" -#include "analyzersettings.h" -#include "analyzerstartparameters.h" - -#include <utils/qtcassert.h> - -#include <projectexplorer/applicationrunconfiguration.h> - -#include <remotelinux/linuxdeviceconfiguration.h> -#include <remotelinux/remotelinuxrunconfiguration.h> - -#include <QtCore/QDebug> - -using namespace Analyzer; -using namespace Analyzer::Internal; - -AnalyzerStartParameters localStartParameters(ProjectExplorer::RunConfiguration *runConfiguration) -{ - AnalyzerStartParameters sp; - QTC_ASSERT(runConfiguration, return sp); - ProjectExplorer::LocalApplicationRunConfiguration *rc = - qobject_cast<ProjectExplorer::LocalApplicationRunConfiguration *>(runConfiguration); - QTC_ASSERT(rc, return sp); - - sp.startMode = StartLocal; - sp.environment = rc->environment(); - sp.workingDirectory = rc->workingDirectory(); - sp.debuggee = rc->executable(); - sp.debuggeeArgs = rc->commandLineArguments(); - sp.displayName = rc->displayName(); - sp.connParams.host = QLatin1String("localhost"); - sp.connParams.port = rc->qmlDebugServerPort(); - return sp; -} - -AnalyzerStartParameters remoteLinuxStartParameters(ProjectExplorer::RunConfiguration *runConfiguration) -{ - AnalyzerStartParameters sp; - RemoteLinux::RemoteLinuxRunConfiguration * const rc - = qobject_cast<RemoteLinux::RemoteLinuxRunConfiguration *>(runConfiguration); - QTC_ASSERT(rc, return sp); - - sp.debuggee = rc->remoteExecutableFilePath(); - sp.debuggeeArgs = rc->arguments(); - sp.connParams = rc->deviceConfig()->sshParameters(); - sp.analyzerCmdPrefix = rc->commandPrefix(); - sp.startMode = StartRemote; - sp.displayName = rc->displayName(); - return sp; -} - - -// AnalyzerRunControlFactory //////////////////////////////////////////////////// -AnalyzerRunControlFactory::AnalyzerRunControlFactory(QObject *parent) - : IRunControlFactory(parent) -{ -} - -bool AnalyzerRunControlFactory::canRun(RunConfiguration *runConfiguration, const QString &mode) const -{ - return runConfiguration->isEnabled() && mode == Constants::MODE_ANALYZE; -} - -ProjectExplorer::RunControl *AnalyzerRunControlFactory::create(RunConfiguration *runConfiguration, - const QString &mode) -{ - QTC_ASSERT(canRun(runConfiguration, mode), return 0); - - 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; - } - - return create(sp, runConfiguration); -} - -AnalyzerRunControl *AnalyzerRunControlFactory::create(const AnalyzerStartParameters &sp, - RunConfiguration *runConfiguration) -{ - AnalyzerRunControl *rc = new AnalyzerRunControl(sp, runConfiguration); - emit runControlCreated(rc); - return rc; -} - -QString AnalyzerRunControlFactory::displayName() const -{ - return tr("Analyzer"); -} - -ProjectExplorer::IRunConfigurationAspect *AnalyzerRunControlFactory::createRunConfigurationAspect() -{ - return new AnalyzerProjectSettings; -} - -ProjectExplorer::RunConfigWidget *AnalyzerRunControlFactory::createConfigurationWidget(RunConfiguration - *runConfiguration) -{ - ProjectExplorer::LocalApplicationRunConfiguration *localRc = - qobject_cast<ProjectExplorer::LocalApplicationRunConfiguration *>(runConfiguration); - if (!localRc) - return 0; - AnalyzerProjectSettings *settings = runConfiguration->extraAspect<AnalyzerProjectSettings>(); - if (!settings) - return 0; - - AnalyzerRunConfigWidget *ret = new AnalyzerRunConfigWidget; - ret->setRunConfiguration(runConfiguration); - return ret; -} diff --git a/src/plugins/analyzerbase/analyzerruncontrolfactory.h b/src/plugins/analyzerbase/analyzerruncontrolfactory.h deleted file mode 100644 index 7c518f15cc..0000000000 --- a/src/plugins/analyzerbase/analyzerruncontrolfactory.h +++ /dev/null @@ -1,71 +0,0 @@ -/************************************************************************** -** -** This file is part of Qt Creator -** -** Copyright (c) 2011 Nokia Corporation and/or its subsidiary(-ies). -** -** Contact: Nokia Corporation (info@qt.nokia.com) -** -** -** GNU Lesser General Public License Usage -** -** This file may be used under the terms of the GNU Lesser General Public -** License version 2.1 as published by the Free Software Foundation and -** appearing in the file LICENSE.LGPL included in the packaging of this file. -** Please review the following information to ensure the GNU Lesser General -** Public License version 2.1 requirements will be met: -** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. -** -** In addition, as a special exception, Nokia gives you certain additional -** rights. These rights are described in the Nokia Qt LGPL Exception -** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. -** -** Other Usage -** -** Alternatively, this file may be used in accordance with the terms and -** conditions contained in a signed written agreement between you and Nokia. -** -** If you have questions regarding the use of this file, please contact -** Nokia at info@qt.nokia.com. -** -**************************************************************************/ - -#ifndef ANALYZERRUNCONTROLFACTORY_H -#define ANALYZERRUNCONTROLFACTORY_H - -#include <projectexplorer/runconfiguration.h> - -namespace Analyzer { - -class AnalyzerRunControl; -class AnalyzerStartParameters; - -namespace Internal { - -class AnalyzerRunControlFactory: public ProjectExplorer::IRunControlFactory -{ - Q_OBJECT - -public: - AnalyzerRunControlFactory(QObject *parent = 0); - - typedef ProjectExplorer::RunConfiguration RunConfiguration; - typedef ProjectExplorer::RunControl RunControl; - - // virtuals from IRunControlFactory - bool canRun(RunConfiguration *runConfiguration, const QString &mode) const; - RunControl *create(RunConfiguration *runConfiguration, const QString &mode); - AnalyzerRunControl *create(const AnalyzerStartParameters &sp, RunConfiguration *rc = 0); - QString displayName() const; - - ProjectExplorer::IRunConfigurationAspect *createRunConfigurationAspect(); - ProjectExplorer::RunConfigWidget *createConfigurationWidget(RunConfiguration *runConfiguration); - -signals: - void runControlCreated(Analyzer::AnalyzerRunControl *); -}; - -} // namespace Internal -} // namespace Analyzer - -#endif // ANALYZERRUNCONTROLFACTORY_H diff --git a/src/plugins/analyzerbase/analyzersettings.cpp b/src/plugins/analyzerbase/analyzersettings.cpp index fa00ab55d0..89fa68b1c2 100644 --- a/src/plugins/analyzerbase/analyzersettings.cpp +++ b/src/plugins/analyzerbase/analyzersettings.cpp @@ -40,7 +40,6 @@ #include "analyzeroptionspage.h" #include <coreplugin/icore.h> -#include <valgrind/xmlprotocol/error.h> #include <utils/qtcassert.h> #include <QtCore/QSettings> diff --git a/src/plugins/analyzerbase/analyzerstartparameters.h b/src/plugins/analyzerbase/analyzerstartparameters.h index a867108c42..5265e7099f 100644 --- a/src/plugins/analyzerbase/analyzerstartparameters.h +++ b/src/plugins/analyzerbase/analyzerstartparameters.h @@ -50,19 +50,16 @@ class ANALYZER_EXPORT AnalyzerStartParameters { public: AnalyzerStartParameters() - : startMode(StartLocal) - , connParams(Utils::SshConnectionParameters::NoProxy) - { } + : connParams(Utils::SshConnectionParameters::NoProxy) + {} - AnalyzerStartMode startMode; + StartMode startMode; Utils::SshConnectionParameters connParams; + QByteArray toolId; QString debuggee; QString debuggeeArgs; QString analyzerCmdPrefix; - QString remoteMountPoint; - QString localMountDir; - QString remoteSourcesDir; QString displayName; Utils::Environment environment; QString workingDirectory; diff --git a/src/plugins/analyzerbase/analyzerutils.cpp b/src/plugins/analyzerbase/analyzerutils.cpp index 532a3c559f..83107e8312 100644 --- a/src/plugins/analyzerbase/analyzerutils.cpp +++ b/src/plugins/analyzerbase/analyzerutils.cpp @@ -116,10 +116,3 @@ CPlusPlus::Symbol *AnalyzerUtils::findSymbolUnderCursor() const CPlusPlus::LookupItem &lookupItem = lookupItems.first(); // ### TODO: select best candidate. return lookupItem.declaration(); } - -QWidget *AnalyzerUtils::createDummyWidget() -{ - QWidget *widget = new QWidget; - widget->setProperty(Constants::ANALYZER_DUMMYWIDGET_ID, QVariant(true)); - return widget; -} diff --git a/src/plugins/analyzerbase/analyzerutils.h b/src/plugins/analyzerbase/analyzerutils.h index cece97438f..61f6b8a98d 100644 --- a/src/plugins/analyzerbase/analyzerutils.h +++ b/src/plugins/analyzerbase/analyzerutils.h @@ -46,8 +46,6 @@ class Symbol; namespace AnalyzerUtils { ANALYZER_EXPORT CPlusPlus::Symbol *findSymbolUnderCursor(); - - ANALYZER_EXPORT QWidget *createDummyWidget(); } #endif // ANALYZERUTILS_H diff --git a/src/plugins/analyzerbase/ianalyzerengine.cpp b/src/plugins/analyzerbase/ianalyzerengine.cpp index 1da091d93c..91da9d098f 100644 --- a/src/plugins/analyzerbase/ianalyzerengine.cpp +++ b/src/plugins/analyzerbase/ianalyzerengine.cpp @@ -36,21 +36,19 @@ namespace Analyzer { -IAnalyzerEngine::IAnalyzerEngine(const AnalyzerStartParameters &sp, - ProjectExplorer::RunConfiguration *runConfiguration) - : m_runConfig(runConfiguration) - , m_sp(sp) +IAnalyzerEngine::IAnalyzerEngine(IAnalyzerTool *tool, const AnalyzerStartParameters &sp, + ProjectExplorer::RunConfiguration *runConfiguration) { + m_runConfig = runConfiguration; + m_sp = sp; + m_tool = tool; } -ProjectExplorer::RunConfiguration *IAnalyzerEngine::runConfiguration() const +IAnalyzerEngine::IAnalyzerEngine(IAnalyzerTool *tool, + ProjectExplorer::RunConfiguration *runConfiguration) { - return m_runConfig; -} - -AnalyzerStartParameters IAnalyzerEngine::startParameters() const -{ - return m_sp; + m_runConfig = runConfiguration; + m_tool = tool; } } // namespace Analyzer diff --git a/src/plugins/analyzerbase/ianalyzerengine.h b/src/plugins/analyzerbase/ianalyzerengine.h index d8a9bd8895..29c2d0f0b8 100644 --- a/src/plugins/analyzerbase/ianalyzerengine.h +++ b/src/plugins/analyzerbase/ianalyzerengine.h @@ -51,6 +51,8 @@ class RunConfiguration; namespace Analyzer { +class IAnalyzerTool; + /** * An IAnalyzerEngine instance handles the launch of an analyzation tool. * @@ -61,40 +63,47 @@ class ANALYZER_EXPORT IAnalyzerEngine : public QObject Q_OBJECT public: - explicit IAnalyzerEngine(const AnalyzerStartParameters &sp, + IAnalyzerEngine(IAnalyzerTool *tool, const AnalyzerStartParameters &sp, ProjectExplorer::RunConfiguration *runConfiguration = 0); + IAnalyzerEngine(IAnalyzerTool *tool, + ProjectExplorer::RunConfiguration *runConfiguration); - /// start analyzation process + /// Start analyzation process. virtual void start() = 0; - /// trigger async stop of the analyzation process + /// Trigger async stop of the analyzation process. virtual void stop() = 0; - /// controller actions + /// Controller actions. virtual bool canPause() const { return false; } virtual void pause() {} virtual void unpause() {} - /// the active run configuration for this engine, might be zero - ProjectExplorer::RunConfiguration *runConfiguration() const; + /// The active run configuration for this engine, might be zero. + ProjectExplorer::RunConfiguration *runConfiguration() const { return m_runConfig; } + + /// The start parameters for this engine. + const AnalyzerStartParameters &startParameters() const { return m_sp; } - /// the start parameters for this engine - AnalyzerStartParameters startParameters() const; + /// The tool this engine is associated with. + IAnalyzerTool *tool() const { return m_tool; } + StartMode mode() const { return m_sp.startMode; } signals: - /// should be emitted when the debuggee outputted something + /// Should be emitted when the debuggee outputted something. void outputReceived(const QString &, Utils::OutputFormat format); - /// can be emitted when you want to show a task, e.g. to display an error + /// Can be emitted when you want to show a task, e.g. to display an error. void taskToBeAdded(ProjectExplorer::Task::TaskType type, const QString &description, const QString &file, int line); - /// must be emitted when the engine finished + /// Must be emitted when the engine finished. void finished(); - /// must be emitted when the engine is starting + /// Must be emitted when the engine is starting. void starting(const Analyzer::IAnalyzerEngine *); private: ProjectExplorer::RunConfiguration *m_runConfig; AnalyzerStartParameters m_sp; + IAnalyzerTool *m_tool; }; } // namespace Analyzer diff --git a/src/plugins/analyzerbase/ianalyzertool.cpp b/src/plugins/analyzerbase/ianalyzertool.cpp index 600d18f844..f0dce04541 100644 --- a/src/plugins/analyzerbase/ianalyzertool.cpp +++ b/src/plugins/analyzerbase/ianalyzertool.cpp @@ -33,6 +33,7 @@ **************************************************************************/ #include "ianalyzertool.h" +#include "analyzermanager.h" namespace Analyzer { @@ -40,26 +41,27 @@ IAnalyzerTool::IAnalyzerTool(QObject *parent) : QObject(parent) {} -QString IAnalyzerTool::modeString(ToolMode mode) +QByteArray IAnalyzerTool::defaultMenuGroup(StartMode mode) { - switch (mode) { - case IAnalyzerTool::DebugMode: - return tr("Debug"); - case IAnalyzerTool::ReleaseMode: - return tr("Release"); - case IAnalyzerTool::AnyMode: - break; - } - return QString(); + if (mode == StartRemote) + return Analyzer::Constants::G_ANALYZER_REMOTE_TOOLS; + return Analyzer::Constants::G_ANALYZER_TOOLS; } -void IAnalyzerTool::initializeDockWidgets() +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); } -QWidget *IAnalyzerTool::createControlWidget() +QString IAnalyzerTool::defaultActionName(const IAnalyzerTool *tool, StartMode mode) { - return 0; + QString base = tool->displayName(); + if (mode == StartRemote) + return base + tr(" (Remote)"); + return base; } } // namespace Analyzer diff --git a/src/plugins/analyzerbase/ianalyzertool.h b/src/plugins/analyzerbase/ianalyzertool.h index 0e77b82199..8b7e489ad8 100644 --- a/src/plugins/analyzerbase/ianalyzertool.h +++ b/src/plugins/analyzerbase/ianalyzertool.h @@ -36,6 +36,7 @@ #define IANALYZERTOOL_H #include "analyzerbase_global.h" +#include "analyzerconstants.h" #include <QtCore/QObject> @@ -49,8 +50,12 @@ class AnalyzerStartParameters; class IAnalyzerOutputPaneAdapter; class IAnalyzerEngine; + /** * This class represents an analyzation tool, e.g. "Valgrind Memcheck". + * + * Each tool can run in different run modes. The modes are specific to the mode. + * * @code * bool YourPlugin::initialize(const QStringList &arguments, QString *errorString) * { @@ -67,16 +72,25 @@ public: explicit IAnalyzerTool(QObject *parent = 0); /// Returns a unique ID for this tool. - virtual QString id() const = 0; + virtual QByteArray id() const = 0; /// Returns a short user readable display name for this tool. virtual QString displayName() const = 0; /// 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 mode) const + { return defaultActionId(this, mode); } + /// Returns the menu group the start action should go to. + virtual QByteArray menuGroup(StartMode mode) const + { return defaultMenuGroup(mode); } + /// Returns a short user readable action name for this tool. + virtual QString actionName(StartMode mode) const + { return defaultActionName(this, mode); } /** * The mode in which this tool should preferably be run * - * The memcheckt tool, for example, requires debug symbols, hence DebugMode + * The memcheck tool, for example, requires debug symbols, hence DebugMode * is preferred. On the other hand, callgrind should look at optimized code, * hence ReleaseMode. */ @@ -85,38 +99,27 @@ public: ReleaseMode, AnyMode }; - virtual ToolMode mode() const = 0; + virtual ToolMode toolMode() const = 0; - static QString modeString(ToolMode mode); + /// Convenience implementation. + static QByteArray defaultMenuGroup(StartMode mode); + static QByteArray defaultActionId(const IAnalyzerTool *tool, StartMode mode); + static QString defaultActionName(const IAnalyzerTool *tool, StartMode mode); - /** - * The implementation should setup widgets for the output pane here and - * optionally add dock widgets in the analyzation mode if wanted. - */ - virtual void initialize() = 0; /// This gets called after all analyzation tools where initialized. virtual void extensionsInitialized() = 0; - /** - * This is called to add all dock widgets if tool becomes active first time. - * \sa AnalzyerManager::createDockWidget - */ - virtual void initializeDockWidgets(); - - /// Returns a control widget which will be shown - /// in the output pane when this tool is selected. - virtual QWidget *createControlWidget(); + /// Creates all widgets used by the tool. + /// Returns a control widget which will be shown in the status bar when + /// this tool is selected. Must be non-zero. + virtual QWidget *createWidgets() = 0; /// Returns a new engine for the given start parameters. /// Called each time the tool is launched. virtual IAnalyzerEngine *createEngine(const AnalyzerStartParameters &sp, ProjectExplorer::RunConfiguration *runConfiguration = 0) = 0; - /// Returns true when this tool can be run on the loca machine. - virtual bool canRunLocally() const = 0; - - /// Returns true when this tool can be run on a remote machine. - virtual bool canRunRemotely() const = 0; + virtual void startTool(StartMode mode) = 0; /// Called when tools gets selected. virtual void toolSelected() const {} diff --git a/src/plugins/analyzerbase/startremotedialog.cpp b/src/plugins/analyzerbase/startremotedialog.cpp index cfb2859576..2fdec91bea 100644 --- a/src/plugins/analyzerbase/startremotedialog.cpp +++ b/src/plugins/analyzerbase/startremotedialog.cpp @@ -40,8 +40,8 @@ namespace Analyzer { -StartRemoteDialog::StartRemoteDialog(QWidget *parent, Qt::WindowFlags f) - : QDialog(parent, f) +StartRemoteDialog::StartRemoteDialog(QWidget *parent) + : QDialog(parent) , m_ui(new Ui::StartRemoteDialog) { m_ui->setupUi(this); diff --git a/src/plugins/analyzerbase/startremotedialog.h b/src/plugins/analyzerbase/startremotedialog.h index 24f32b775f..258d45554f 100644 --- a/src/plugins/analyzerbase/startremotedialog.h +++ b/src/plugins/analyzerbase/startremotedialog.h @@ -33,12 +33,11 @@ #ifndef STARTREMOTEDIALOG_H #define STARTREMOTEDIALOG_H -#include <QtGui/QDialog> +#include "analyzerbase_global.h" #include <utils/ssh/sshconnection.h> -QT_BEGIN_NAMESPACE -QT_END_NAMESPACE +#include <QtGui/QDialog> namespace Analyzer { @@ -46,11 +45,12 @@ namespace Ui { class StartRemoteDialog; } -class StartRemoteDialog : public QDialog { +class ANALYZER_EXPORT StartRemoteDialog : public QDialog +{ Q_OBJECT public: - explicit StartRemoteDialog(QWidget *parent = 0, Qt::WindowFlags f = 0); + explicit StartRemoteDialog(QWidget *parent = 0); virtual ~StartRemoteDialog(); Utils::SshConnectionParameters sshParams() const; @@ -66,6 +66,6 @@ private: Ui::StartRemoteDialog *m_ui; }; -} +} // namespace Analyzer #endif // STARTREMOTEDIALOG_H |