From 1c17ed6db8efd767cce99c62f71888dbe55cc1f2 Mon Sep 17 00:00:00 2001 From: Eike Ziller Date: Tue, 23 Oct 2018 15:32:33 +0200 Subject: [PATCH] Debugger: Use engine specific contexts for delegating actions Some actions that are engine specific are visible globally in the Debug menu, like stopping, interrupting and continuing the debugger, and various step variants. These are registered in the action manager by the debugger plugin. Avoid duplicating the state management of these actions in the debugger plugin, by registering these actions as disabled dummies. The actual actions of the specific debugger run are now registered in the action manager by the debugger engine instance, for a debugger engine instance specific context. The engine manager sets the engine instance specific context when the UI is switched to the specific debugger run. Change-Id: I0a311cec0856365b830460dec2ce33d14a2289c0 Reviewed-by: hjk --- src/plugins/debugger/debuggerconstants.h | 6 +- src/plugins/debugger/debuggerengine.cpp | 68 ++++++- src/plugins/debugger/debuggerengine.h | 1 + src/plugins/debugger/debuggerplugin.cpp | 225 ++++++----------------- src/plugins/debugger/enginemanager.cpp | 20 +- 5 files changed, 133 insertions(+), 187 deletions(-) diff --git a/src/plugins/debugger/debuggerconstants.h b/src/plugins/debugger/debuggerconstants.h index 294e806e1a4..82c49edcbf6 100644 --- a/src/plugins/debugger/debuggerconstants.h +++ b/src/plugins/debugger/debuggerconstants.h @@ -37,7 +37,6 @@ const char MODE_DEBUG[] = "Mode.Debug"; const char C_DEBUGMODE[] = "Debugger.DebugMode"; const char C_CPPDEBUGGER[] = "Gdb Debugger"; const char C_QMLDEBUGGER[] = "Qml/JavaScript Debugger"; -const char C_DEBUGGER_RUNNING[] = "Debugger.Running"; const char C_DEBUGGER_NOTRUNNING[] = "Debugger.NotRunning"; const char PRESET_PERSPECTIVE_ID[] = "Debugger.Perspective.Preset"; @@ -56,9 +55,14 @@ const char ABORT[] = "Debugger.Abort"; const char STEP[] = "Debugger.StepLine"; const char STEPOUT[] = "Debugger.StepOut"; const char NEXT[] = "Debugger.NextLine"; +const char RUNTOLINE[] = "Debugger.RunToLine"; +const char RUNTOSELECTEDFUNCTION[] = "Debugger.RunToSelectedFunction"; +const char JUMPTOLINE[] = "Debugger.JumpToLine"; +const char RETURNFROMFUNCTION[] = "Debugger.ReturnFromFunction"; const char START_AND_BREAK_ON_MAIN[]= "Debugger.StartAndBreakOnMain"; const char REVERSE[] = "Debugger.ReverseDirection"; const char RESET[] = "Debugger.Reset"; +const char DETACH[] = "Debugger.Detach"; const char OPERATE_BY_INSTRUCTION[] = "Debugger.OperateByInstruction"; const char QML_SHOW_APP_ON_TOP[] = "Debugger.QmlShowAppOnTop"; const char QML_SELECTTOOL[] = "Debugger.QmlSelectTool"; diff --git a/src/plugins/debugger/debuggerengine.cpp b/src/plugins/debugger/debuggerengine.cpp index 9a52be5e215..8d9a8884410 100644 --- a/src/plugins/debugger/debuggerengine.cpp +++ b/src/plugins/debugger/debuggerengine.cpp @@ -286,10 +286,39 @@ public: connect(action(EnableReverseDebugging), &SavedAction::valueChanged, this, [this] { updateState(true); }); + static int contextCount = 0; + m_context = Context(Id("Debugger.Engine.").withSuffix(++contextCount)); + + ActionManager::registerAction(&m_continueAction, Constants::CONTINUE, m_context); + ActionManager::registerAction(&m_exitAction, Constants::STOP, m_context); + ActionManager::registerAction(&m_interruptAction, Constants::INTERRUPT, m_context); + ActionManager::registerAction(&m_abortAction, Constants::ABORT, m_context); + ActionManager::registerAction(&m_stepOverAction, Constants::NEXT, m_context); + ActionManager::registerAction(&m_stepIntoAction, Constants::STEP, m_context); + ActionManager::registerAction(&m_stepOutAction, Constants::STEPOUT, m_context); + ActionManager::registerAction(&m_runToLineAction, Constants::RUNTOLINE, m_context); + ActionManager::registerAction(&m_runToSelectedFunctionAction, Constants::RUNTOSELECTEDFUNCTION, m_context); + ActionManager::registerAction(&m_jumpToLineAction, Constants::JUMPTOLINE, m_context); + ActionManager::registerAction(&m_returnFromFunctionAction, Constants::RETURNFROMFUNCTION, m_context); + ActionManager::registerAction(&m_detachAction, Constants::DETACH, m_context); + ActionManager::registerAction(&m_resetAction, Constants::RESET, m_context); } ~DebuggerEnginePrivate() { + ActionManager::unregisterAction(&m_continueAction, Constants::CONTINUE); + ActionManager::unregisterAction(&m_exitAction, Constants::STOP); + ActionManager::unregisterAction(&m_interruptAction, Constants::INTERRUPT); + ActionManager::unregisterAction(&m_abortAction, Constants::ABORT); + ActionManager::unregisterAction(&m_stepOverAction, Constants::NEXT); + ActionManager::unregisterAction(&m_stepIntoAction, Constants::STEP); + ActionManager::unregisterAction(&m_stepOutAction, Constants::STEPOUT); + ActionManager::unregisterAction(&m_runToLineAction, Constants::RUNTOLINE); + ActionManager::unregisterAction(&m_runToSelectedFunctionAction, Constants::RUNTOSELECTEDFUNCTION); + ActionManager::unregisterAction(&m_jumpToLineAction, Constants::JUMPTOLINE); + ActionManager::unregisterAction(&m_returnFromFunctionAction, Constants::RETURNFROMFUNCTION); + ActionManager::unregisterAction(&m_detachAction, Constants::DETACH); + ActionManager::unregisterAction(&m_resetAction, Constants::RESET); destroyPerspective(); delete m_logWindow; @@ -316,6 +345,14 @@ public: delete m_threadsView; } + void updateActionToolTips() + { + // update tooltips that are visible on the button in the mode selector + const QString displayName = m_engine->displayName(); + m_continueAction.setToolTip(tr("Continue %1").arg(displayName)); + m_interruptAction.setToolTip(tr("Interrupt %1").arg(displayName)); + } + void setupViews(); void destroyPerspective() @@ -494,6 +531,7 @@ public: QPointer m_terminalRunner; DebuggerToolTipManager m_toolTipManager; + Context m_context; }; void DebuggerEnginePrivate::setupViews() @@ -668,6 +706,8 @@ void DebuggerEnginePrivate::setupViews() m_perspective->addToolBarAction(&m_resetAction); m_perspective->addToolBarAction(&m_operateByInstructionAction); + connect(&m_detachAction, &QAction::triggered, m_engine, &DebuggerEngine::handleExecDetach); + m_continueAction.setIcon(Icons::DEBUG_CONTINUE_SMALL_TOOLBAR.icon()); connect(&m_continueAction, &QAction::triggered, m_engine, &DebuggerEngine::handleExecContinue); @@ -787,6 +827,7 @@ DebuggerEngine::~DebuggerEngine() void DebuggerEngine::setDebuggerName(const QString &name) { d->m_debuggerName = name; + d->updateActionToolTips(); } QString DebuggerEngine::debuggerName() const @@ -924,6 +965,7 @@ void DebuggerEngine::setRegisterValue(const QString &name, const QString &value) void DebuggerEngine::setRunParameters(const DebuggerRunParameters &runParameters) { d->m_runParameters = runParameters; + d->updateActionToolTips(); } void DebuggerEngine::setRunId(const QString &id) @@ -1295,9 +1337,11 @@ void DebuggerEnginePrivate::setInitialActionStates() m_stepIntoAction.setEnabled(true); m_stepOutAction.setEnabled(false); m_runToLineAction.setEnabled(false); + m_runToLineAction.setVisible(false); m_runToSelectedFunctionAction.setEnabled(true); m_returnFromFunctionAction.setEnabled(false); m_jumpToLineAction.setEnabled(false); + m_jumpToLineAction.setVisible(false); m_stepOverAction.setEnabled(true); action(AutoDerefPointers)->setEnabled(true); @@ -1434,13 +1478,20 @@ void DebuggerEnginePrivate::updateState(bool alsoUpdateCompanion) m_stepOverAction.setToolTip(QString()); m_stepOutAction.setEnabled(stopped); - m_runToLineAction.setEnabled(stopped && m_engine->hasCapability(RunToLineCapability)); - m_runToSelectedFunctionAction.setEnabled(stopped); - m_returnFromFunctionAction. - setEnabled(stopped && m_engine->hasCapability(ReturnFromFunctionCapability)); - const bool canJump = stopped && m_engine->hasCapability(JumpToLineCapability); - m_jumpToLineAction.setEnabled(canJump); + const bool canRunToLine = m_engine->hasCapability(RunToLineCapability); + m_runToLineAction.setVisible(canRunToLine); + m_runToLineAction.setEnabled(stopped && canRunToLine); + + m_runToSelectedFunctionAction.setEnabled(stopped); + + const bool canReturnFromFunction = m_engine->hasCapability(ReturnFromFunctionCapability); + m_returnFromFunctionAction.setVisible(canReturnFromFunction); + m_returnFromFunctionAction.setEnabled(stopped && canReturnFromFunction); + + const bool canJump = m_engine->hasCapability(JumpToLineCapability); + m_jumpToLineAction.setVisible(canJump); + m_jumpToLineAction.setEnabled(stopped && canJump); const bool actionsEnabled = m_engine->debuggerActionsEnabled(); const bool canDeref = actionsEnabled && m_engine->hasCapability(AutoDerefPointersCapability); @@ -2036,6 +2087,11 @@ void DebuggerEngine::updateLocals() doUpdateLocals(UpdateParameters()); } +Context DebuggerEngine::debuggerContext() const +{ + return d->m_context; +} + void DebuggerEngine::updateAll() { } diff --git a/src/plugins/debugger/debuggerengine.h b/src/plugins/debugger/debuggerengine.h index 987ca38073f..a8962b71c05 100644 --- a/src/plugins/debugger/debuggerengine.h +++ b/src/plugins/debugger/debuggerengine.h @@ -304,6 +304,7 @@ public: virtual void updateAll(); virtual void updateLocals(); + Core::Context debuggerContext() const; virtual Core::Context languageContext() const { return {}; } QString displayName() const; diff --git a/src/plugins/debugger/debuggerplugin.cpp b/src/plugins/debugger/debuggerplugin.cpp index a72bc1db0dc..949edd2a799 100644 --- a/src/plugins/debugger/debuggerplugin.cpp +++ b/src/plugins/debugger/debuggerplugin.cpp @@ -758,33 +758,13 @@ public: QAction m_startRemoteCdbAction{tr("Attach to Remote CDB Session...")}; QAction m_attachToCoreAction{tr("Load Core File...")}; - Action m_detachAction{tr("Detach Debugger"), {}, &DebuggerEngine::handleExecDetach}; - Action m_continueAction{tr("Continue"), continueIcon(false), &DebuggerEngine::handleExecContinue}; - - // On application output button if "Stop" is possible - Action m_exitAction{tr("Stop Debugger"), Icons::DEBUG_EXIT_SMALL.icon(), &DebuggerEngine::quitDebugger}; - - // On the fat debug button if "Pause" is possible - Action m_interruptAction{tr("Interrupt"), interruptIcon(false), &DebuggerEngine::handleExecInterrupt}; - Action m_abortAction{tr("Abort Debugging"), {}, &DebuggerEngine::abortDebugger, - tr("Aborts debugging and resets the debugger to the initial state.")}; - QAction m_stepInAction{tr("Step Into")}; - Action m_stepOutAction{tr("Step Out"), Icons::STEP_OUT.icon(), &DebuggerEngine::handleExecStepOut}; - - Action m_runToLineAction{tr("Run to Line"), {}, &DebuggerEngine::handleExecRunToLine}; - Action m_runToSelectedFunctionAction{tr("Run to Selected Function"), {}, &DebuggerEngine::handleExecRunToSelectedFunction}; - Action m_jumpToLineAction{tr("Jump to Line"), {}, &DebuggerEngine::handleExecJumpToLine}; // In the Debug menu. - Action m_returnFromFunctionAction{tr("Immediately Return From Inner Function"), {}, &DebuggerEngine::executeReturn}; - QAction m_stepOverAction{tr("Step Over")}; QAction m_startAndBreakOnMain{tr("Start and Break on Main")}; Action m_watchAction{tr("Add Expression Evaluator"), {}, &DebuggerEngine::handleAddToWatchWindow}; Command *m_watchCommand = nullptr; QAction m_breakAction{tr("Toggle Breakpoint")}; Action m_frameUpAction{tr("Move to Calling Frame"), {}, &DebuggerEngine::handleFrameDown}; Action m_frameDownAction{tr("Move to Called Frame"), {}, &DebuggerEngine::handleFrameUp}; - Action m_resetAction{tr("Restart Debugging"), Icons::RESTART_TOOLBAR.icon(), &DebuggerEngine::handleReset, - tr("Restart the debugging session.")}; Action m_openMemoryEditorAction{tr("Memory..."), {}, &DebuggerEngine::openMemoryEditor}; BreakpointManager m_breakpointManager; @@ -1014,7 +994,6 @@ bool DebuggerPluginPrivate::initialize(const QStringList &arguments, { Q_UNUSED(errorMessage); - const Context debuggerRunning(C_DEBUGGER_RUNNING); const Context debuggerNotRunning(C_DEBUGGER_NOTRUNNING); ICore::addAdditionalContext(debuggerNotRunning); @@ -1041,6 +1020,8 @@ bool DebuggerPluginPrivate::initialize(const QStringList &arguments, m_menu->addSeparator(G_ANALYZER_REMOTE_TOOLS); m_menu->addSeparator(G_ANALYZER_OPTIONS); + QAction *act; + // Populate Windows->Views menu with standard actions. Context debugcontext(Constants::C_DEBUGMODE); @@ -1200,19 +1181,27 @@ bool DebuggerPluginPrivate::initialize(const QStringList &arguments, cmd->setAttribute(Command::CA_Hide); mstart->addAction(cmd, Constants::G_START_QML); - cmd = ActionManager::registerAction(&m_detachAction, "Debugger.Detach"); - cmd->setAttribute(Command::CA_Hide); + act = new QAction(tr("Detach Debugger"), this); + act->setEnabled(false); + cmd = ActionManager::registerAction(act, Constants::DETACH); debugMenu->addAction(cmd, CC::G_DEFAULT_ONE); - cmd = ActionManager::registerAction(&m_interruptAction, Constants::INTERRUPT); + act = new QAction(interruptIcon(false), tr("Interrupt"), this); + act->setEnabled(false); + cmd = ActionManager::registerAction(act, Constants::INTERRUPT); cmd->setDescription(tr("Interrupt Debugger")); + cmd->setAttribute(Command::CA_UpdateText); debugMenu->addAction(cmd, CC::G_DEFAULT_ONE); - cmd = ActionManager::registerAction(&m_continueAction, Constants::CONTINUE); -// cmd->setDefaultKeySequence(debugKey); + act = new QAction(continueIcon(false), tr("Continue"), this); + act->setEnabled(false); + cmd = ActionManager::registerAction(act, Constants::CONTINUE); + cmd->setAttribute(Command::CA_UpdateText); debugMenu->addAction(cmd, CC::G_DEFAULT_ONE); - cmd = ActionManager::registerAction(&m_exitAction, Constants::STOP); + act = new QAction(Icons::DEBUG_EXIT_SMALL.icon(), tr("Stop Debugger"), this); + act->setEnabled(false); + cmd = ActionManager::registerAction(act, Constants::STOP); debugMenu->addAction(cmd, CC::G_DEFAULT_ONE); m_hiddenStopAction.initialize(cmd->action()); m_hiddenStopAction.setAttribute(ProxyAction::UpdateText); @@ -1221,11 +1210,16 @@ bool DebuggerPluginPrivate::initialize(const QStringList &arguments, cmd = ActionManager::registerAction(&m_hiddenStopAction, Constants::HIDDEN_STOP); cmd->setDefaultKeySequence(QKeySequence(useMacShortcuts ? tr("Shift+Ctrl+Y") : tr("Shift+F5"))); - cmd = ActionManager::registerAction(&m_abortAction, Constants::ABORT); + act = new QAction(tr("Abort Debugging"), this); + act->setEnabled(false); + cmd = ActionManager::registerAction(act, Constants::ABORT); cmd->setDescription(tr("Reset Debugger")); debugMenu->addAction(cmd, CC::G_DEFAULT_ONE); - cmd = ActionManager::registerAction(&m_resetAction, Constants::RESET); + act = new QAction(Icons::RESTART_TOOLBAR.icon(), tr("Restart Debugging"), this); + act->setEnabled(false); + act->setToolTip(tr("Restart the debugging session.")); + cmd = ActionManager::registerAction(act, Constants::RESET); cmd->setDescription(tr("Restart Debugging")); debugMenu->addAction(cmd, CC::G_DEFAULT_ONE); @@ -1242,56 +1236,50 @@ bool DebuggerPluginPrivate::initialize(const QStringList &arguments, ProjectExplorerPlugin::runStartupProject(ProjectExplorer::Constants::DEBUG_RUN_MODE, false); }); - cmd = ActionManager::registerAction(&m_stepOverAction, Constants::NEXT, debuggerRunning); + act = new QAction(Icons::STEP_OVER.icon(), tr("Step Over"), this); + act->setEnabled(false); + cmd = ActionManager::registerAction(act, Constants::NEXT); cmd->setDefaultKeySequence(QKeySequence(useMacShortcuts ? tr("Ctrl+Shift+O") : tr("F10"))); - cmd->setAttribute(Command::CA_Hide); debugMenu->addAction(cmd); - m_stepOverAction.setIcon(Icons::STEP_OVER.icon()); - connect(&m_stepOverAction, &QAction::triggered, this, [] { - DebuggerEngine *engine = EngineManager::currentEngine(); - QTC_ASSERT(engine, return); - engine->handleExecStepOver(); - }); - cmd = ActionManager::registerAction(&m_stepInAction, Constants::STEP, debuggerRunning); + act = new QAction(Icons::STEP_INTO.icon(), tr("Step Into"), this); + act->setEnabled(false); + cmd = ActionManager::registerAction(act, Constants::STEP); cmd->setDefaultKeySequence(QKeySequence(useMacShortcuts ? tr("Ctrl+Shift+I") : tr("F11"))); - cmd->setAttribute(Command::CA_Hide); debugMenu->addAction(cmd); - m_stepInAction.setIcon(Icons::STEP_INTO.icon()); - connect(&m_stepInAction, &QAction::triggered, this, [] { - DebuggerEngine *engine = EngineManager::currentEngine(); - QTC_ASSERT(engine, return); - engine->handleExecStepIn(); - }); - - cmd = ActionManager::registerAction(&m_stepOutAction, Constants::STEPOUT); + act = new QAction(Icons::STEP_OUT.icon(), tr("Step Out"), this); + act->setEnabled(false); + cmd = ActionManager::registerAction(act, Constants::STEPOUT); cmd->setDefaultKeySequence(QKeySequence(useMacShortcuts ? tr("Ctrl+Shift+T") : tr("Shift+F11"))); - cmd->setAttribute(Command::CA_Hide); debugMenu->addAction(cmd); - cmd = ActionManager::registerAction(&m_runToLineAction, - "Debugger.RunToLine", cppDebuggercontext); + act = new QAction(tr("Run to Line"), this); + act->setEnabled(false); + act->setVisible(false); + cmd = ActionManager::registerAction(act, Constants::RUNTOLINE); cmd->setDefaultKeySequence(QKeySequence(useMacShortcuts ? tr("Shift+F8") : tr("Ctrl+F10"))); - cmd->setAttribute(Command::CA_Hide); debugMenu->addAction(cmd); - cmd = ActionManager::registerAction(&m_runToSelectedFunctionAction, - "Debugger.RunToSelectedFunction", cppDebuggercontext); + act = new QAction(tr("Run to Selected Function"), this); + act->setEnabled(false); + act->setEnabled(false); + cmd = ActionManager::registerAction(act, Constants::RUNTOSELECTEDFUNCTION); cmd->setDefaultKeySequence(QKeySequence(tr("Ctrl+F6"))); - cmd->setAttribute(Command::CA_Hide); // Don't add to menu by default as keeping its enabled state // and text up-to-date is a lot of hassle. // debugMenu->addAction(cmd); - cmd = ActionManager::registerAction(&m_jumpToLineAction, - "Debugger.JumpToLine", cppDebuggercontext); - cmd->setAttribute(Command::CA_Hide); + act = new QAction(tr("Jump to Line"), this); + act->setEnabled(false); + act->setVisible(false); + cmd = ActionManager::registerAction(act, Constants::JUMPTOLINE); debugMenu->addAction(cmd); - cmd = ActionManager::registerAction(&m_returnFromFunctionAction, - "Debugger.ReturnFromFunction", cppDebuggercontext); - cmd->setAttribute(Command::CA_Hide); + act = new QAction(tr("Immediately Return From Inner Function"), this); + act->setEnabled(false); + act->setVisible(false); + cmd = ActionManager::registerAction(act, Constants::RETURNFROMFUNCTION); debugMenu->addAction(cmd); debugMenu->addSeparator(); @@ -1476,150 +1464,61 @@ void DebuggerPluginPrivate::updatePresetState() if (!currentEngine || !currentEngine->isStartupRunConfiguration()) { // No engine running -- or -- we have a running engine but it does not // correspond to the current start up project. - // Step into/next: Start and break at 'main' unless a debugger is running. - QString stepToolTip = canRun ? tr("Start \"%1\" and break at function \"main\"").arg(startupRunConfigName) : whyNot; - m_stepInAction.setEnabled(canRun); - m_stepInAction.setToolTip(stepToolTip); - m_stepOverAction.setEnabled(canRun); - m_stepOverAction.setToolTip(stepToolTip); m_startAction.setEnabled(canRun); m_startAction.setIcon(startIcon(false)); m_startAction.setToolButtonStyle(Qt::ToolButtonTextBesideIcon); m_startAction.setVisible(true); - m_interruptAction.setEnabled(false); - m_continueAction.setEnabled(false); - m_exitAction.setEnabled(false); m_debugWithoutDeployAction.setEnabled(canRun); m_visibleStartAction.setAction(&m_startAction); m_hiddenStopAction.setAction(&m_undisturbableAction); - m_detachAction.setEnabled(false); - m_jumpToLineAction.setEnabled(false); - m_returnFromFunctionAction.setEnabled(false); return; } QTC_ASSERT(currentEngine, return); // We have a current engine, and it belongs to the startup runconfig. - m_stepInAction.setToolTip(QString()); - m_stepOverAction.setToolTip(QString()); - // The 'state' bits only affect the fat debug button, not the preset start button. m_startAction.setIcon(startIcon(false)); m_startAction.setEnabled(false); m_startAction.setVisible(false); - QString currentDisplayName = currentEngine->displayName(); - m_interruptAction.setToolTip(tr("Interrupt %1").arg(currentDisplayName)); - m_continueAction.setToolTip(tr("Continue %1").arg(currentDisplayName)); - m_debugWithoutDeployAction.setEnabled(canRun); - // Global actions are redirected to running, active engine if possible. - - const bool isCore = currentEngine->runParameters().startMode == AttachCore; - const DebuggerState state = currentEngine->state(); - const bool companionPreventsAction = currentEngine->companionPreventsActions(); if (state == InferiorStopOk) { // F5 continues, Shift-F5 kills. It is "continuable". m_startAction.setEnabled(false); - m_interruptAction.setEnabled(false); - m_continueAction.setEnabled(!companionPreventsAction); - m_exitAction.setEnabled(true); m_debugWithoutDeployAction.setEnabled(false); - m_visibleStartAction.setAction(&m_continueAction); - m_hiddenStopAction.setAction(&m_exitAction); - m_stepInAction.setEnabled(!companionPreventsAction); - m_stepOverAction.setEnabled(!companionPreventsAction); - m_jumpToLineAction.setEnabled(currentEngine->hasCapability(JumpToLineCapability)); - m_returnFromFunctionAction.setEnabled(currentEngine->hasCapability(ReturnFromFunctionCapability)); - m_detachAction.setEnabled(!isCore); - m_abortAction.setEnabled(true); - m_resetAction.setEnabled(currentEngine->hasCapability(ResetInferiorCapability)); - m_stepOutAction.setEnabled(!companionPreventsAction); - m_runToLineAction.setEnabled(currentEngine->hasCapability(RunToLineCapability)); - m_runToSelectedFunctionAction.setEnabled(true); + m_visibleStartAction.setAction(ActionManager::command(Constants::CONTINUE)->action()); + m_hiddenStopAction.setAction(ActionManager::command(Constants::STOP)->action()); } else if (state == InferiorRunOk) { // Shift-F5 interrupts. It is also "interruptible". m_startAction.setEnabled(false); - m_interruptAction.setEnabled(!companionPreventsAction); - m_continueAction.setEnabled(false); - m_exitAction.setEnabled(true); m_debugWithoutDeployAction.setEnabled(false); - m_visibleStartAction.setAction(&m_interruptAction); - m_hiddenStopAction.setAction(&m_interruptAction); - m_stepInAction.setEnabled(false); - m_stepOverAction.setEnabled(false); - m_jumpToLineAction.setEnabled(false); - m_returnFromFunctionAction.setEnabled(false); - m_detachAction.setEnabled(false); - m_abortAction.setEnabled(true); - m_resetAction.setEnabled(false); - m_stepOutAction.setEnabled(false); - m_runToLineAction.setEnabled(false); - m_runToSelectedFunctionAction.setEnabled(false); + m_visibleStartAction.setAction(ActionManager::command(Constants::INTERRUPT)->action()); + m_hiddenStopAction.setAction(ActionManager::command(Constants::INTERRUPT)->action()); } else if (state == DebuggerFinished) { // We don't want to do anything anymore. m_startAction.setEnabled(canRun); - m_interruptAction.setEnabled(false); - m_continueAction.setEnabled(false); - m_exitAction.setEnabled(false); m_debugWithoutDeployAction.setEnabled(canRun); m_visibleStartAction.setAction(&m_startAction); m_hiddenStopAction.setAction(&m_undisturbableAction); - m_stepInAction.setEnabled(false); - m_stepOverAction.setEnabled(false); - m_jumpToLineAction.setEnabled(false); - m_returnFromFunctionAction.setEnabled(false); - m_detachAction.setEnabled(false); - m_abortAction.setEnabled(false); - m_resetAction.setEnabled(false); - m_stepOutAction.setEnabled(false); - m_runToLineAction.setEnabled(false); - m_runToSelectedFunctionAction.setEnabled(false); } else if (state == InferiorUnrunnable) { // We don't want to do anything anymore. m_startAction.setEnabled(false); - m_interruptAction.setEnabled(false); - m_continueAction.setEnabled(false); - m_exitAction.setEnabled(true); m_debugWithoutDeployAction.setEnabled(false); - m_visibleStartAction.setAction(&m_exitAction); - m_hiddenStopAction.setAction(&m_exitAction); - m_stepInAction.setEnabled(false); - m_stepOverAction.setEnabled(false); - m_jumpToLineAction.setEnabled(false); - m_returnFromFunctionAction.setEnabled(false); - m_detachAction.setEnabled(false); - m_abortAction.setEnabled(true); - m_resetAction.setEnabled(false); - m_stepOutAction.setEnabled(false); - m_runToLineAction.setEnabled(false); - m_runToSelectedFunctionAction.setEnabled(false); + m_visibleStartAction.setAction(ActionManager::command(Constants::STOP)->action()); + m_hiddenStopAction.setAction(ActionManager::command(Constants::STOP)->action()); } else { // The startup phase should be over once we are here. // But treat it as 'undisturbable if we are here by accident. QTC_CHECK(state != DebuggerNotReady); // Everything else is "undisturbable". m_startAction.setEnabled(false); - m_interruptAction.setEnabled(false); - m_continueAction.setEnabled(false); - m_exitAction.setEnabled(false); m_debugWithoutDeployAction.setEnabled(false); m_visibleStartAction.setAction(&m_undisturbableAction); m_hiddenStopAction.setAction(&m_undisturbableAction); - m_stepInAction.setEnabled(false); - m_stepOverAction.setEnabled(false); - m_jumpToLineAction.setEnabled(false); - m_returnFromFunctionAction.setEnabled(false); - m_detachAction.setEnabled(false); - m_abortAction.setEnabled(true); - m_resetAction.setEnabled(false); - m_stepOutAction.setEnabled(false); - m_runToLineAction.setEnabled(false); - m_runToSelectedFunctionAction.setEnabled(false); } // FIXME: Decentralize the actions below @@ -2060,27 +1959,11 @@ void DebuggerPluginPrivate::setInitialState() m_attachToRemoteServerAction.setEnabled(true); m_attachToRunningApplication.setEnabled(true); m_attachToUnstartedApplication.setEnabled(true); - m_detachAction.setEnabled(false); m_watchAction.setEnabled(false); m_breakAction.setEnabled(false); //m_snapshotAction.setEnabled(false); - m_exitAction.setEnabled(false); - m_abortAction.setEnabled(false); - m_resetAction.setEnabled(false); - - m_interruptAction.setEnabled(false); - m_continueAction.setEnabled(false); - - m_stepInAction.setEnabled(true); - m_stepOutAction.setEnabled(false); - m_runToLineAction.setEnabled(false); - m_runToSelectedFunctionAction.setEnabled(true); - m_returnFromFunctionAction.setEnabled(false); - m_jumpToLineAction.setEnabled(false); - m_stepOverAction.setEnabled(true); - action(AutoDerefPointers)->setEnabled(true); action(ExpandStack)->setEnabled(false); } diff --git a/src/plugins/debugger/enginemanager.cpp b/src/plugins/debugger/enginemanager.cpp index ef92bb2858a..7e8e6d16987 100644 --- a/src/plugins/debugger/enginemanager.cpp +++ b/src/plugins/debugger/enginemanager.cpp @@ -315,23 +315,30 @@ void EngineManagerPrivate::activateEngineByIndex(int index) void EngineManagerPrivate::activateEngineItem(EngineItem *engineItem) { + Context previousContext; if (m_currentItem) { if (DebuggerEngine *engine = m_currentItem->m_engine) { - const Context context = engine->languageContext(); - ICore::removeAdditionalContext(context); + previousContext.add(engine->languageContext()); + previousContext.add(engine->debuggerContext()); + } else { + previousContext.add(Context(Constants::C_DEBUGGER_NOTRUNNING)); } } m_currentItem = engineItem; + Context newContext; if (m_currentItem) { if (DebuggerEngine *engine = m_currentItem->m_engine) { - const Context context = engine->languageContext(); - ICore::addAdditionalContext(context); + newContext.add(engine->languageContext()); + newContext.add(engine->debuggerContext()); engine->gotoCurrentLocation(); + } else { + newContext.add(Context(Constants::C_DEBUGGER_NOTRUNNING)); } } + ICore::updateAdditionalContexts(previousContext, newContext); selectUiForCurrentEngine(); } @@ -344,13 +351,8 @@ void EngineManagerPrivate::selectUiForCurrentEngine() int row = 0; if (m_currentItem && m_currentItem->m_engine) { - ICore::updateAdditionalContexts(Context(Debugger::Constants::C_DEBUGGER_NOTRUNNING), - Context(Debugger::Constants::C_DEBUGGER_RUNNING)); perspective = m_currentItem->m_engine->perspective(); m_currentItem->m_engine->updateState(false); - } else { - ICore::updateAdditionalContexts(Context(Debugger::Constants::C_DEBUGGER_RUNNING), - Context(Debugger::Constants::C_DEBUGGER_NOTRUNNING)); } if (m_currentItem)