feedc0de/qt-creator
1
0
Fork 0
forked from qt-creator/qt-creator
Code Pull Requests Activity

Debugger: Convert to Tr::tr

Browse Source 
Change-Id: I5d2475c790851c68f9997ac6af72b5eaca58482d
Reviewed-by: Eike Ziller <eike.ziller@qt.io>
This commit is contained in:
hjk
2022-07-05 15:37:08 +02:00
parent bb3549a721
commit 9894c6eaf0
143 changed files with 2272 additions and 36880 deletions
Download Patch File Download Diff File Expand all files Collapse all files

264
src/plugins/debugger/debuggeractions.cpp
View File

@@ -28,6 +28,7 @@
#include "commonoptionspage.h"
#include "debuggericons.h"
#include "debuggerinternalconstants.h"
#include "debuggertr.h"
#ifdef Q_OS_WIN
#include "registerpostmortemaction.h"
@@ -45,12 +46,11 @@
using namespace Utils;
namespace Debugger::Internal {
const char debugModeSettingsGroupC[] = "DebugMode";
const char cdbSettingsGroupC[] = "CDB2";
namespace Debugger {
namespace Internal {
//////////////////////////////////////////////////////////////////////////
//
// DebuggerSettings
@@ -72,79 +72,79 @@ DebuggerSettings::DebuggerSettings()
const QString debugModeGroup(debugModeSettingsGroupC);
const QString cdbSettingsGroup(cdbSettingsGroupC);
settingsDialog.setLabelText(tr("Configure Debugger..."));
settingsDialog.setLabelText(Tr::tr("Configure Debugger..."));
/*
groupBoxPluginDebugging = new QGroupBox(q);
groupBoxPluginDebugging->setTitle(GdbOptionsPage::tr(
groupBoxPluginDebugging->setTitle(Tr::tr(
"Behavior of Breakpoint Setting in Plugins"));
radioButtonAllPluginBreakpoints = new QRadioButton(groupBoxPluginDebugging);
radioButtonAllPluginBreakpoints->setText(GdbOptionsPage::tr(
radioButtonAllPluginBreakpoints->setText(Tr::tr(
"Always try to set breakpoints in plugins automatically"));
radioButtonAllPluginBreakpoints->setToolTip(GdbOptionsPage::tr(
radioButtonAllPluginBreakpoints->setToolTip(Tr::tr(
"This is the slowest but safest option."));
radioButtonSelectedPluginBreakpoints = new QRadioButton(groupBoxPluginDebugging);
radioButtonSelectedPluginBreakpoints->setText(GdbOptionsPage::tr(
radioButtonSelectedPluginBreakpoints->setText(Tr::tr(
"Try to set breakpoints in selected plugins"));
radioButtonNoPluginBreakpoints = new QRadioButton(groupBoxPluginDebugging);
radioButtonNoPluginBreakpoints->setText(GdbOptionsPage::tr(
radioButtonNoPluginBreakpoints->setText(Tr::tr(
"Never set breakpoints in plugins automatically"));
lineEditSelectedPluginBreakpointsPattern = new QLineEdit(groupBoxPluginDebugging);
labelSelectedPluginBreakpoints = new QLabel(groupBoxPluginDebugging);
labelSelectedPluginBreakpoints->setText(GdbOptionsPage::tr(
labelSelectedPluginBreakpoints->setText(Tr::tr(
"Matching regular expression: "));
*/
//
// View
//
alwaysAdjustColumnWidths.setLabelText(tr("Always Adjust View Column Widths to Contents"));
alwaysAdjustColumnWidths.setLabelText(Tr::tr("Always Adjust View Column Widths to Contents"));
alwaysAdjustColumnWidths.setSettingsKey(debugModeGroup, "AlwaysAdjustColumnWidths");
alwaysAdjustColumnWidths.setDefaultValue(true);
// Needed by QML Inspector
//useAlternatingRowColors.setLabelText(tr("Use Alternating Row Colors"));
//useAlternatingRowColors.setLabelText(Tr::tr("Use Alternating Row Colors"));
useAlternatingRowColors.setSettingsKey(debugModeGroup, "UseAlternatingRowColours");
useAlternatingRowColors.setLabelText(tr("Use alternating row colors in debug views"));
useAlternatingRowColors.setLabelText(Tr::tr("Use alternating row colors in debug views"));
stationaryEditorWhileStepping.setSettingsKey(debugModeGroup, "StationaryEditorWhileStepping");
stationaryEditorWhileStepping.setLabelText(tr("Keep editor stationary when stepping"));
stationaryEditorWhileStepping.setToolTip(tr("Scrolls the editor only when it is necessary "
stationaryEditorWhileStepping.setLabelText(Tr::tr("Keep editor stationary when stepping"));
stationaryEditorWhileStepping.setToolTip(Tr::tr("Scrolls the editor only when it is necessary "
"to keep the current line in view, "
"instead of keeping the next statement centered at "
"all times."));
forceLoggingToConsole.setSettingsKey(debugModeGroup, "ForceLoggingToConsole");
forceLoggingToConsole.setLabelText(tr("Force logging to console"));
forceLoggingToConsole.setToolTip(tr("Sets QT_LOGGING_TO_CONSOLE=1 in the environment "
forceLoggingToConsole.setLabelText(Tr::tr("Force logging to console"));
forceLoggingToConsole.setToolTip(Tr::tr("Sets QT_LOGGING_TO_CONSOLE=1 in the environment "
"of the debugged program, preventing storing debug output "
"in system logs."));
fontSizeFollowsEditor.setSettingsKey(debugModeGroup, "FontSizeFollowsEditor");
fontSizeFollowsEditor.setToolTip(tr("Changes the font size in the debugger views when"
fontSizeFollowsEditor.setToolTip(Tr::tr("Changes the font size in the debugger views when"
"the font size in the main editor changes."));
fontSizeFollowsEditor.setLabelText(tr("Debugger font size follows main editor"));
fontSizeFollowsEditor.setLabelText(Tr::tr("Debugger font size follows main editor"));
useMessageBoxForSignals.setSettingsKey(debugModeGroup, "UseMessageBoxForSignals");
useMessageBoxForSignals.setDefaultValue(true);
useMessageBoxForSignals.setLabelText(/*GdbOptionsPage::*/tr(
useMessageBoxForSignals.setLabelText(Tr::tr(
"Show a message box when receiving a signal"));
useMessageBoxForSignals.setToolTip(/*GdbOptionsPage::*/tr(
useMessageBoxForSignals.setToolTip(Tr::tr(
"Displays a message box as soon as your application\n"
"receives a signal like SIGSEGV during debugging."));
logTimeStamps.setLabelText(tr("Log Time Stamps"));
logTimeStamps.setLabelText(Tr::tr("Log Time Stamps"));
logTimeStamps.setSettingsKey(debugModeGroup, "LogTimeStamps");
autoDerefPointers.setLabelText(tr("Dereference Pointers Automatically"));
autoDerefPointers.setLabelText(Tr::tr("Dereference Pointers Automatically"));
autoDerefPointers.setDefaultValue(true);
autoDerefPointers.setSettingsKey(debugModeGroup, "AutoDerefPointers");
autoDerefPointers.setToolTip(tr("<p>This switches the Locals and Expressions views to "
autoDerefPointers.setToolTip(Tr::tr("<p>This switches the Locals and Expressions views to "
"automatically dereference pointers. This saves a level in the "
"tree view, but also loses data for the now-missing intermediate "
"level."));
@@ -155,7 +155,7 @@ DebuggerSettings::DebuggerSettings()
cdbAdditionalArguments.setSettingsKey(cdbSettingsGroup, "AdditionalArguments");
cdbAdditionalArguments.setDisplayStyle(StringAspect::LineEditDisplay);
cdbAdditionalArguments.setLabelText(tr("Additional arguments:"));
cdbAdditionalArguments.setLabelText(Tr::tr("Additional arguments:"));
cdbSymbolPaths.setSettingsKey(cdbSettingsGroup, "SymbolPaths");
cdbSourcePaths.setSettingsKey(cdbSettingsGroup, "SourcePaths");
@@ -166,68 +166,68 @@ DebuggerSettings::DebuggerSettings()
CommonOptionsPage::msgSetBreakpointAtFunction(Constants::CRT_DEBUG_REPORT));
cdbBreakOnCrtDbgReport.setToolTip(
CommonOptionsPage::msgSetBreakpointAtFunctionToolTip(Constants::CRT_DEBUG_REPORT,
tr("Catches runtime error messages caused by assert(), for example.")));
Tr::tr("Catches runtime error messages caused by assert(), for example.")));
useCdbConsole.setSettingsKey(cdbSettingsGroup, "CDB_Console");
useCdbConsole.setToolTip("<html><head/><body><p>" + tr(
useCdbConsole.setToolTip("<html><head/><body><p>" + Tr::tr(
"Uses CDB's native console for console applications. "
"This overrides the setting in Environment > System. "
"The native console does not prompt on application exit. "
"It is suitable for diagnosing cases in which the application does not "
"start up properly in the configured console and the subsequent attach fails.")
+ "</p></body></html>");
useCdbConsole.setLabelText(tr("Use CDB &console"));
useCdbConsole.setLabelText(Tr::tr("Use CDB &console"));
cdbBreakPointCorrection.setSettingsKey(cdbSettingsGroup, "BreakpointCorrection");
cdbBreakPointCorrection.setDefaultValue(true);
cdbBreakPointCorrection.setToolTip("<html><head/><body><p>" + tr(
cdbBreakPointCorrection.setToolTip("<html><head/><body><p>" + Tr::tr(
"Attempts to correct the location of a breakpoint based on file and line number should"
"it be in a comment or in a line for which no code is generated. "
"The correction is based on the code model.") + "</p></body></html>");
cdbBreakPointCorrection.setLabelText(tr("Correct breakpoint location"));
cdbBreakPointCorrection.setLabelText(Tr::tr("Correct breakpoint location"));
cdbUsePythonDumper.setSettingsKey(cdbSettingsGroup, "UsePythonDumper");
cdbUsePythonDumper.setDefaultValue(true);
cdbUsePythonDumper.setLabelText(tr("Use Python dumper"));
cdbUsePythonDumper.setLabelText(Tr::tr("Use Python dumper"));
firstChanceExceptionTaskEntry.setSettingsKey(cdbSettingsGroup, "FirstChanceExceptionTaskEntry");
firstChanceExceptionTaskEntry.setDefaultValue(true);
firstChanceExceptionTaskEntry.setLabelText(tr("First chance exceptions"));
firstChanceExceptionTaskEntry.setLabelText(Tr::tr("First chance exceptions"));
secondChanceExceptionTaskEntry.setSettingsKey(cdbSettingsGroup, "SecondChanceExceptionTaskEntry");
secondChanceExceptionTaskEntry.setDefaultValue(true);
secondChanceExceptionTaskEntry.setLabelText(tr("Second chance exceptions"));
secondChanceExceptionTaskEntry.setLabelText(Tr::tr("Second chance exceptions"));
ignoreFirstChanceAccessViolation.setSettingsKey(cdbSettingsGroup, "IgnoreFirstChanceAccessViolation");
ignoreFirstChanceAccessViolation.setLabelText(tr("Ignore first chance access violations"));
ignoreFirstChanceAccessViolation.setLabelText(Tr::tr("Ignore first chance access violations"));
//
// Locals & Watchers
//
showStdNamespace.setSettingsKey(debugModeGroup, "ShowStandardNamespace");
showStdNamespace.setDefaultValue(true);
showStdNamespace.setDisplayName(tr("Show \"std::\" Namespace in Types"));
showStdNamespace.setLabelText(tr("Show \"std::\" namespace in types"));
showStdNamespace.setToolTip(tr("<p>Shows \"std::\" prefix for types from the standard library."));
showStdNamespace.setDisplayName(Tr::tr("Show \"std::\" Namespace in Types"));
showStdNamespace.setLabelText(Tr::tr("Show \"std::\" namespace in types"));
showStdNamespace.setToolTip(Tr::tr("<p>Shows \"std::\" prefix for types from the standard library."));
showQtNamespace.setSettingsKey(debugModeGroup, "ShowQtNamespace");
showQtNamespace.setDefaultValue(true);
showQtNamespace.setDisplayName(tr("Show Qt's Namespace in Types"));
showQtNamespace.setLabelText(tr("Show Qt's namespace in types"));
showQtNamespace.setToolTip(tr("<p>Shows Qt namespace prefix for Qt types. This is only "
showQtNamespace.setDisplayName(Tr::tr("Show Qt's Namespace in Types"));
showQtNamespace.setLabelText(Tr::tr("Show Qt's namespace in types"));
showQtNamespace.setToolTip(Tr::tr("<p>Shows Qt namespace prefix for Qt types. This is only "
"relevant if Qt was configured with \"-qtnamespace\"."));
showQObjectNames.setSettingsKey(debugModeGroup, "ShowQObjectNames2");
showQObjectNames.setDefaultValue(true);
showQObjectNames.setDisplayName(tr("Show QObject names if available"));
showQObjectNames.setLabelText(tr("Show QObject names if available"));
showQObjectNames.setToolTip(tr("<p>Displays the objectName property of QObject based items. "
showQObjectNames.setDisplayName(Tr::tr("Show QObject names if available"));
showQObjectNames.setLabelText(Tr::tr("Show QObject names if available"));
showQObjectNames.setToolTip(Tr::tr("<p>Displays the objectName property of QObject based items. "
"Note that this can negatively impact debugger performance "
"even if no QObjects are present."));
sortStructMembers.setSettingsKey(debugModeGroup, "SortStructMembers");
sortStructMembers.setDisplayName(tr("Sort Members of Classes and Structs Alphabetically"));
sortStructMembers.setLabelText(tr("Sort members of classes and structs alphabetically"));
sortStructMembers.setDisplayName(Tr::tr("Sort Members of Classes and Structs Alphabetically"));
sortStructMembers.setLabelText(Tr::tr("Sort members of classes and structs alphabetically"));
sortStructMembers.setDefaultValue(true);
//
@@ -235,27 +235,27 @@ DebuggerSettings::DebuggerSettings()
//
useDebuggingHelpers.setSettingsKey(debugModeGroup, "UseDebuggingHelper");
useDebuggingHelpers.setDefaultValue(true);
useDebuggingHelpers.setLabelText(tr("Use Debugging Helpers"));
useDebuggingHelpers.setLabelText(Tr::tr("Use Debugging Helpers"));
useCodeModel.setSettingsKey(debugModeGroup, "UseCodeModel");
useCodeModel.setDefaultValue(true);
useCodeModel.setLabelText(tr("Use code model"));
useCodeModel.setToolTip(tr("<p>Selecting this causes the C++ Code Model being asked "
useCodeModel.setLabelText(Tr::tr("Use code model"));
useCodeModel.setToolTip(Tr::tr("<p>Selecting this causes the C++ Code Model being asked "
"for variable scope information. This might result in slightly faster "
"debugger operation but may fail for optimized code."));
showThreadNames.setSettingsKey(debugModeGroup, "ShowThreadNames");
showThreadNames.setLabelText(tr("Display thread names"));
showThreadNames.setToolTip(tr("<p>Displays names of QThread based threads."));
showThreadNames.setLabelText(Tr::tr("Display thread names"));
showThreadNames.setToolTip(Tr::tr("<p>Displays names of QThread based threads."));
//
// Breakpoints
//
synchronizeBreakpoints.setLabelText(tr("Synchronize Breakpoints"));
synchronizeBreakpoints.setLabelText(Tr::tr("Synchronize Breakpoints"));
adjustBreakpointLocations.setDisplayName(tr("Adjust Breakpoint Locations"));
adjustBreakpointLocations.setToolTip(tr("<p>Not all source code lines generate "
adjustBreakpointLocations.setDisplayName(Tr::tr("Adjust Breakpoint Locations"));
adjustBreakpointLocations.setToolTip(Tr::tr("<p>Not all source code lines generate "
"executable code. Putting a breakpoint on such a line acts as "
"if the breakpoint was set on the next line that generated code. "
"Selecting 'Adjust Breakpoint Locations' shifts the red "
@@ -263,9 +263,9 @@ DebuggerSettings::DebuggerSettings()
"breakpoint."));
adjustBreakpointLocations.setDefaultValue(true);
adjustBreakpointLocations.setSettingsKey(debugModeGroup, "AdjustBreakpointLocations");
adjustBreakpointLocations.setLabelText(/*GdbOptionsPage::*/tr(
adjustBreakpointLocations.setLabelText(Tr::tr(
"Adjust breakpoint locations"));
adjustBreakpointLocations.setToolTip(/*GdbOptionsPage::*/tr(
adjustBreakpointLocations.setToolTip(Tr::tr(
"GDB allows setting breakpoints on source lines for which no code \n"
"was generated. In such situations the breakpoint is shifted to the\n"
"next source code line for which code was actually generated.\n"
@@ -273,24 +273,24 @@ DebuggerSettings::DebuggerSettings()
"markers in the source code editor."));
breakOnThrow.setLabelText(tr("Break on \"throw\""));
breakOnThrow.setLabelText(Tr::tr("Break on \"throw\""));
breakOnThrow.setSettingsKey(debugModeGroup, "BreakOnThrow");
breakOnCatch.setLabelText(tr("Break on \"catch\""));
breakOnCatch.setLabelText(Tr::tr("Break on \"catch\""));
breakOnCatch.setSettingsKey(debugModeGroup, "BreakOnCatch");
breakOnWarning.setLabelText(tr("Break on \"qWarning\""));
breakOnWarning.setLabelText(Tr::tr("Break on \"qWarning\""));
breakOnWarning.setSettingsKey(debugModeGroup, "BreakOnWarning");
// FIXME: Move to common settings page.
breakOnWarning.setLabelText(CommonOptionsPage::msgSetBreakpointAtFunction("qWarning"));
breakOnWarning.setToolTip(CommonOptionsPage::msgSetBreakpointAtFunctionToolTip("qWarning"));
breakOnFatal.setLabelText(tr("Break on \"qFatal\""));
breakOnFatal.setLabelText(Tr::tr("Break on \"qFatal\""));
breakOnFatal.setSettingsKey(debugModeGroup, "BreakOnFatal");
breakOnFatal.setLabelText(CommonOptionsPage::msgSetBreakpointAtFunction("qFatal"));
breakOnFatal.setToolTip(CommonOptionsPage::msgSetBreakpointAtFunctionToolTip("qFatal"));
breakOnAbort.setLabelText(tr("Break on \"abort\""));
breakOnAbort.setLabelText(Tr::tr("Break on \"abort\""));
breakOnAbort.setSettingsKey(debugModeGroup, "BreakOnAbort");
breakOnAbort.setLabelText(CommonOptionsPage::msgSetBreakpointAtFunction("abort"));
breakOnAbort.setToolTip(CommonOptionsPage::msgSetBreakpointAtFunctionToolTip("abort"));
@@ -301,46 +301,46 @@ DebuggerSettings::DebuggerSettings()
loadGdbInit.setSettingsKey(debugModeGroup, "LoadGdbInit");
loadGdbInit.setDefaultValue(true);
loadGdbInit.setLabelText(/*GdbOptionsPage::*/tr("Load .gdbinit file on startup"));
loadGdbInit.setToolTip(/*GdbOptionsPage::*/tr(
loadGdbInit.setLabelText(Tr::tr("Load .gdbinit file on startup"));
loadGdbInit.setToolTip(Tr::tr(
"Allows or inhibits reading the user's default\n"
".gdbinit file on debugger startup."));
loadGdbDumpers.setSettingsKey(debugModeGroup, "LoadGdbDumpers2");
loadGdbDumpers.setLabelText(/*GdbOptionsPage::*/tr("Load system GDB pretty printers"));
loadGdbDumpers.setToolTip(/*GdbOptionsPage::*/tr(
loadGdbDumpers.setLabelText(Tr::tr("Load system GDB pretty printers"));
loadGdbDumpers.setToolTip(Tr::tr(
"Uses the default GDB pretty printers installed in your "
"system or linked to the libraries your application uses."));
autoEnrichParameters.setSettingsKey(debugModeGroup, "AutoEnrichParameters");
autoEnrichParameters.setDefaultValue(true);
autoEnrichParameters.setLabelText(/*GdbOptionsPage::*/tr(
autoEnrichParameters.setLabelText(Tr::tr(
"Use common locations for debug information"));
autoEnrichParameters.setToolTip(/*GdbOptionsPage::*/tr(
autoEnrichParameters.setToolTip(Tr::tr(
"<html><head/><body>Adds common paths to locations "
"of debug information such as <i>/usr/src/debug</i> "
"when starting GDB.</body></html>"));
useDynamicType.setSettingsKey(debugModeGroup, "UseDynamicType");
useDynamicType.setDefaultValue(true);
useDynamicType.setDisplayName(tr("Use Dynamic Object Type for Display"));
useDynamicType.setLabelText(/*GdbOptionsPage::*/tr(
useDynamicType.setDisplayName(Tr::tr("Use Dynamic Object Type for Display"));
useDynamicType.setLabelText(Tr::tr(
"Use dynamic object type for display"));
useDynamicType.setToolTip(/*GdbOptionsPage::*/tr(
useDynamicType.setToolTip(Tr::tr(
"Specifies whether the dynamic or the static type of objects will be "
"displayed. Choosing the dynamic type might be slower."));
targetAsync.setSettingsKey(debugModeGroup, "TargetAsync");
targetAsync.setLabelText(/*GdbOptionsPage::*/tr(
targetAsync.setLabelText(Tr::tr(
"Use asynchronous mode to control the inferior"));
warnOnReleaseBuilds.setSettingsKey(debugModeGroup, "WarnOnReleaseBuilds");
warnOnReleaseBuilds.setDefaultValue(true);
warnOnReleaseBuilds.setLabelText(tr("Warn when debugging \"Release\" builds"));
warnOnReleaseBuilds.setToolTip(tr("Shows a warning when starting the debugger "
warnOnReleaseBuilds.setLabelText(Tr::tr("Warn when debugging \"Release\" builds"));
warnOnReleaseBuilds.setToolTip(Tr::tr("Shows a warning when starting the debugger "
"on a binary with insufficient debug information."));
QString howToUsePython = /*GdbOptionsPage::*/tr(
QString howToUsePython = Tr::tr(
"<p>To execute simple Python commands, prefix them with \"python\".</p>"
"<p>To execute sequences of Python commands spanning multiple lines "
"prepend the block with \"python\" on a separate line, and append "
@@ -351,7 +351,7 @@ DebuggerSettings::DebuggerSettings()
gdbStartupCommands.setSettingsKey(debugModeGroup, "GdbStartupCommands");
gdbStartupCommands.setDisplayStyle(StringAspect::TextEditDisplay);
gdbStartupCommands.setUseGlobalMacroExpander();
gdbStartupCommands.setToolTip("<html><head/><body><p>" + /*GdbOptionsPage::*/tr(
gdbStartupCommands.setToolTip("<html><head/><body><p>" + Tr::tr(
"GDB commands entered here will be executed after "
"GDB has been started, but before the debugged program is started or "
"attached, and before the debugging helpers are initialized.") + "</p>"
@@ -360,7 +360,7 @@ DebuggerSettings::DebuggerSettings()
gdbPostAttachCommands.setSettingsKey(debugModeGroup, "GdbPostAttachCommands");
gdbPostAttachCommands.setDisplayStyle(StringAspect::TextEditDisplay);
gdbPostAttachCommands.setUseGlobalMacroExpander();
gdbPostAttachCommands.setToolTip("<html><head/><body><p>" + /*GdbOptionsPage::*/tr(
gdbPostAttachCommands.setToolTip("<html><head/><body><p>" + Tr::tr(
"GDB commands entered here will be executed after "
"GDB has successfully attached to remote targets.</p>"
"<p>You can add commands to further set up the target here, "
@@ -371,102 +371,100 @@ DebuggerSettings::DebuggerSettings()
extraDumperCommands.setDisplayStyle(StringAspect::TextEditDisplay);
extraDumperCommands.setUseGlobalMacroExpander();
extraDumperCommands.setToolTip("<html><head/><body><p>"
+ tr("Python commands entered here will be executed after built-in "
+ Tr::tr("Python commands entered here will be executed after built-in "
"debugging helpers have been loaded and fully initialized. You can "
"load additional debugging helpers or modify existing ones here.")
+ "</p></body></html>");
extraDumperFile.setSettingsKey(debugModeGroup, "ExtraDumperFile");
extraDumperFile.setDisplayStyle(StringAspect::PathChooserDisplay);
extraDumperFile.setDisplayName(tr("Extra Debugging Helpers"));
extraDumperFile.setDisplayName(Tr::tr("Extra Debugging Helpers"));
// Label text is intentional empty in the GUI.
extraDumperFile.setToolTip(tr("Path to a Python file containing additional data dumpers."));
extraDumperFile.setToolTip(Tr::tr("Path to a Python file containing additional data dumpers."));
const QString t = tr("Stopping and stepping in the debugger "
const QString t = Tr::tr("Stopping and stepping in the debugger "
"will automatically open views associated with the current location.") + '\n';
closeSourceBuffersOnExit.setSettingsKey(debugModeGroup, "CloseBuffersOnExit");
closeSourceBuffersOnExit.setLabelText(tr("Close temporary source views on debugger exit"));
closeSourceBuffersOnExit.setToolTip(t + tr("Closes automatically opened source views when the debugger exits."));
closeSourceBuffersOnExit.setLabelText(Tr::tr("Close temporary source views on debugger exit"));
closeSourceBuffersOnExit.setToolTip(t + Tr::tr("Closes automatically opened source views when the debugger exits."));
closeMemoryBuffersOnExit.setSettingsKey(debugModeGroup, "CloseMemoryBuffersOnExit");
closeMemoryBuffersOnExit.setDefaultValue(true);
closeMemoryBuffersOnExit.setLabelText(tr("Close temporary memory views on debugger exit"));
closeMemoryBuffersOnExit.setToolTip(t + tr("Closes automatically opened memory views when the debugger exits."));
closeMemoryBuffersOnExit.setLabelText(Tr::tr("Close temporary memory views on debugger exit"));
closeMemoryBuffersOnExit.setToolTip(t + Tr::tr("Closes automatically opened memory views when the debugger exits."));
switchModeOnExit.setSettingsKey(debugModeGroup, "SwitchModeOnExit");
switchModeOnExit.setLabelText(tr("Switch to previous mode on debugger exit"));
switchModeOnExit.setLabelText(Tr::tr("Switch to previous mode on debugger exit"));
breakpointsFullPathByDefault.setSettingsKey(debugModeGroup, "BreakpointsFullPath");
breakpointsFullPathByDefault.setToolTip(tr("Enables a full file path in breakpoints by default also for GDB."));
breakpointsFullPathByDefault.setLabelText(tr("Set breakpoints using a full absolute path"));
breakpointsFullPathByDefault.setToolTip(Tr::tr("Enables a full file path in breakpoints by default also for GDB."));
breakpointsFullPathByDefault.setLabelText(Tr::tr("Set breakpoints using a full absolute path"));
raiseOnInterrupt.setSettingsKey(debugModeGroup, "RaiseOnInterrupt");
raiseOnInterrupt.setDefaultValue(true);
raiseOnInterrupt.setLabelText(tr("Bring %1 to foreground when application interrupts")
raiseOnInterrupt.setLabelText(Tr::tr("Bring %1 to foreground when application interrupts")
.arg(Core::Constants::IDE_DISPLAY_NAME));
autoQuit.setSettingsKey(debugModeGroup, "AutoQuit");
autoQuit.setLabelText(tr("Automatically Quit Debugger"));
autoQuit.setLabelText(Tr::tr("Automatically Quit Debugger"));
multiInferior.setSettingsKey(debugModeGroup, "MultiInferior");
multiInferior.setLabelText(/*GdbOptionsPage::*/tr("Debug all child processes"));
multiInferior.setToolTip(/*GdbOptionsPage::*/tr(
multiInferior.setLabelText(Tr::tr("Debug all child processes"));
multiInferior.setToolTip(Tr::tr(
"<html><head/><body>Keeps debugging all children after a fork."
"</body></html>"));
intelFlavor.setSettingsKey(debugModeGroup, "IntelFlavor");
intelFlavor.setLabelText(/*GdbOptionsPage::*/tr("Use Intel style disassembly"));
intelFlavor.setToolTip(/*GdbOptionsPage::*/tr(
"GDB shows by default AT&&T style disassembly."));
intelFlavor.setLabelText(Tr::tr("Use Intel style disassembly"));
intelFlavor.setToolTip(Tr::tr("GDB shows by default AT&&T style disassembly."));
useAnnotationsInMainEditor.setSettingsKey(debugModeGroup, "UseAnnotations");
useAnnotationsInMainEditor.setLabelText(tr("Use annotations in main editor when debugging"));
useAnnotationsInMainEditor.setToolTip(tr("<p>Shows simple variable values "
useAnnotationsInMainEditor.setLabelText(Tr::tr("Use annotations in main editor when debugging"));
useAnnotationsInMainEditor.setToolTip(Tr::tr("<p>Shows simple variable values "
"as annotations in the main editor during debugging."));
useAnnotationsInMainEditor.setDefaultValue(true);
usePseudoTracepoints.setSettingsKey(debugModeGroup, "UsePseudoTracepoints");
usePseudoTracepoints.setLabelText(/*GdbOptionsPage::*/tr("Use pseudo message tracepoints"));
usePseudoTracepoints.setToolTip(
/*GdbOptionsPage::*/ tr("Uses Python to extend the ordinary GDB breakpoint class."));
usePseudoTracepoints.setLabelText(Tr::tr("Use pseudo message tracepoints"));
usePseudoTracepoints.setToolTip(Tr::tr("Uses Python to extend the ordinary GDB breakpoint class."));
usePseudoTracepoints.setDefaultValue(true);
useIndexCache.setSettingsKey(debugModeGroup, "UseIndexCache");
useIndexCache.setLabelText(tr("Use automatic symbol cache"));
useIndexCache.setToolTip(tr("It is possible for GDB to automatically save a copy of "
useIndexCache.setLabelText(Tr::tr("Use automatic symbol cache"));
useIndexCache.setToolTip(Tr::tr("It is possible for GDB to automatically save a copy of "
"its symbol index in a cache on disk and retrieve it from there when loading the same "
"binary in the future."));
useIndexCache.setDefaultValue(true);
useToolTipsInMainEditor.setSettingsKey(debugModeGroup, "UseToolTips");
useToolTipsInMainEditor.setLabelText(tr("Use tooltips in main editor when debugging"));
useToolTipsInMainEditor.setToolTip(tr("<p>Enables tooltips for variable "
useToolTipsInMainEditor.setLabelText(Tr::tr("Use tooltips in main editor when debugging"));
useToolTipsInMainEditor.setToolTip(Tr::tr("<p>Enables tooltips for variable "
"values during debugging. Since this can slow down debugging and "
"does not provide reliable information as it does not use scope "
"information, it is switched off by default."));
useToolTipsInMainEditor.setDefaultValue(true);
useToolTipsInLocalsView.setSettingsKey(debugModeGroup, "UseToolTipsInLocalsView");
useToolTipsInLocalsView.setLabelText(tr("Use Tooltips in Locals View when Debugging"));
useToolTipsInLocalsView.setToolTip(tr("<p>Enables tooltips in the locals "
useToolTipsInLocalsView.setLabelText(Tr::tr("Use Tooltips in Locals View when Debugging"));
useToolTipsInLocalsView.setToolTip(Tr::tr("<p>Enables tooltips in the locals "
"view during debugging."));
useToolTipsInBreakpointsView.setSettingsKey(debugModeGroup, "UseToolTipsInBreakpointsView");
useToolTipsInBreakpointsView.setLabelText(tr("Use Tooltips in Breakpoints View when Debugging"));
useToolTipsInBreakpointsView.setToolTip(tr("<p>Enables tooltips in the breakpoints "
useToolTipsInBreakpointsView.setLabelText(Tr::tr("Use Tooltips in Breakpoints View when Debugging"));
useToolTipsInBreakpointsView.setToolTip(Tr::tr("<p>Enables tooltips in the breakpoints "
"view during debugging."));
useToolTipsInStackView.setSettingsKey(debugModeGroup, "UseToolTipsInStackView");
useToolTipsInStackView.setLabelText(tr("Use Tooltips in Stack View when Debugging"));
useToolTipsInStackView.setToolTip(tr("<p>Enables tooltips in the stack "
useToolTipsInStackView.setLabelText(Tr::tr("Use Tooltips in Stack View when Debugging"));
useToolTipsInStackView.setToolTip(Tr::tr("<p>Enables tooltips in the stack "
"view during debugging."));
useToolTipsInStackView.setDefaultValue(true);
skipKnownFrames.setSettingsKey(debugModeGroup, "SkipKnownFrames");
skipKnownFrames.setDisplayName(tr("Skip Known Frames"));
skipKnownFrames.setLabelText(/*GdbOptionsPage::*/tr("Skip known frames when stepping"));
skipKnownFrames.setToolTip(/*GdbOptionsPage::*/tr(
skipKnownFrames.setDisplayName(Tr::tr("Skip Known Frames"));
skipKnownFrames.setLabelText(Tr::tr("Skip known frames when stepping"));
skipKnownFrames.setToolTip(Tr::tr(
"<html><head/><body><p>"
"Allows <i>Step Into</i> to compress several steps into one step\n"
"for less noisy debugging. For example, the atomic reference\n"
@@ -475,9 +473,9 @@ DebuggerSettings::DebuggerSettings()
enableReverseDebugging.setSettingsKey(debugModeGroup, "EnableReverseDebugging");
enableReverseDebugging.setIcon(Icons::REVERSE_MODE.icon());
enableReverseDebugging.setDisplayName(tr("Enable Reverse Debugging"));
enableReverseDebugging.setLabelText(/*GdbOptionsPage::*/tr("Enable reverse debugging"));
enableReverseDebugging.setToolTip(/*GdbOptionsPage::*/tr(
enableReverseDebugging.setDisplayName(Tr::tr("Enable Reverse Debugging"));
enableReverseDebugging.setLabelText(Tr::tr("Enable reverse debugging"));
enableReverseDebugging.setToolTip(Tr::tr(
"<html><head/><body><p>Enables stepping backwards.</p><p>"
"<b>Note:</b> This feature is very slow and unstable on the GDB side. "
"It exhibits unpredictable behavior when going backwards over system "
@@ -488,10 +486,10 @@ DebuggerSettings::DebuggerSettings()
registerForPostMortem = new RegisterPostMortemAction;
registerForPostMortem->setSettingsKey(debugModeGroup, "RegisterForPostMortem");
registerForPostMortem->setToolTip(
tr("Registers %1 for debugging crashed applications.")
Tr::tr("Registers %1 for debugging crashed applications.")
.arg(Core::Constants::IDE_DISPLAY_NAME));
registerForPostMortem->setLabelText(
tr("Use %1 for post-mortem debugging")
Tr::tr("Use %1 for post-mortem debugging")
.arg(Core::Constants::IDE_DISPLAY_NAME));
#else
// Some dummy.
@@ -511,40 +509,40 @@ DebuggerSettings::DebuggerSettings()
maximalStackDepth.setSettingsKey(debugModeGroup, "MaximalStackDepth");
maximalStackDepth.setDefaultValue(20);
maximalStackDepth.setSpecialValueText(tr("<unlimited>"));
maximalStackDepth.setSpecialValueText(Tr::tr("<unlimited>"));
maximalStackDepth.setRange(0, 1000);
maximalStackDepth.setSingleStep(5);
maximalStackDepth.setLabelText(tr("Maximum stack depth:"));
maximalStackDepth.setLabelText(Tr::tr("Maximum stack depth:"));
displayStringLimit.setSettingsKey(debugModeGroup, "DisplayStringLimit");
displayStringLimit.setDefaultValue(300);
displayStringLimit.setSpecialValueText(tr("<unlimited>"));
displayStringLimit.setSpecialValueText(Tr::tr("<unlimited>"));
displayStringLimit.setRange(20, 10000);
displayStringLimit.setSingleStep(10);
displayStringLimit.setLabelText(tr("Display string length:"));
displayStringLimit.setToolTip(tr("<p>The maximum length of string entries in the "
displayStringLimit.setLabelText(Tr::tr("Display string length:"));
displayStringLimit.setToolTip(Tr::tr("<p>The maximum length of string entries in the "
"Locals and Expressions views. Longer than that are cut off "
"and displayed with an ellipsis attached."));
maximalStringLength.setSettingsKey(debugModeGroup, "MaximalStringLength");
maximalStringLength.setDefaultValue(10000);
maximalStringLength.setSpecialValueText(tr("<unlimited>"));
maximalStringLength.setSpecialValueText(Tr::tr("<unlimited>"));
maximalStringLength.setRange(20, 10000000);
maximalStringLength.setSingleStep(20);
maximalStringLength.setLabelText(tr("Maximum string length:"));
maximalStringLength.setToolTip(tr("<p>The maximum length for strings in separated windows. "
maximalStringLength.setLabelText(Tr::tr("Maximum string length:"));
maximalStringLength.setToolTip(Tr::tr("<p>The maximum length for strings in separated windows. "
"Longer strings are cut off and displayed with an ellipsis attached."));
expandStack.setLabelText(tr("Reload Full Stack"));
expandStack.setLabelText(Tr::tr("Reload Full Stack"));
createFullBacktrace.setLabelText(tr("Create Full Backtrace"));
createFullBacktrace.setLabelText(Tr::tr("Create Full Backtrace"));
gdbWatchdogTimeout.setSettingsKey(debugModeGroup, "WatchdogTimeout");
gdbWatchdogTimeout.setDefaultValue(20);
gdbWatchdogTimeout.setSuffix(/*GdbOptionsPage::*/tr("sec"));
gdbWatchdogTimeout.setSuffix(Tr::tr("sec"));
gdbWatchdogTimeout.setRange(20, 1000000);
gdbWatchdogTimeout.setLabelText(/*GdbOptionsPage::*/tr("GDB timeout:"));
gdbWatchdogTimeout.setToolTip(/*GdbOptionsPage::*/tr(
gdbWatchdogTimeout.setLabelText(Tr::tr("GDB timeout:"));
gdbWatchdogTimeout.setToolTip(Tr::tr(
"The number of seconds before a non-responsive GDB process is terminated.\n"
"The default value of 20 seconds should be sufficient for most\n"
"applications, but there are situations when loading big libraries or\n"
@@ -556,8 +554,9 @@ DebuggerSettings::DebuggerSettings()
//
showQmlObjectTree.setSettingsKey(debugModeGroup, "ShowQmlObjectTree");
showQmlObjectTree.setDefaultValue(true);
showQmlObjectTree.setToolTip(tr("Shows QML object tree in Locals and Expressions when connected and not stepping."));
showQmlObjectTree.setLabelText(tr("Show QML object tree"));
showQmlObjectTree.setToolTip(Tr::tr("Shows QML object tree in Locals and Expressions "
"when connected and not stepping."));
showQmlObjectTree.setLabelText(Tr::tr("Show QML object tree"));
const QString qmlInspectorGroup = "QML.Inspector";
showAppOnTop.setSettingsKey(qmlInspectorGroup, "QmlInspector.ShowAppOnTop");
@@ -697,6 +696,5 @@ QString DebuggerSettings::dump()
return "Debugger settings:\n" + settings.join('\n');
}
} // namespace Internal
} // namespace Debugger
} // Debugger::Internal