eric: comparison Debugger/DebugUI.py

-:c99695c0f13a
+:f53c03574697
 """
 Class implementing the debugger part of the UI.
 @signal clientStack(stack) emitted at breaking after a reported exception
 @signal compileForms() emitted if changed project forms should be compiled
-@signal compileResources() emitted if changed project resources should be compiled
+@signal compileResources() emitted if changed project resources should be
-@signal debuggingStarted(filename) emitted when a debugging session was started
+compiled
+@signal debuggingStarted(filename) emitted when a debugging session was
+started
 @signal resetUI() emitted to reset the UI
-@signal exceptionInterrupt() emitted after the execution was interrupted by an
+@signal exceptionInterrupt() emitted after the execution was interrupted
-exception and acknowledged by the user
+by an exception and acknowledged by the user
-@signal appendStdout(msg) emitted when the client program has terminated and the
+@signal appendStdout(msg) emitted when the client program has terminated
-display of the termination dialog is suppressed
+and the display of the termination dialog is suppressed
 """
 clientStack = pyqtSignal(list)
 resetUI = pyqtSignal()
 exceptionInterrupt = pyqtSignal()
 compileForms = pyqtSignal()
 # read the saved debug info values
 self.argvHistory = Preferences.toList(
 Preferences.Prefs.settings.value('DebugInfo/ArgumentsHistory'))
 self.wdHistory = Preferences.toList(
-Preferences.Prefs.settings.value('DebugInfo/WorkingDirectoryHistory'))
+Preferences.Prefs.settings.value(
+'DebugInfo/WorkingDirectoryHistory'))
 self.envHistory = Preferences.toList(
 Preferences.Prefs.settings.value('DebugInfo/EnvironmentHistory'))
 self.excList = Preferences.toList(
 Preferences.Prefs.settings.value('DebugInfo/Exceptions'))
 self.excIgnoreList = Preferences.toList(
 Preferences.Prefs.settings.value('DebugInfo/IgnoredExceptions'))
 self.exceptions = Preferences.toBool(
-Preferences.Prefs.settings.value('DebugInfo/ReportExceptions', True))
+Preferences.Prefs.settings.value(
+'DebugInfo/ReportExceptions', True))
 self.autoClearShell = Preferences.toBool(
 Preferences.Prefs.settings.value('DebugInfo/AutoClearShell', True))
 self.tracePython = Preferences.toBool(
 Preferences.Prefs.settings.value('DebugInfo/TracePython', False))
 self.autoContinue = Preferences.toBool(
 Preferences.Prefs.settings.value('DebugInfo/AutoContinue', True))
 self.forkAutomatically = Preferences.toBool(
-Preferences.Prefs.settings.value('DebugInfo/ForkAutomatically', False))
+Preferences.Prefs.settings.value(
+'DebugInfo/ForkAutomatically', False))
 self.forkIntoChild = Preferences.toBool(
 Preferences.Prefs.settings.value('DebugInfo/ForkIntoChild', False))
 self.evalHistory = []
 self.execHistory = []
 self.clientType = ""
 self.lastAction = -1
 self.debugActions = [self.__continue, self.__step,\
 self.__stepOver, self.__stepOut,\
 self.__stepQuit, self.__runToCursor]
-self.localsVarFilter, self.globalsVarFilter = Preferences.getVarFilters()
+self.localsVarFilter, self.globalsVarFilter = \
-self.debugViewer.setVariablesFilter(self.globalsVarFilter, self.localsVarFilter)
+Preferences.getVarFilters()
+self.debugViewer.setVariablesFilter(
+self.globalsVarFilter, self.localsVarFilter)
 # Connect the signals emitted by the debug-server
 debugServer.clientGone.connect(self.__clientGone)
 debugServer.clientLine.connect(self.__clientLine)
 debugServer.clientExit.connect(self.__clientExit)
 debugServer.clientSyntaxError.connect(self.__clientSyntaxError)
 debugServer.clientException.connect(self.__clientException)
 debugServer.clientVariables.connect(self.__clientVariables)
 debugServer.clientVariable.connect(self.__clientVariable)
-debugServer.clientBreakConditionError.connect(self.__clientBreakConditionError)
+debugServer.clientBreakConditionError.connect(
-debugServer.clientWatchConditionError.connect(self.__clientWatchConditionError)
+self.__clientBreakConditionError)
+debugServer.clientWatchConditionError.connect(
+self.__clientWatchConditionError)
 debugServer.passiveDebugStarted.connect(self.__passiveDebugStarted)
 debugServer.clientThreadSet.connect(self.__clientThreadSet)
 debugServer.clientRawInput.connect(debugViewer.handleRawInput)
 debugServer.clientRawInputSent.connect(debugViewer.restoreCurrentPage)
 """
 self.actions = []
 self.runAct = E5Action(self.trUtf8('Run Script'),
 UI.PixmapCache.getIcon("runScript.png"),
-self.trUtf8('&Run Script...'), Qt.Key_F2, 0, self, 'dbg_run_script')
+self.trUtf8('&Run Script...'),
+Qt.Key_F2, 0, self, 'dbg_run_script')
 self.runAct.setStatusTip(self.trUtf8('Run the current Script'))
 self.runAct.setWhatsThis(self.trUtf8(
 """<b>Run Script</b>"""
-"""<p>Set the command line arguments and run the script outside the"""
+"""<p>Set the command line arguments and run the script outside"""
-""" debugger. If the file has unsaved changes it may be saved first.</p>"""
+""" the debugger. If the file has unsaved changes it may be"""
+""" saved first.</p>"""
 ))
 self.runAct.triggered[()].connect(self.__runScript)
 self.actions.append(self.runAct)
 self.runProjectAct = E5Action(self.trUtf8('Run Project'),
 self.runProjectAct.setStatusTip(self.trUtf8('Run the current Project'))
 self.runProjectAct.setWhatsThis(self.trUtf8(
 """<b>Run Project</b>"""
 """<p>Set the command line arguments and run the current project"""
 """ outside the debugger."""
-""" If files of the current project have unsaved changes they may"""
+""" If files of the current project have unsaved changes they"""
-""" be saved first.</p>"""
+""" may be saved first.</p>"""
 ))
 self.runProjectAct.triggered[()].connect(self.__runProject)
 self.actions.append(self.runProjectAct)
 self.coverageAct = E5Action(self.trUtf8('Coverage run of Script'),
 UI.PixmapCache.getIcon("coverageScript.png"),
-self.trUtf8('Coverage run of Script...'), 0, 0, self, 'dbg_coverage_script')
+self.trUtf8('Coverage run of Script...'), 0, 0, self,
+'dbg_coverage_script')
 self.coverageAct.setStatusTip(
 self.trUtf8('Perform a coverage run of the current Script'))
 self.coverageAct.setWhatsThis(self.trUtf8(
 """<b>Coverage run of Script</b>"""
-"""<p>Set the command line arguments and run the script under the control"""
+"""<p>Set the command line arguments and run the script under"""
-""" of a coverage analysis tool. If the file has unsaved changes it may be"""
+""" the control of a coverage analysis tool. If the file has"""
-""" saved first.</p>"""
+""" unsaved changes it may be saved first.</p>"""
 ))
 self.coverageAct.triggered[()].connect(self.__coverageScript)
 self.actions.append(self.coverageAct)
-self.coverageProjectAct = E5Action(self.trUtf8('Coverage run of Project'),
+self.coverageProjectAct = E5Action(
-UI.PixmapCache.getIcon("coverageProject.png"),
+self.trUtf8('Coverage run of Project'),
-self.trUtf8('Coverage run of Project...'), 0, 0, self, 'dbg_coverage_project')
+UI.PixmapCache.getIcon("coverageProject.png"),
+self.trUtf8('Coverage run of Project...'), 0, 0, self,
+'dbg_coverage_project')
 self.coverageProjectAct.setStatusTip(
 self.trUtf8('Perform a coverage run of the current Project'))
 self.coverageProjectAct.setWhatsThis(self.trUtf8(
 """<b>Coverage run of Project</b>"""
 """<p>Set the command line arguments and run the current project"""
 """ under the control of a coverage analysis tool."""
-""" If files of the current project have unsaved changes they may"""
+""" If files of the current project have unsaved changes"""
-""" be saved first.</p>"""
+""" they may be saved first.</p>"""
 ))
 self.coverageProjectAct.triggered[()].connect(self.__coverageProject)
 self.actions.append(self.coverageProjectAct)
 self.profileAct = E5Action(self.trUtf8('Profile Script'),
 UI.PixmapCache.getIcon("profileScript.png"),
 self.trUtf8('Profile Script...'), 0, 0, self, 'dbg_profile_script')
 self.profileAct.setStatusTip(self.trUtf8('Profile the current Script'))
 self.profileAct.setWhatsThis(self.trUtf8(
 """<b>Profile Script</b>"""
 """<p>Set the command line arguments and profile the script."""
 """ If the file has unsaved changes it may be saved first.</p>"""
 ))
 self.profileAct.triggered[()].connect(self.__profileScript)
 self.actions.append(self.profileAct)
 self.profileProjectAct = E5Action(self.trUtf8('Profile Project'),
 UI.PixmapCache.getIcon("profileProject.png"),
-self.trUtf8('Profile Project...'), 0, 0, self, 'dbg_profile_project')
+self.trUtf8('Profile Project...'), 0, 0, self,
-self.profileProjectAct.setStatusTip(self.trUtf8('Profile the current Project'))
+'dbg_profile_project')
+self.profileProjectAct.setStatusTip(
+self.trUtf8('Profile the current Project'))
 self.profileProjectAct.setWhatsThis(self.trUtf8(
 """<b>Profile Project</b>"""
-"""<p>Set the command line arguments and profile the current project."""
+"""<p>Set the command line arguments and profile the current"""
-""" If files of the current project have unsaved changes they may"""
+""" project. If files of the current project have unsaved"""
-""" be saved first.</p>"""
+""" changes they may be saved first.</p>"""
 ))
 self.profileProjectAct.triggered[()].connect(self.__profileProject)
 self.actions.append(self.profileProjectAct)
 self.debugAct = E5Action(self.trUtf8('Debug Script'),
 UI.PixmapCache.getIcon("debugScript.png"),
-self.trUtf8('&Debug Script...'), Qt.Key_F5, 0, self, 'dbg_debug_script')
+self.trUtf8('&Debug Script...'), Qt.Key_F5, 0, self,
+'dbg_debug_script')
 self.debugAct.setStatusTip(self.trUtf8('Debug the current Script'))
 self.debugAct.setWhatsThis(self.trUtf8(
 """<b>Debug Script</b>"""
-"""<p>Set the command line arguments and set the current line to be the"""
+"""<p>Set the command line arguments and set the current line"""
-""" first executable Python statement of the current editor window."""
+""" to be the first executable Python statement of the current"""
-""" If the file has unsaved changes it may be saved first.</p>"""
+""" editor window. If the file has unsaved changes it may be"""
+""" saved first.</p>"""
 ))
 self.debugAct.triggered[()].connect(self.__debugScript)
 self.actions.append(self.debugAct)
 self.debugProjectAct = E5Action(self.trUtf8('Debug Project'),
 UI.PixmapCache.getIcon("debugProject.png"),
 self.trUtf8('Debug &Project...'), Qt.SHIFT + Qt.Key_F5, 0, self,
 'dbg_debug_project')
-self.debugProjectAct.setStatusTip(self.trUtf8('Debug the current Project'))
+self.debugProjectAct.setStatusTip(self.trUtf8(
+'Debug the current Project'))
 self.debugProjectAct.setWhatsThis(self.trUtf8(
 """<b>Debug Project</b>"""
-"""<p>Set the command line arguments and set the current line to be the"""
+"""<p>Set the command line arguments and set the current line"""
-""" first executable Python statement of the main script of the current"""
+""" to be the first executable Python statement of the main"""
-""" project. If files of the current project have unsaved changes they may"""
+""" script of the current project. If files of the current"""
-""" be saved first.</p>"""
+""" project have unsaved changes they may be saved first.</p>"""
 ))
 self.debugProjectAct.triggered[()].connect(self.__debugProject)
 self.actions.append(self.debugProjectAct)
 self.restartAct = E5Action(self.trUtf8('Restart'),
 UI.PixmapCache.getIcon("restart.png"),
 self.trUtf8('Restart'), Qt.Key_F4, 0, self, 'dbg_restart_script')
-self.restartAct.setStatusTip(self.trUtf8('Restart the last debugged script'))
+self.restartAct.setStatusTip(self.trUtf8(
+'Restart the last debugged script'))
 self.restartAct.setWhatsThis(self.trUtf8(
 """<b>Restart</b>"""
-"""<p>Set the command line arguments and set the current line to be the"""
+"""<p>Set the command line arguments and set the current line"""
-""" first executable Python statement of the script that was debugged last."""
+""" to be the first executable Python statement of the script"""
-""" If there are unsaved changes, they may be saved first.</p>"""
+""" that was debugged last. If there are unsaved changes, they"""
+""" may be saved first.</p>"""
 ))
 self.restartAct.triggered[()].connect(self.__doRestart)
 self.actions.append(self.restartAct)
 self.stopAct = E5Action(self.trUtf8('Stop'),
 UI.PixmapCache.getIcon("stopScript.png"),
 self.trUtf8('Stop'), Qt.SHIFT + Qt.Key_F10, 0,
 self, 'dbg_stop_script')
 self.stopAct.setStatusTip(self.trUtf8("""Stop the running script."""))
 self.stopAct.setWhatsThis(self.trUtf8(
 """<b>Stop</b>"""
 """<p>This stops the script running in the debugger backend.</p>"""
 ))
 self.actions.append(self.stopAct)
 self.debugActGrp = createActionGroup(self)
 act = E5Action(self.trUtf8('Continue'),
 UI.PixmapCache.getIcon("continue.png"),
 self.trUtf8('&Continue'), Qt.Key_F6, 0,
 self.debugActGrp, 'dbg_continue')
 act.setStatusTip(
 self.trUtf8('Continue running the program from the current line'))
 act.setWhatsThis(self.trUtf8(
 """<b>Continue</b>"""
-"""<p>Continue running the program from the current line. The program will"""
+"""<p>Continue running the program from the current line. The"""
-""" stop when it terminates or when a breakpoint is reached.</p>"""
+""" program will stop when it terminates or when a breakpoint"""
+""" is reached.</p>"""
 ))
 act.triggered[()].connect(self.__continue)
 self.actions.append(act)
 act = E5Action(self.trUtf8('Continue to Cursor'),
 UI.PixmapCache.getIcon("continueToCursor.png"),
 self.trUtf8('Continue &To Cursor'), Qt.SHIFT + Qt.Key_F6, 0,
 self.debugActGrp, 'dbg_continue_to_cursor')
-act.setStatusTip(self.trUtf8("""Continue running the program from the"""
+act.setStatusTip(self.trUtf8(
+"""Continue running the program from the"""
 """ current line to the current cursor position"""))
 act.setWhatsThis(self.trUtf8(
 """<b>Continue To Cursor</b>"""
 """<p>Continue running the program from the current line to the"""
 """ current cursor position.</p>"""
 ))
 act.triggered[()].connect(self.__runToCursor)
 self.actions.append(act)
 act = E5Action(self.trUtf8('Single Step'),
 UI.PixmapCache.getIcon("step.png"),
 self.trUtf8('Sin&gle Step'), Qt.Key_F7, 0,
 self.debugActGrp, 'dbg_single_step')
 act.setStatusTip(self.trUtf8('Execute a single Python statement'))
 act.setWhatsThis(self.trUtf8(
 """<b>Single Step</b>"""
 """<p>Execute a single Python statement. If the statement"""
 """ is an <tt>import</tt> statement, a class constructor, or a"""
-""" method or function call then control is returned to the debugger at"""
+""" method or function call then control is returned to the"""
-""" the next statement.</p>"""
+""" debugger at the next statement.</p>"""
 ))
 act.triggered[()].connect(self.__step)
 self.actions.append(act)
 act = E5Action(self.trUtf8('Step Over'),
 UI.PixmapCache.getIcon("stepOver.png"),
 self.trUtf8('Step &Over'), Qt.Key_F8, 0,
 self.debugActGrp, 'dbg_step_over')
-act.setStatusTip(self.trUtf8("""Execute a single Python statement staying"""
+act.setStatusTip(self.trUtf8(
+"""Execute a single Python statement staying"""
 """ in the current frame"""))
 act.setWhatsThis(self.trUtf8(
 """<b>Step Over</b>"""
-"""<p>Execute a single Python statement staying in the same frame. If"""
+"""<p>Execute a single Python statement staying in the same"""
-""" the statement is an <tt>import</tt> statement, a class constructor,"""
+""" frame. If the statement is an <tt>import</tt> statement,"""
-""" or a method or function call then control is returned to the debugger"""
+""" a class constructor, or a method or function call then"""
-""" after the statement has completed.</p>"""
+""" control is returned to the debugger after the statement"""
+""" has completed.</p>"""
 ))
 act.triggered[()].connect(self.__stepOver)
 self.actions.append(act)
 act = E5Action(self.trUtf8('Step Out'),
 UI.PixmapCache.getIcon("stepOut.png"),
 self.trUtf8('Step Ou&t'), Qt.Key_F9, 0,
 self.debugActGrp, 'dbg_step_out')
-act.setStatusTip(self.trUtf8("""Execute Python statements until leaving"""
+act.setStatusTip(self.trUtf8(
+"""Execute Python statements until leaving"""
 """ the current frame"""))
 act.setWhatsThis(self.trUtf8(
 """<b>Step Out</b>"""
-"""<p>Execute Python statements until leaving the current frame. If"""
+"""<p>Execute Python statements until leaving the current"""
-""" the statements are inside an <tt>import</tt> statement, a class"""
+""" frame. If the statements are inside an <tt>import</tt>"""
-""" constructor, or a method or function call then control is returned"""
+""" statement, a class constructor, or a method or function"""
-""" to the debugger after the current frame has been left.</p>"""
+""" call then control is returned to the debugger after the"""
+""" current frame has been left.</p>"""
 ))
 act.triggered[()].connect(self.__stepOut)
 self.actions.append(act)
 act = E5Action(self.trUtf8('Stop'),
 UI.PixmapCache.getIcon("stepQuit.png"),
 self.trUtf8('&Stop'), Qt.Key_F10, 0,
 self.debugActGrp, 'dbg_stop')
 act.setStatusTip(self.trUtf8('Stop debugging'))
 act.setWhatsThis(self.trUtf8(
 """<b>Stop</b>"""
 """<p>Stop the running debugging session.</p>"""
 ))
 self.actions.append(act)
 self.debugActGrp2 = createActionGroup(self)
 act = E5Action(self.trUtf8('Evaluate'),
 self.trUtf8('E&valuate...'),
 0, 0, self.debugActGrp2, 'dbg_evaluate')
 act.setStatusTip(self.trUtf8('Evaluate in current context'))
 act.setWhatsThis(self.trUtf8(
 """<b>Evaluate</b>"""
 """<p>Evaluate an expression in the current context of the"""
 """ debugged program. The result is displayed in the"""
 ))
 act.triggered[()].connect(self.__exec)
 self.actions.append(act)
 self.dbgFilterAct = E5Action(self.trUtf8('Variables Type Filter'),
 self.trUtf8('Varia&bles Type Filter...'), 0, 0, self,
 'dbg_variables_filter')
-self.dbgFilterAct.setStatusTip(self.trUtf8('Configure variables type filter'))
+self.dbgFilterAct.setStatusTip(self.trUtf8(
+'Configure variables type filter'))
 self.dbgFilterAct.setWhatsThis(self.trUtf8(
 """<b>Variables Type Filter</b>"""
-"""<p>Configure the variables type filter. Only variable types that are not"""
+"""<p>Configure the variables type filter. Only variable types"""
-""" selected are displayed in the global or local variables window"""
+""" that are not selected are displayed in the global or local"""
-""" during a debugging session.</p>"""
+""" variables window during a debugging session.</p>"""
 ))
-self.dbgFilterAct.triggered[()].connect(self.__configureVariablesFilters)
+self.dbgFilterAct.triggered[()].connect(
+self.__configureVariablesFilters)
 self.actions.append(self.dbgFilterAct)
 self.excFilterAct = E5Action(self.trUtf8('Exceptions Filter'),
-self.trUtf8('&Exceptions Filter...'), 0, 0, self, 'dbg_exceptions_filter')
+self.trUtf8('&Exceptions Filter...'), 0, 0, self,
-self.excFilterAct.setStatusTip(self.trUtf8('Configure exceptions filter'))
+'dbg_exceptions_filter')
+self.excFilterAct.setStatusTip(self.trUtf8(
+'Configure exceptions filter'))
 self.excFilterAct.setWhatsThis(self.trUtf8(
 """<b>Exceptions Filter</b>"""
-"""<p>Configure the exceptions filter. Only exception types that are"""
+"""<p>Configure the exceptions filter. Only exception types"""
-""" listed are highlighted during a debugging session.</p>"""
+""" that are listed are highlighted during a debugging"""
-"""<p>Please note, that all unhandled exceptions are highlighted"""
+""" session.</p><p>Please note, that all unhandled exceptions"""
-""" indepent from the filter list.</p>"""
+""" are highlighted indepent from the filter list.</p>"""
 ))
-self.excFilterAct.triggered[()].connect(self.__configureExceptionsFilter)
+self.excFilterAct.triggered[()].connect(
+self.__configureExceptionsFilter)
 self.actions.append(self.excFilterAct)
 self.excIgnoreFilterAct = E5Action(self.trUtf8('Ignored Exceptions'),
 self.trUtf8('&Ignored Exceptions...'), 0, 0,
 self, 'dbg_ignored_exceptions')
-self.excIgnoreFilterAct.setStatusTip(self.trUtf8('Configure ignored exceptions'))
+self.excIgnoreFilterAct.setStatusTip(self.trUtf8(
+'Configure ignored exceptions'))
 self.excIgnoreFilterAct.setWhatsThis(self.trUtf8(
 """<b>Ignored Exceptions</b>"""
-"""<p>Configure the ignored exceptions. Only exception types that are"""
+"""<p>Configure the ignored exceptions. Only exception types"""
-""" not listed are highlighted during a debugging session.</p>"""
+""" that are not listed are highlighted during a debugging"""
-"""<p>Please note, that unhandled exceptions cannot be ignored.</p>"""
+""" session.</p><p>Please note, that unhandled exceptions"""
-))
+""" cannot be ignored.</p>"""
-self.excIgnoreFilterAct.triggered[()].connect(self.__configureIgnoredExceptions)
+))
+self.excIgnoreFilterAct.triggered[()].connect(
+self.__configureIgnoredExceptions)
 self.actions.append(self.excIgnoreFilterAct)
 self.dbgSetBpActGrp = createActionGroup(self)
 self.dbgToggleBpAct = E5Action(self.trUtf8('Toggle Breakpoint'),
 UI.PixmapCache.getIcon("breakpointToggle.png"),
 self.trUtf8('Toggle Breakpoint'),
-QKeySequence(self.trUtf8("Shift+F11", "Debug|Toggle Breakpoint")), 0,
+QKeySequence(self.trUtf8("Shift+F11", "Debug|Toggle Breakpoint")),
-self.dbgSetBpActGrp, 'dbg_toggle_breakpoint')
+0, self.dbgSetBpActGrp, 'dbg_toggle_breakpoint')
 self.dbgToggleBpAct.setStatusTip(self.trUtf8('Toggle Breakpoint'))
 self.dbgToggleBpAct.setWhatsThis(self.trUtf8(
 """<b>Toggle Breakpoint</b>"""
 """<p>Toggles a breakpoint at the current line of the"""
 """ current editor.</p>"""
 ))
 self.dbgToggleBpAct.triggered[()].connect(self.__toggleBreakpoint)
 self.actions.append(self.dbgToggleBpAct)
 self.dbgEditBpAct = E5Action(self.trUtf8('Edit Breakpoint'),
 UI.PixmapCache.getIcon("cBreakpointToggle.png"),
 self.trUtf8('Edit Breakpoint...'),
 QKeySequence(self.trUtf8("Shift+F12", "Debug|Edit Breakpoint")), 0,
 self.dbgSetBpActGrp, 'dbg_edit_breakpoint')
 self.dbgEditBpAct.setStatusTip(self.trUtf8('Edit Breakpoint'))
 self.dbgEditBpAct.setWhatsThis(self.trUtf8(
 """<b>Edit Breakpoint</b>"""
 """<p>Opens a dialog to edit the breakpoints properties."""
 """ It works at the current line of the current editor.</p>"""
 ))
 self.dbgEditBpAct.triggered[()].connect(self.__editBreakpoint)
 self.actions.append(self.dbgEditBpAct)
 self.dbgNextBpAct = E5Action(self.trUtf8('Next Breakpoint'),
 UI.PixmapCache.getIcon("breakpointNext.png"),
 self.trUtf8('Next Breakpoint'),
-QKeySequence(self.trUtf8("Ctrl+Shift+PgDown", "Debug|Next Breakpoint")), 0,
+QKeySequence(
-self.dbgSetBpActGrp, 'dbg_next_breakpoint')
+self.trUtf8("Ctrl+Shift+PgDown", "Debug|Next Breakpoint")), 0,
+self.dbgSetBpActGrp, 'dbg_next_breakpoint')
 self.dbgNextBpAct.setStatusTip(self.trUtf8('Next Breakpoint'))
 self.dbgNextBpAct.setWhatsThis(self.trUtf8(
 """<b>Next Breakpoint</b>"""
 """<p>Go to next breakpoint of the current editor.</p>"""
 ))
 self.dbgNextBpAct.triggered[()].connect(self.__nextBreakpoint)
 self.actions.append(self.dbgNextBpAct)
 self.dbgPrevBpAct = E5Action(self.trUtf8('Previous Breakpoint'),
 UI.PixmapCache.getIcon("breakpointPrevious.png"),
 self.trUtf8('Previous Breakpoint'),
-QKeySequence(self.trUtf8("Ctrl+Shift+PgUp", "Debug|Previous Breakpoint")),
+QKeySequence(
-0, self.dbgSetBpActGrp, 'dbg_previous_breakpoint')
+self.trUtf8("Ctrl+Shift+PgUp", "Debug|Previous Breakpoint")),
+0, self.dbgSetBpActGrp, 'dbg_previous_breakpoint')
 self.dbgPrevBpAct.setStatusTip(self.trUtf8('Previous Breakpoint'))
 self.dbgPrevBpAct.setWhatsThis(self.trUtf8(
 """<b>Previous Breakpoint</b>"""
 """<p>Go to previous breakpoint of the current editor.</p>"""
 ))
 self.dbgPrevBpAct.triggered[()].connect(self.__previousBreakpoint)
 self.actions.append(self.dbgPrevBpAct)
 act = E5Action(self.trUtf8('Clear Breakpoints'),
 self.trUtf8('Clear Breakpoints'),
-QKeySequence(self.trUtf8("Ctrl+Shift+C", "Debug|Clear Breakpoints")), 0,
+QKeySequence(
-self.dbgSetBpActGrp, 'dbg_clear_breakpoint')
+self.trUtf8("Ctrl+Shift+C", "Debug|Clear Breakpoints")), 0,
+self.dbgSetBpActGrp, 'dbg_clear_breakpoint')
 act.setStatusTip(self.trUtf8('Clear Breakpoints'))
 act.setWhatsThis(self.trUtf8(
 """<b>Clear Breakpoints</b>"""
 """<p>Clear breakpoints of all editors.</p>"""
 ))
 def initToolbars(self, toolbarManager):
 """
 Public slot to initialize the debug toolbars.
-@param toolbarManager reference to a toolbar manager object (E5ToolBarManager)
+@param toolbarManager reference to a toolbar manager object
+(E5ToolBarManager)
 @return the generated toolbars (list of QToolBar)
 """
 starttb = QToolBar(self.trUtf8("Start"), self.ui)
 starttb.setIconSize(UI.Config.ToolBarIconSize)
 starttb.setObjectName("StartToolbar")
 toolbarManager.addToolBar(starttb, starttb.windowTitle())
 toolbarManager.addToolBar(debugtb, debugtb.windowTitle())
 toolbarManager.addAction(self.profileAct, starttb.windowTitle())
 toolbarManager.addAction(self.profileProjectAct, starttb.windowTitle())
 toolbarManager.addAction(self.coverageAct, starttb.windowTitle())
-toolbarManager.addAction(self.coverageProjectAct, starttb.windowTitle())
+toolbarManager.addAction(self.coverageProjectAct,
+starttb.windowTitle())
 return [starttb, debugtb]
 def setArgvHistory(self, argsStr, clearHistories=False):
 """
 def setAutoContinue(self, autoContinue):
 """
 Public slot to initialize the autoContinue flag.
-@param autoContinue flag indicating, that the debugger should not stop at
+@param autoContinue flag indicating, that the debugger should not
-the first executable line (boolean)
+stop at the first executable line (boolean)
 """
 self.autoContinue = autoContinue
 def __editorOpened(self, fn):
 """
 del self.wdHistory[10:]
 del self.envHistory[10:]
 Preferences.Prefs.settings.setValue('DebugInfo/ArgumentsHistory',
 self.argvHistory)
-Preferences.Prefs.settings.setValue('DebugInfo/WorkingDirectoryHistory',
+Preferences.Prefs.settings.setValue(
-self.wdHistory)
+'DebugInfo/WorkingDirectoryHistory', self.wdHistory)
 Preferences.Prefs.settings.setValue('DebugInfo/EnvironmentHistory',
 self.envHistory)
 Preferences.Prefs.settings.setValue('DebugInfo/Exceptions',
 self.excList)
 Preferences.Prefs.settings.setValue('DebugInfo/IgnoredExceptions',
 ' status of {0}.</p>').format(status))
 else:
 E5MessageBox.information(self.ui, Program,
 self.trUtf8('<p><b>{0}</b> has terminated with an exit'
 ' status of {1}.</p>')
-.format(Utilities.normabspath(self.ui.currentProg), status))
+.format(Utilities.normabspath(self.ui.currentProg),
+status))
 else:
 if self.ui.notificationsEnabled():
 if self.ui.currentProg is None:
 msg = self.trUtf8('The program has terminated with an exit'
 ' status of {0}.').format(status)
 else:
 msg = self.trUtf8('"{0}" has terminated with an exit'
 ' status of {1}.')\
-.format(os.path.basename(self.ui.currentProg), status)
+.format(os.path.basename(self.ui.currentProg),
-self.ui.showNotification(UI.PixmapCache.getPixmap("debug48.png"),
+status)
+self.ui.showNotification(
+UI.PixmapCache.getPixmap("debug48.png"),
 self.trUtf8("Program terminated"), msg)
 else:
 if self.ui.currentProg is None:
 self.appendStdout.emit(
 self.trUtf8('The program has terminated with an exit'
 ' status of {0}.\n').format(status))
 else:
 self.appendStdout.emit(
 self.trUtf8('"{0}" has terminated with an exit'
 ' status of {1}.\n')
-.format(Utilities.normabspath(self.ui.currentProg), status))
+.format(Utilities.normabspath(self.ui.currentProg),
+status))
 def __clientSyntaxError(self, message, filename, lineNo, characterNo):
 """
 Private method to handle a syntax error in the debugged program.
 @param message message of the syntax error (string)
-@param filename translated filename of the syntax error position (string)
+@param filename translated filename of the syntax error position
+(string)
 @param lineNo line number of the syntax error position (integer)
-@param characterNo character number of the syntax error position (integer)
+@param characterNo character number of the syntax error position
+(integer)
 """
 self.__resetUI()
 self.ui.raise_()
 self.ui.activateWindow()
 if message is None:
 E5MessageBox.critical(self.ui, Program,
-self.trUtf8('The program being debugged contains an unspecified'
+self.trUtf8(
-' syntax error.'))
+'The program being debugged contains an unspecified'
+' syntax error.'))
 return
 if not os.path.isabs(filename):
-if os.path.exists(os.path.join(self.project.getProjectPath(), filename)):
+if os.path.exists(os.path.join(self.project.getProjectPath(),
-filename = os.path.join(self.project.getProjectPath(), filename)
+filename)):
+filename = os.path.join(self.project.getProjectPath(),
+filename)
 else:
-d = os.path.dirname(self.project.getMainScript(normalized=True))
+d = os.path.dirname(
+self.project.getMainScript(normalized=True))
 if os.path.exists(os.path.join(d, filename)):
 filename = os.path.join(d, filename)
 self.viewmanager.setFileLine(filename, lineNo, True, True)
 E5MessageBox.critical(self.ui, Program,
 self.trUtf8('<p>The file <b>{0}</b> contains the syntax error'
-' <b>{1}</b> at line <b>{2}</b>, character <b>{3}</b>.</p>')
+' <b>{1}</b> at line <b>{2}</b>, character <b>{3}</b>.'
+'</p>')
 .format(filename, message, lineNo, characterNo))
 def __clientException(self, exceptionType, exceptionMessage, stackTrace):
 """
 Private method to handle an exception of the debugged program.
 source[line - 1]):
 res = E5MessageBox.No
 except (UnicodeError, IOError):
 pass
 if res != E5MessageBox.No:
-self.viewmanager.setFileLine(stackTrace[0][0], stackTrace[0][1], True)
+self.viewmanager.setFileLine(
+stackTrace[0][0], stackTrace[0][1], True)
 if res != E5MessageBox.No:
 if Preferences.getDebugger("BreakAlways"):
 res = E5MessageBox.Yes
 else:
 if stackTrace:
 buttons = E5MessageBox.StandardButtons(
 E5MessageBox.No | \
 E5MessageBox.Yes | \
 E5MessageBox.Ignore)
 res = E5MessageBox.critical(self.ui, Program,
-self.trUtf8('<p>The debugged program raised the exception'
+self.trUtf8(
-' <b>{0}</b><br>"<b>{1}</b>"<br>File: <b>{2}</b>,'
+'<p>The debugged program raised the exception'
-' Line: <b>{3}</b></p><p>Break here?</p>')
+' <b>{0}</b><br>"<b>{1}</b>"<br>'
-.format(exceptionType,
+'File: <b>{2}</b>, Line: <b>{3}</b></p>'
-Utilities.html_encode(exceptionMessage),
+'<p>Break here?</p>')
-stackTrace[0][0],
+.format(
-stackTrace[0][1]),
+exceptionType,
+Utilities.html_encode(exceptionMessage),
+stackTrace[0][0],
+stackTrace[0][1]),
 buttons,
 E5MessageBox.No)
 else:
 res = E5MessageBox.critical(self.ui, Program,
-self.trUtf8('<p>The debugged program raised the exception'
+self.trUtf8(
-' <b>{0}</b><br>"<b>{1}</b>"</p>')
+'<p>The debugged program raised the exception'
-.format(exceptionType,
+' <b>{0}</b><br>"<b>{1}</b>"</p>')
-Utilities.html_encode(exceptionMessage)))
+.format(
+exceptionType,
+Utilities.html_encode(exceptionMessage)))
 if res == E5MessageBox.Yes:
 self.exceptionInterrupt.emit()
 stack = []
 for fn, ln, func, args in stackTrace:
 stack.append((fn, ln, func, args))
 @param unplanned True if the client died, False otherwise
 """
 self.__resetUI()
 if unplanned:
 E5MessageBox.information(self.ui, Program,
-self.trUtf8('The program being debugged has terminated unexpectedly.'))
+self.trUtf8('The program being debugged has terminated'
+' unexpectedly.'))
 def __getThreadList(self):
 """
 Private method to get the list of threads from the client.
 """
 def __clientVariables(self, scope, variables):
 """
 Private method to write the clients variables to the user interface.
-@param scope scope of the variables (-1 = empty global, 1 = global, 0 = local)
+@param scope scope of the variables (-1 = empty global, 1 = global,
+0 = local)
 @param variables the list of variables from the client
 """
 if scope > 0:
 self.debugViewer.showVariables(variables, True)
 if scope == 1:
 self.debugActGrp.setEnabled(True)
 self.debugActGrp2.setEnabled(True)
 def __clientVariable(self, scope, variables):
 """
-Private method to write the contents of a clients classvariable to the user
+Private method to write the contents of a clients classvariable to
-interface.
+the user interface.
-@param scope scope of the variables (-1 = empty global, 1 = global, 0 = local)
+@param scope scope of the variables (-1 = empty global, 1 = global,
+0 = local)
 @param variables the list of members of a classvariable from the client
 """
 if scope == 1:
 self.debugViewer.showVariable(variables, 1)
 elif scope == 0:
 @param filename filename of the breakpoint (string)
 @param lineno linenumber of the breakpoint (integer)
 """
 E5MessageBox.critical(self.ui,
 self.trUtf8("Breakpoint Condition Error"),
-self.trUtf8("""<p>The condition of the breakpoint <b>{0}, {1}</b>"""
+self.trUtf8(
-""" contains a syntax error.</p>""")\
+"""<p>The condition of the breakpoint <b>{0}, {1}</b>"""
-.format(filename, lineno))
+""" contains a syntax error.</p>""")\
+.format(filename, lineno))
 model = self.debugServer.getBreakPointModel()
 index = model.getBreakPointIndex(filename, lineno)
 if not index.isValid():
 return
 from .EditBreakpointDialog import EditBreakpointDialog
 dlg = EditBreakpointDialog((fn, line), (cond, temp, enabled, count),
 [], self.ui, modal=True)
 if dlg.exec_() == QDialog.Accepted:
 cond, temp, enabled, count = dlg.getData()
-model.setBreakPointByIndex(index, fn, line, (cond, temp, enabled, count))
+model.setBreakPointByIndex(index, fn, line,
+(cond, temp, enabled, count))
 def __clientWatchConditionError(self, cond):
 """
 Public method to handle a expression error of a watch expression.
 if dlg.exec_() == QDialog.Accepted:
 cond, temp, enabled, count, special = dlg.getData()
 # check for duplicates
 idx = self.__model.getWatchPointIndex(cond, special)
-duplicate = idx.isValid() and idx.internalPointer() != index.internalPointer()
+duplicate = idx.isValid() and \
+idx.internalPointer() != index.internalPointer()
 if duplicate:
 if not special:
 msg = self.trUtf8("""<p>A watch expression '<b>{0}</b>'"""
 """ already exists.</p>""")\
 .format(Utilities.html_encode(cond))
 else:
 msg = self.trUtf8("""<p>A watch expression '<b>{0}</b>'"""
-""" for the variable <b>{1}</b> already exists.</p>""")\
+""" for the variable <b>{1}</b> already"""
+""" exists.</p>""")\
 .format(special,
 Utilities.html_encode(cond))
 E5MessageBox.warning(self,
 self.trUtf8("Watch expression already exists"),
 msg)
 def __doCoverage(self, runProject):
 """
 Private method to handle the coverage actions.
-@param runProject flag indicating coverage of the current project (True)
+@param runProject flag indicating coverage of the current project
-or script (false)
+(True) or script (false)
 """
 from .StartDialog import StartDialog
 self.__resetUI()
 doNotStart = False
 # exception reporting flag.
 if runProject:
 cap = self.trUtf8("Coverage of Project")
 else:
 cap = self.trUtf8("Coverage of Script")
-dlg = StartDialog(cap, self.argvHistory, self.wdHistory, self.envHistory,
+dlg = StartDialog(cap, self.argvHistory, self.wdHistory,
-self.exceptions, self.ui, 2, autoClearShell=self.autoClearShell)
+self.envHistory, self.exceptions, self.ui, 2,
+autoClearShell=self.autoClearShell)
 if dlg.exec_() == QDialog.Accepted:
-argv, wd, env, exceptions, clearShell, clearHistories, console = dlg.getData()
+argv, wd, env, exceptions, clearShell, clearHistories, console = \
+dlg.getData()
 eraseCoverage = dlg.getCoverageData()
 if runProject:
 fn = self.project.getMainScript(1)
 if fn is None:
 if Preferences.getDebugger("Autosave") and \
 not self.project.saveAllScripts(reportSyntaxErrors=True):
 doNotStart = True
 # save the info for later use
-self.project.setDbgInfo(argv, wd, env, exceptions, self.excList,
+self.project.setDbgInfo(
+argv, wd, env, exceptions, self.excList,
 self.excIgnoreList, clearShell)
 self.lastStartAction = 6
 self.clientType = self.project.getProjectLanguage()
 else:
 def __doProfile(self, runProject):
 """
 Private method to handle the profile actions.
-@param runProject flag indicating profiling of the current project (True)
+@param runProject flag indicating profiling of the current project
-or script (False)
+(True) or script (False)
 """
 from .StartDialog import StartDialog
 self.__resetUI()
 doNotStart = False
 # exception reporting flag.
 if runProject:
 cap = self.trUtf8("Profile of Project")
 else:
 cap = self.trUtf8("Profile of Script")
-dlg = StartDialog(cap, self.argvHistory, self.wdHistory, self.envHistory,
+dlg = StartDialog(
+cap, self.argvHistory, self.wdHistory, self.envHistory,
 self.exceptions, self.ui, 3,
 autoClearShell=self.autoClearShell)
 if dlg.exec_() == QDialog.Accepted:
-argv, wd, env, exceptions, clearShell, clearHistories, console = dlg.getData()
+argv, wd, env, exceptions, clearShell, clearHistories, console = \
+dlg.getData()
 eraseTimings = dlg.getProfilingData()
 if runProject:
 fn = self.project.getMainScript(1)
 if fn is None:
 if Preferences.getDebugger("Autosave") and \
 not self.project.saveAllScripts(reportSyntaxErrors=True):
 doNotStart = True
 # save the info for later use
-self.project.setDbgInfo(argv, wd, env, exceptions, self.excList,
+self.project.setDbgInfo(
+argv, wd, env, exceptions, self.excList,
 self.excIgnoreList, clearShell)
 self.lastStartAction = 8
 self.clientType = self.project.getProjectLanguage()
 else:
 # exception reporting flag.
 if runProject:
 cap = self.trUtf8("Run Project")
 else:
 cap = self.trUtf8("Run Script")
-dlg = StartDialog(cap, self.argvHistory, self.wdHistory, self.envHistory,
+dlg = StartDialog(
+cap, self.argvHistory, self.wdHistory, self.envHistory,
 self.exceptions, self.ui, 1,
 autoClearShell=self.autoClearShell,
 autoFork=self.forkAutomatically,
 forkChild=self.forkIntoChild)
 if dlg.exec_() == QDialog.Accepted:
-argv, wd, env, exceptions, clearShell, clearHistories, console = dlg.getData()
+argv, wd, env, exceptions, clearShell, clearHistories, console = \
+dlg.getData()
 forkAutomatically, forkIntoChild = dlg.getRunData()
 if runProject:
 fn = self.project.getMainScript(1)
 if fn is None:
 if Preferences.getDebugger("Autosave") and \
 not self.project.saveAllScripts(reportSyntaxErrors=True):
 doNotStart = True
 # save the info for later use
-self.project.setDbgInfo(argv, wd, env, exceptions, self.excList,
+self.project.setDbgInfo(
+argv, wd, env, exceptions, self.excList,
 self.excIgnoreList, clearShell)
 self.lastStartAction = 4
 self.clientType = self.project.getProjectLanguage()
 else:
 def __doDebug(self, debugProject):
 """
 Private method to handle the debug actions.
-@param debugProject flag indicating debugging the current project (True)
+@param debugProject flag indicating debugging the current project
-or script (False)
+(True) or script (False)
 """
 from .StartDialog import StartDialog
 self.__resetUI()
 doNotStart = False
 # exception reporting flag.
 if debugProject:
 cap = self.trUtf8("Debug Project")
 else:
 cap = self.trUtf8("Debug Script")
-dlg = StartDialog(cap, self.argvHistory, self.wdHistory, self.envHistory,
+dlg = StartDialog(
+cap, self.argvHistory, self.wdHistory, self.envHistory,
 self.exceptions, self.ui, 0, tracePython=self.tracePython,
 autoClearShell=self.autoClearShell, autoContinue=self.autoContinue,
 autoFork=self.forkAutomatically, forkChild=self.forkIntoChild)
 if dlg.exec_() == QDialog.Accepted:
-argv, wd, env, exceptions, clearShell, clearHistories, console = dlg.getData()
+argv, wd, env, exceptions, clearShell, clearHistories, console = \
+dlg.getData()
 tracePython, autoContinue, forkAutomatically, forkIntoChild = \
 dlg.getDebugData()
 if debugProject:
 fn = self.project.getMainScript(True)
 if Preferences.getDebugger("Autosave") and \
 not self.project.saveAllScripts(reportSyntaxErrors=True):
 doNotStart = True
 # save the info for later use
-self.project.setDbgInfo(argv, wd, env, exceptions, self.excList,
+self.project.setDbgInfo(
+argv, wd, env, exceptions, self.excList,
 self.excIgnoreList, clearShell, tracePython=tracePython,
 autoContinue=self.autoContinue)
 self.lastStartAction = 2
 self.clientType = self.project.getProjectLanguage()
 # Hide all error highlights
 self.viewmanager.unhighlight()
 if not doNotStart:
-if debugProject and self.project.getProjectType() == "E4Plugin":
+if debugProject and \
+self.project.getProjectType() == "E4Plugin":
 argv = '--plugin="{0}" {1}'.format(fn, argv)
 fn = os.path.join(getConfig('ericDir'), "eric5.py")
 tracePython = True  # override flag because it must be true
 self.debugViewer.initCallStackViewer(debugProject)
 self.debugViewer.clearCallTrace()
 self.debugViewer.setCallTraceToProjectMode(debugProject)
 # Ask the client to open the new program.
 self.debugServer.remoteLoad(fn, argv, wd, env,
-autoClearShell=self.autoClearShell, tracePython=tracePython,
+autoClearShell=self.autoClearShell,
+tracePython=tracePython,
 autoContinue=autoContinue, forProject=debugProject,
 runInConsole=console, autoFork=forkAutomatically,
 forkChild=forkIntoChild, clientType=self.clientType,
 enableCallTrace=enableCallTrace)
 self.stopAct.setEnabled(True)
 def __doRestart(self):
 """
-Private slot to handle the restart action to restart the last debugged file.
+Private slot to handle the restart action to restart the last
+debugged file.
 """
 self.__resetUI()
 doNotStart = False
 # first save any changes
 enableCallTrace = self.debugViewer.isCallTraceEnabled()
 self.debugViewer.clearCallTrace()
 self.debugViewer.setCallTraceToProjectMode(forProject)
 # Ask the client to debug the new program.
-self.debugServer.remoteLoad(fn, argv, wd, env,
+self.debugServer.remoteLoad(
-autoClearShell=self.autoClearShell, tracePython=self.tracePython,
+fn, argv, wd, env,
-autoContinue=self.autoContinue, forProject=forProject,
+autoClearShell=self.autoClearShell,
-runInConsole=self.runInConsole, autoFork=self.forkAutomatically,
+tracePython=self.tracePython,
-forkChild=self.forkIntoChild, clientType=self.clientType,
+autoContinue=self.autoContinue,
+forProject=forProject,
+runInConsole=self.runInConsole,
+autoFork=self.forkAutomatically,
+forkChild=self.forkIntoChild,
+clientType=self.clientType,
 enableCallTrace=enableCallTrace)
 # Signal that we have started a debugging session
 self.debuggingStarted.emit(fn)
 elif self.lastStartAction in [3, 4]:
 # Ask the client to run the new program.
-self.debugServer.remoteRun(fn, argv, wd, env,
+self.debugServer.remoteRun(
-autoClearShell=self.autoClearShell, forProject=forProject,
+fn, argv, wd, env,
-runInConsole=self.runInConsole, autoFork=self.forkAutomatically,
+autoClearShell=self.autoClearShell,
-forkChild=self.forkIntoChild, clientType=self.clientType)
+forProject=forProject,
+runInConsole=self.runInConsole,
+autoFork=self.forkAutomatically,
+forkChild=self.forkIntoChild,
+clientType=self.clientType)
 elif self.lastStartAction in [5, 6]:
 # Ask the client to coverage run the new program.
-self.debugServer.remoteCoverage(fn, argv, wd, env,
+self.debugServer.remoteCoverage(
-autoClearShell=self.autoClearShell, erase=self.eraseCoverage,
+fn, argv, wd, env,
-forProject=forProject, runInConsole=self.runInConsole,
+autoClearShell=self.autoClearShell,
+erase=self.eraseCoverage,
+forProject=forProject,
+runInConsole=self.runInConsole,
 clientType=self.clientType)
 elif self.lastStartAction in [7, 8]:
 # Ask the client to profile run the new program.
-self.debugServer.remoteProfile(fn, argv, wd, env,
+self.debugServer.remoteProfile(
-autoClearShell=self.autoClearShell, erase=self.eraseTimings,
+fn, argv, wd, env,
-forProject=forProject, runInConsole=self.runInConsole,
+autoClearShell=self.autoClearShell,
+erase=self.eraseTimings,
+forProject=forProject,
+runInConsole=self.runInConsole,
 clientType=self.clientType)
 self.stopAct.setEnabled(True)
 def __stopScript(self):

Mercurial Repositories > eric / file comparison

comparison: Debugger/DebugUI.py

Debugger/DebugUI.py