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)