eric: comparison Debugger/DebugUI.py

-:1b59c4ba121e
+:8cd4d08fa9f6
 from E5Gui.E5Action import E5Action, createActionGroup
 from E5Gui import E5MessageBox
 from eric5config import getConfig
 class DebugUI(QObject):
 """
 Class implementing the debugger part of the UI.
 """
 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"""
 """ 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'),
 UI.PixmapCache.getIcon("runProject.png"),
-self.trUtf8('Run &Project...'),Qt.SHIFT + Qt.Key_F2,0,self,
+self.trUtf8('Run &Project...'), Qt.SHIFT + Qt.Key_F2, 0, self,
 'dbg_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"""
 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"""
 self.coverageAct.triggered[()].connect(self.__coverageScript)
 self.actions.append(self.coverageAct)
 self.coverageProjectAct = E5Action(self.trUtf8('Coverage run of Project'),
 UI.PixmapCache.getIcon("coverageProject.png"),
-self.trUtf8('Coverage run of Project...'),0,0,self,'dbg_coverage_project')
+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"""
 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.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, '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."""
 """ If files of the current project have unsaved changes they may"""
 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"""
 """ first executable Python statement of the current editor window."""
 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,
+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.setWhatsThis(self.trUtf8(
 """<b>Debug Project</b>"""
 """<p>Set the command line arguments and set the current line to be the"""
 self.debugProjectAct.triggered[()].connect(self.__debugProject)
 self.actions.append(self.debugProjectAct)
 self.restartAct = E5Action(self.trUtf8('Restart Script'),
 UI.PixmapCache.getIcon("restart.png"),
-self.trUtf8('Restart Script'),Qt.Key_F4,0,self,'dbg_restart_script')
+self.trUtf8('Restart Script'), Qt.Key_F4, 0, self, 'dbg_restart_script')
 self.restartAct.setStatusTip(self.trUtf8('Restart the last debugged script'))
 self.restartAct.setWhatsThis(self.trUtf8(
 """<b>Restart Script</b>"""
 """<p>Set the command line arguments and set the current line to be the"""
 """ first executable Python statement of the script that was debugged last."""
 self.restartAct.triggered[()].connect(self.__doRestart)
 self.actions.append(self.restartAct)
 self.stopAct = E5Action(self.trUtf8('Stop Script'),
 UI.PixmapCache.getIcon("stopScript.png"),
-self.trUtf8('Stop Script'),Qt.SHIFT + Qt.Key_F10,0,
+self.trUtf8('Stop Script'), Qt.SHIFT + Qt.Key_F10, 0,
-self,'dbg_stop_script')
+self, 'dbg_stop_script')
 self.stopAct.setStatusTip(self.trUtf8("""Stop the running script."""))
 self.stopAct.setWhatsThis(self.trUtf8(
 """<b>Stop Script</b>"""
 """<p>This stops the script running in the debugger backend.</p>"""
 ))
 self.debugActGrp = createActionGroup(self)
 act = E5Action(self.trUtf8('Continue'),
 UI.PixmapCache.getIcon("continue.png"),
-self.trUtf8('&Continue'),Qt.Key_F6,0,
+self.trUtf8('&Continue'), Qt.Key_F6, 0,
-self.debugActGrp,'dbg_continue')
+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"""
 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.trUtf8('Continue &To Cursor'), Qt.SHIFT + Qt.Key_F6, 0,
-self.debugActGrp,'dbg_continue_to_cursor')
+self.debugActGrp, 'dbg_continue_to_cursor')
 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"""
 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.trUtf8('Sin&gle Step'), Qt.Key_F7, 0,
-self.debugActGrp,'dbg_single_step')
+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"""
 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.trUtf8('Step &Over'), Qt.Key_F8, 0,
-self.debugActGrp,'dbg_step_over')
+self.debugActGrp, 'dbg_step_over')
 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"""
 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.trUtf8('Step Ou&t'), Qt.Key_F9, 0,
-self.debugActGrp,'dbg_step_out')
+self.debugActGrp, 'dbg_step_out')
 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"""
 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.trUtf8('&Stop'), Qt.Key_F10, 0,
-self.debugActGrp,'dbg_stop')
+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.debugActGrp2 = createActionGroup(self)
 act = E5Action(self.trUtf8('Evaluate'),
 self.trUtf8('E&valuate...'),
-0,0,self.debugActGrp2,'dbg_evaluate')
+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.__eval)
 self.actions.append(act)
 act = E5Action(self.trUtf8('Execute'),
 self.trUtf8('E&xecute...'),
-0,0,self.debugActGrp2,'dbg_execute')
+0, 0, self.debugActGrp2, 'dbg_execute')
 act.setStatusTip(
 self.trUtf8('Execute a one line statement in the current context'))
 act.setWhatsThis(self.trUtf8(
 """<b>Execute</b>"""
 """<p>Execute a one line statement in the current context"""
 ))
 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.setWhatsThis(self.trUtf8(
 """<b>Variables Type Filter</b>"""
 """<p>Configure the variables type filter. Only variable types that are not"""
 ))
 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.setWhatsThis(self.trUtf8(
 """<b>Ignored Exceptions</b>"""
 """<p>Configure the ignored exceptions. Only exception types that are"""
 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")), 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"""
 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,
+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."""
 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.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.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(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.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>"""
 toolbarManager.addAction(self.coverageAct, starttb.windowTitle())
 toolbarManager.addAction(self.coverageProjectAct, starttb.windowTitle())
 return [starttb, debugtb]
-def setArgvHistory(self, argsStr, clearHistories = False):
+def setArgvHistory(self, argsStr, clearHistories=False):
 """
 Public slot to initialize the argv history.
 @param argsStr the commandline arguments (string)
 @param clearHistories flag indicating, that the list should
 else:
 if argsStr in self.argvHistory:
 self.argvHistory.remove(argsStr)
 self.argvHistory.insert(0, argsStr)
-def setWdHistory(self, wdStr, clearHistories = False):
+def setWdHistory(self, wdStr, clearHistories=False):
 """
 Public slot to initialize the wd history.
 @param wdStr the working directory (string)
 @param clearHistories flag indicating, that the list should
 else:
 if wdStr in self.wdHistory:
 self.wdHistory.remove(wdStr)
 self.wdHistory.insert(0, wdStr)
-def setEnvHistory(self, envStr, clearHistories = False):
+def setEnvHistory(self, envStr, clearHistories=False):
 """
 Public slot to initialize the env history.
 @param envStr the environment settings (string)
 @param clearHistories flag indicating, that the list should
 # Just save the 10 most recent entries
 del self.argvHistory[10:]
 del self.wdHistory[10:]
 del self.envHistory[10:]
 Preferences.Prefs.settings.setValue('DebugInfo/ArgumentsHistory',
 self.argvHistory)
 Preferences.Prefs.settings.setValue('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',
 self.excIgnoreList)
 Preferences.Prefs.settings.setValue('DebugInfo/ReportExceptions',
 self.exceptions)
 Preferences.Prefs.settings.setValue('DebugInfo/AutoClearShell',
 self.autoClearShell)
 Preferences.Prefs.settings.setValue('DebugInfo/TracePython',
 self.tracePython)
 Preferences.Prefs.settings.setValue('DebugInfo/AutoContinue',
 self.autoContinue)
 Preferences.Prefs.settings.setValue('DebugInfo/ForkAutomatically',
 self.forkAutomatically)
 Preferences.Prefs.settings.setValue('DebugInfo/ForkIntoChild',
 self.forkIntoChild)
 def shutdownServer(self):
 """
 Public method to shut down the debug server.
 self.__resetUI()
 self.ui.raise_()
 self.ui.activateWindow()
 if message is None:
-E5MessageBox.critical(self.ui,Program,
+E5MessageBox.critical(self.ui, Program,
 self.trUtf8('The program being debugged contains an unspecified'
 ' syntax error.'))
 return
 self.viewmanager.setFileLine(filename, lineNo, True, True)
-E5MessageBox.critical(self.ui,Program,
+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>')
 .format(filename, message, lineNo, characterNo))
 def __clientException(self, exceptionType, exceptionMessage, stackTrace):
 """
 self.ui.raise_()
 self.ui.activateWindow()
 QApplication.processEvents()
 if exceptionType is None:
-E5MessageBox.critical(self.ui,Program,
+E5MessageBox.critical(self.ui, Program,
 self.trUtf8('An unhandled exception occured.'
 ' See the shell window for details.'))
 return
 if (self.exceptions and \
 E5MessageBox.Ignore)
 res = E5MessageBox.critical(self.ui, Program,
 self.trUtf8('<p>The debugged program raised the exception'
 ' <b>{0}</b><br>"<b>{1}</b>"<br>File: <b>{2}</b>,'
 ' Line: <b>{3}</b></p><p>Break here?</p>')
 .format(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'
 ' <b>{0}</b><br>"<b>{1}</b>"</p>')
 .format(exceptionType,
 Utilities.html_encode(exceptionMessage)))
 if res == E5MessageBox.Yes:
 self.exceptionInterrupt.emit()
 stack = []
 for fn, ln in stackTrace:
 @param unplanned True if the client died, False otherwise
 """
 self.__resetUI()
 if unplanned:
-E5MessageBox.information(self.ui,Program,
+E5MessageBox.information(self.ui, Program,
 self.trUtf8('The program being debugged has terminated unexpectedly.'))
 def __getThreadList(self):
 """
 Private method to get the list of threads from the client.
 # now get the local variables
 self.debugServer.remoteClientVariables(0, self.localsVarFilter)
 elif scope == 0:
 self.debugViewer.showVariables(variables, False)
 elif scope == -1:
-vlist = [('None','','')]
+vlist = [('None', '', '')]
 self.debugViewer.showVariables(vlist, False)
 if scope < 1:
 self.debugActGrp.setEnabled(True)
 self.debugActGrp2.setEnabled(True)
 return
 fn, line, cond, temp, enabled, count = bp[:6]
 dlg = EditBreakpointDialog((fn, line), (cond, temp, enabled, count),
-[], self.ui, modal = True)
+[], self.ui, modal=True)
 if dlg.exec_() == QDialog.Accepted:
 cond, temp, enabled, count = dlg.getData()
 model.setBreakPointByIndex(index, fn, line, (cond, temp, enabled, count))
 def __clientWatchConditionError(self, cond):
 """ 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>""")\
 .format(special,
 Utilities.html_encode(cond))
 E5MessageBox.warning(self,
 self.trUtf8("Watch expression already exists"),
 msg)
 model.deleteWatchPointByIndex(index)
 else:
 model.setWatchPointByIndex(index, cond, special,
 (temp, enabled, count))
 def __configureVariablesFilters(self):
 """
 Private slot for displaying the variables filter configuration dialog.
 def __configureExceptionsFilter(self):
 """
 Private slot for displaying the exception filter dialog.
 """
-dlg = ExceptionsFilterDialog(self.excList, ignore = False)
+dlg = ExceptionsFilterDialog(self.excList, ignore=False)
 if dlg.exec_() == QDialog.Accepted:
 self.excList = dlg.getExceptionsList()[:]   # keep a copy
 def __configureIgnoredExceptions(self):
 """
 Private slot for displaying the ignored exceptions dialog.
 """
-dlg = ExceptionsFilterDialog(self.excIgnoreList, ignore = True)
+dlg = ExceptionsFilterDialog(self.excIgnoreList, ignore=True)
 if dlg.exec_() == QDialog.Accepted:
 self.excIgnoreList = dlg.getExceptionsList()[:]   # keep a copy
 def __toggleBreakpoint(self):
 """
 bpSuffix = " : {0:d}{1}".format(line, formattedCond)
 act = self.breakpointsMenu.addAction(
 "{0}{1}".format(
 Utilities.compactPath(
 filename,
 self.ui.maxMenuFilePathLen - len(bpSuffix)),
 bpSuffix))
 act.setData([filename, line])
 def __breakpointSelected(self, act):
 """
 if runProject:
 cap = self.trUtf8("Coverage of Project")
 else:
 cap = self.trUtf8("Coverage of Script")
 dlg = StartDialog(cap, self.argvHistory, self.wdHistory, self.envHistory,
-self.exceptions, self.ui, 2, autoClearShell = self.autoClearShell)
+self.exceptions, self.ui, 2, autoClearShell=self.autoClearShell)
 if dlg.exec_() == QDialog.Accepted:
 argv, wd, env, exceptions, clearShell, clearHistories, console = dlg.getData()
 eraseCoverage = dlg.getCoverageData()
 if runProject:
 self.trUtf8("There is no main script defined for the"
 " current project. Aborting"))
 return
 if Preferences.getDebugger("Autosave") and \
-not self.project.saveAllScripts(reportSyntaxErrors = True):
+not self.project.saveAllScripts(reportSyntaxErrors=True):
 doNotStart = True
 # save the info for later use
 self.project.setDbgInfo(argv, wd, env, exceptions, self.excList,
 self.excIgnoreList, clearShell)
 self.lastStartAction = 6
 self.clientType = ""
 else:
 editor = self.viewmanager.activeWindow()
 if editor is None:
 return
 if not self.viewmanager.checkDirty(editor,
 Preferences.getDebugger("Autosave")) or \
 editor.getFileName() is None:
 return
 fn = editor.getFileName()
 if runProject and self.project.getProjectType() == "E4Plugin":
 argv = '--plugin="{0}" {1}'.format(fn, argv)
 fn = os.path.join(getConfig('ericDir'), "eric5.py")
 # Ask the client to open the new program.
 self.debugServer.remoteCoverage(fn, argv, wd, env,
-autoClearShell = self.autoClearShell, erase = eraseCoverage,
+autoClearShell=self.autoClearShell, erase=eraseCoverage,
-forProject = runProject, runInConsole = console,
+forProject=runProject, runInConsole=console,
-clientType = self.clientType)
+clientType=self.clientType)
 self.stopAct.setEnabled(True)
 def __profileScript(self):
 """
 cap = self.trUtf8("Profile of Project")
 else:
 cap = self.trUtf8("Profile of Script")
 dlg = StartDialog(cap, self.argvHistory, self.wdHistory, self.envHistory,
 self.exceptions, self.ui, 3,
-autoClearShell = self.autoClearShell)
+autoClearShell=self.autoClearShell)
 if dlg.exec_() == QDialog.Accepted:
 argv, wd, env, exceptions, clearShell, clearHistories, console = dlg.getData()
 eraseTimings = dlg.getProfilingData()
 if runProject:
 self.trUtf8("There is no main script defined for the"
 " current project. Aborting"))
 return
 if Preferences.getDebugger("Autosave") and \
-not self.project.saveAllScripts(reportSyntaxErrors = True):
+not self.project.saveAllScripts(reportSyntaxErrors=True):
 doNotStart = True
 # save the info for later use
 self.project.setDbgInfo(argv, wd, env, exceptions, self.excList,
 self.excIgnoreList, clearShell)
 else:
 editor = self.viewmanager.activeWindow()
 if editor is None:
 return
 if not self.viewmanager.checkDirty(editor,
 Preferences.getDebugger("Autosave")) or \
 editor.getFileName() is None:
 return
 fn = editor.getFileName()
 argv = '--plugin="{0}" {1}'.format(fn, argv)
 fn = os.path.join(getConfig('ericDir'), "eric5.py")
 # Ask the client to open the new program.
 self.debugServer.remoteProfile(fn, argv, wd, env,
-autoClearShell = self.autoClearShell, erase = eraseTimings,
+autoClearShell=self.autoClearShell, erase=eraseTimings,
-forProject = runProject, runInConsole = console,
+forProject=runProject, runInConsole=console,
-clientType = self.clientType)
+clientType=self.clientType)
 self.stopAct.setEnabled(True)
 def __runScript(self):
 """
 # 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,
 self.exceptions, self.ui, 1,
-autoClearShell = self.autoClearShell,
+autoClearShell=self.autoClearShell,
-autoFork = self.forkAutomatically,
+autoFork=self.forkAutomatically,
-forkChild = self.forkIntoChild)
+forkChild=self.forkIntoChild)
 if dlg.exec_() == QDialog.Accepted:
 argv, wd, env, exceptions, clearShell, clearHistories, console = dlg.getData()
 forkAutomatically, forkIntoChild = dlg.getRunData()
 if runProject:
 self.trUtf8("There is no main script defined for the"
 " current project. Aborting"))
 return
 if Preferences.getDebugger("Autosave") and \
-not self.project.saveAllScripts(reportSyntaxErrors = True):
+not self.project.saveAllScripts(reportSyntaxErrors=True):
 doNotStart = True
 # save the info for later use
 self.project.setDbgInfo(argv, wd, env, exceptions, self.excList,
 self.excIgnoreList, clearShell)
 else:
 editor = self.viewmanager.activeWindow()
 if editor is None:
 return
 if not self.viewmanager.checkDirty(editor,
 Preferences.getDebugger("Autosave")) or \
 editor.getFileName() is None:
 return
 fn = editor.getFileName()
 argv = '--plugin="{0}" {1}'.format(fn, argv)
 fn = os.path.join(getConfig('ericDir'), "eric5.py")
 # Ask the client to open the new program.
 self.debugServer.remoteRun(fn, argv, wd, env,
-autoClearShell = self.autoClearShell, forProject = runProject,
+autoClearShell=self.autoClearShell, forProject=runProject,
-runInConsole = console, autoFork = forkAutomatically,
+runInConsole=console, autoFork=forkAutomatically,
-forkChild = forkIntoChild, clientType = self.clientType)
+forkChild=forkIntoChild, clientType=self.clientType)
 self.stopAct.setEnabled(True)
 def __debugScript(self):
 """
 # 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,
-self.exceptions, self.ui, 0, tracePython = self.tracePython,
+self.exceptions, self.ui, 0, tracePython=self.tracePython,
-autoClearShell = self.autoClearShell, autoContinue = self.autoContinue,
+autoClearShell=self.autoClearShell, autoContinue=self.autoContinue,
-autoFork = self.forkAutomatically, forkChild = self.forkIntoChild)
+autoFork=self.forkAutomatically, forkChild=self.forkIntoChild)
 if dlg.exec_() == QDialog.Accepted:
 argv, wd, env, exceptions, clearShell, clearHistories, console = dlg.getData()
 tracePython, autoContinue, forkAutomatically, forkIntoChild = \
 dlg.getDebugData()
 self.trUtf8("There is no main script defined for the"
 " current project. No debugging possible."))
 return
 if Preferences.getDebugger("Autosave") and \
-not self.project.saveAllScripts(reportSyntaxErrors = True):
+not self.project.saveAllScripts(reportSyntaxErrors=True):
 doNotStart = True
 # save the info for later use
 self.project.setDbgInfo(argv, wd, env, exceptions, self.excList,
-self.excIgnoreList, clearShell, tracePython = tracePython,
+self.excIgnoreList, clearShell, tracePython=tracePython,
-autoContinue = self.autoContinue)
+autoContinue=self.autoContinue)
 self.lastStartAction = 2
 self.clientType = ""
 else:
 editor = self.viewmanager.activeWindow()
 if editor is None:
 return
 if not self.viewmanager.checkDirty(editor,
 Preferences.getDebugger("Autosave")) or \
 editor.getFileName() is None:
 return
 fn = editor.getFileName()
 if not doNotStart:
 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
+tracePython = True  # override flag because it must be true
 # 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,
+autoContinue=autoContinue, forProject=debugProject,
-runInConsole = console, autoFork = forkAutomatically,
+runInConsole=console, autoFork=forkAutomatically,
-forkChild = forkIntoChild, clientType = self.clientType)
+forkChild=forkIntoChild, clientType=self.clientType)
 # Signal that we have started a debugging session
 self.debuggingStarted.emit(fn)
 self.stopAct.setEnabled(True)
 # first save any changes
 if self.lastStartAction in [1, 3, 5, 7, 9]:
 editor = self.viewmanager.getOpenEditor(self.lastDebuggedFile)
 if editor and \
 not self.viewmanager.checkDirty(editor,
 Preferences.getDebugger("Autosave")):
 return
 forProject = False
 elif self.lastStartAction in [2, 4, 6, 8, 10]:
 if Preferences.getDebugger("Autosave") and \
-not self.project.saveAllScripts(reportSyntaxErrors = True):
+not self.project.saveAllScripts(reportSyntaxErrors=True):
 doNotStart = True
 self.__compileChangedProjectFiles()
 forProject = True
 else:
 return      # should not happen
 argv = '--plugin="{0}" {1}'.format(fn, argv)
 fn = os.path.join(getConfig('ericDir'), "eric5.py")
 if self.lastStartAction in [1, 2]:
 # Ask the client to debug the new program.
 self.debugServer.remoteLoad(fn, argv, wd, env,
-autoClearShell = self.autoClearShell, tracePython = self.tracePython,
+autoClearShell=self.autoClearShell, tracePython=self.tracePython,
-autoContinue = self.autoContinue, forProject = forProject,
+autoContinue=self.autoContinue, forProject=forProject,
-runInConsole = self.runInConsole, autoFork = self.forkAutomatically,
+runInConsole=self.runInConsole, autoFork=self.forkAutomatically,
-forkChild = self.forkIntoChild, clientType = self.clientType)
+forkChild=self.forkIntoChild, clientType=self.clientType)
 # 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,
-autoClearShell = self.autoClearShell, forProject = forProject,
+autoClearShell=self.autoClearShell, forProject=forProject,
-runInConsole = self.runInConsole, autoFork = self.forkAutomatically,
+runInConsole=self.runInConsole, autoFork=self.forkAutomatically,
-forkChild = self.forkIntoChild, clientType = self.clientType)
+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,
-autoClearShell = self.autoClearShell, erase = self.eraseCoverage,
+autoClearShell=self.autoClearShell, erase=self.eraseCoverage,
-forProject = forProject, runInConsole = self.runInConsole,
+forProject=forProject, runInConsole=self.runInConsole,
-clientType = self.clientType)
+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,
-autoClearShell = self.autoClearShell, erase = self.eraseTimings,
+autoClearShell=self.autoClearShell, erase=self.eraseTimings,
-forProject = forProject, runInConsole = self.runInConsole,
+forProject=forProject, runInConsole=self.runInConsole,
-clientType = self.clientType)
+clientType=self.clientType)
 self.stopAct.setEnabled(True)
 def __stopScript(self):
 """
 """
 self.lastAction = 0
 aw = self.viewmanager.activeWindow()
 line = aw.getCursorPosition()[0] + 1
 self.__enterRemote()
 self.debugServer.remoteBreakpoint(aw.getFileName(),
 line, 1, None, 1)
 self.debugServer.remoteContinue()
 def __eval(self):
 """

Mercurial Repositories > eric / file comparison

comparison: Debugger/DebugUI.py

Debugger/DebugUI.py