eric: comparison Debugger/DebugUI.py

-:10516539f238
+:0a02c433f52d
 self.execHistory = []
 self.lastDebuggedFile = None
 self.lastStartAction = 0    # 0=None, 1=Script, 2=Project
 self.clientType = ""
 self.lastAction = -1
-self.debugActions = [self.__continue, self.__step,\
+self.debugActions = [
-self.__stepOver, self.__stepOut,\
+self.__continue, self.__step, self.__stepOver, self.__stepOut,
-self.__stepQuit, self.__runToCursor]
+self.__stepQuit, self.__runToCursor
+]
 self.localsVarFilter, self.globalsVarFilter = \
 Preferences.getVarFilters()
 self.debugViewer.setVariablesFilter(
 self.globalsVarFilter, self.localsVarFilter)
 """
 Method defining the user interface actions.
 """
 self.actions = []
-self.runAct = E5Action(self.trUtf8('Run Script'),
+self.runAct = E5Action(
-UI.PixmapCache.getIcon("runScript.png"),
+self.trUtf8('Run Script'),
-self.trUtf8('&Run Script...'),
+UI.PixmapCache.getIcon("runScript.png"),
-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'),
+self.runProjectAct = E5Action(
-UI.PixmapCache.getIcon("runProject.png"),
+self.trUtf8('Run Project'),
-self.trUtf8('Run &Project...'), Qt.SHIFT + Qt.Key_F2, 0, self,
+UI.PixmapCache.getIcon("runProject.png"),
-'dbg_run_project')
+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"""
 """ outside the debugger."""
 """ 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'),
+self.coverageAct = E5Action(
-UI.PixmapCache.getIcon("coverageScript.png"),
+self.trUtf8('Coverage run of Script'),
-self.trUtf8('Coverage run of Script...'), 0, 0, self,
+UI.PixmapCache.getIcon("coverageScript.png"),
-'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"""
 """ they may be saved first.</p>"""
 ))
 self.coverageProjectAct.triggered[()].connect(self.__coverageProject)
 self.actions.append(self.coverageProjectAct)
-self.profileAct = E5Action(self.trUtf8('Profile Script'),
+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>"""
 """ 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'),
+self.profileProjectAct = E5Action(
+self.trUtf8('Profile Project'),
 UI.PixmapCache.getIcon("profileProject.png"),
 self.trUtf8('Profile Project...'), 0, 0, self,
 'dbg_profile_project')
 self.profileProjectAct.setStatusTip(
 self.trUtf8('Profile the current Project'))
 """ 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'),
+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.debugAct.setStatusTip(self.trUtf8('Debug the current Script'))
 self.debugAct.setWhatsThis(self.trUtf8(
 """ saved first.</p>"""
 ))
 self.debugAct.triggered[()].connect(self.__debugScript)
 self.actions.append(self.debugAct)
-self.debugProjectAct = E5Action(self.trUtf8('Debug Project'),
+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'))
 """ 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'),
+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.setWhatsThis(self.trUtf8(
 """ may be saved first.</p>"""
 ))
 self.restartAct.triggered[()].connect(self.__doRestart)
 self.actions.append(self.restartAct)
-self.stopAct = E5Action(self.trUtf8('Stop'),
+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(
 self.stopAct.triggered[()].connect(self.__stopScript)
 self.actions.append(self.stopAct)
 self.debugActGrp = createActionGroup(self)
-act = E5Action(self.trUtf8('Continue'),
+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'))
 """ is reached.</p>"""
 ))
 act.triggered[()].connect(self.__continue)
 self.actions.append(act)
-act = E5Action(self.trUtf8('Continue to Cursor'),
+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"""
 """ current cursor position.</p>"""
 ))
 act.triggered[()].connect(self.__runToCursor)
 self.actions.append(act)
-act = E5Action(self.trUtf8('Single Step'),
+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(
 """ debugger at the next statement.</p>"""
 ))
 act.triggered[()].connect(self.__step)
 self.actions.append(act)
-act = E5Action(self.trUtf8('Step Over'),
+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"""
 """ has completed.</p>"""
 ))
 act.triggered[()].connect(self.__stepOver)
 self.actions.append(act)
-act = E5Action(self.trUtf8('Step Out'),
+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"""
 """ current frame has been left.</p>"""
 ))
 act.triggered[()].connect(self.__stepOut)
 self.actions.append(act)
-act = E5Action(self.trUtf8('Stop'),
+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(
 act.triggered[()].connect(self.__stepQuit)
 self.actions.append(act)
 self.debugActGrp2 = createActionGroup(self)
-act = E5Action(self.trUtf8('Evaluate'),
+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>"""
 """ shell window.</p>"""
 ))
 act.triggered[()].connect(self.__eval)
 self.actions.append(act)
-act = E5Action(self.trUtf8('Execute'),
+act = E5Action(
-self.trUtf8('E&xecute...'),
+self.trUtf8('Execute'),
-0, 0, self.debugActGrp2, 'dbg_execute')
+self.trUtf8('E&xecute...'),
+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"""
 """ of the debugged program.</p>"""
 ))
 act.triggered[()].connect(self.__exec)
 self.actions.append(act)
-self.dbgFilterAct = E5Action(self.trUtf8('Variables Type Filter'),
+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(
 ))
 self.dbgFilterAct.triggered[()].connect(
 self.__configureVariablesFilters)
 self.actions.append(self.dbgFilterAct)
-self.excFilterAct = E5Action(self.trUtf8('Exceptions Filter'),
+self.excFilterAct = E5Action(
+self.trUtf8('Exceptions Filter'),
 self.trUtf8('&Exceptions Filter...'), 0, 0, self,
 'dbg_exceptions_filter')
 self.excFilterAct.setStatusTip(self.trUtf8(
 'Configure exceptions filter'))
 self.excFilterAct.setWhatsThis(self.trUtf8(
 ))
 self.excFilterAct.triggered[()].connect(
 self.__configureExceptionsFilter)
 self.actions.append(self.excFilterAct)
-self.excIgnoreFilterAct = E5Action(self.trUtf8('Ignored Exceptions'),
+self.excIgnoreFilterAct = E5Action(
-self.trUtf8('&Ignored Exceptions...'), 0, 0,
+self.trUtf8('Ignored Exceptions'),
-self, 'dbg_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"""
 self.__configureIgnoredExceptions)
 self.actions.append(self.excIgnoreFilterAct)
 self.dbgSetBpActGrp = createActionGroup(self)
-self.dbgToggleBpAct = E5Action(self.trUtf8('Toggle Breakpoint'),
+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, self.dbgSetBpActGrp, 'dbg_toggle_breakpoint')
 self.dbgToggleBpAct.setStatusTip(self.trUtf8('Toggle Breakpoint'))
 """ current editor.</p>"""
 ))
 self.dbgToggleBpAct.triggered[()].connect(self.__toggleBreakpoint)
 self.actions.append(self.dbgToggleBpAct)
-self.dbgEditBpAct = E5Action(self.trUtf8('Edit Breakpoint'),
+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'))
 """ 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'),
+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,
 self.dbgSetBpActGrp, 'dbg_next_breakpoint')
 """<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'),
+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")),
 0, self.dbgSetBpActGrp, 'dbg_previous_breakpoint')
 """<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'),
+act = E5Action(
+self.trUtf8('Clear Breakpoints'),
 self.trUtf8('Clear Breakpoints'),
 QKeySequence(
 self.trUtf8("Ctrl+Shift+C", "Debug|Clear Breakpoints")), 0,
 self.dbgSetBpActGrp, 'dbg_clear_breakpoint')
 act.setStatusTip(self.trUtf8('Clear Breakpoints'))
 # 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',
+Preferences.Prefs.settings.setValue(
-self.argvHistory)
+'DebugInfo/ArgumentsHistory', self.argvHistory)
 Preferences.Prefs.settings.setValue(
 'DebugInfo/WorkingDirectoryHistory', self.wdHistory)
-Preferences.Prefs.settings.setValue('DebugInfo/EnvironmentHistory',
+Preferences.Prefs.settings.setValue(
-self.envHistory)
+'DebugInfo/EnvironmentHistory', self.envHistory)
-Preferences.Prefs.settings.setValue('DebugInfo/Exceptions',
+Preferences.Prefs.settings.setValue(
-self.excList)
+'DebugInfo/Exceptions', self.excList)
-Preferences.Prefs.settings.setValue('DebugInfo/IgnoredExceptions',
+Preferences.Prefs.settings.setValue(
-self.excIgnoreList)
+'DebugInfo/IgnoredExceptions', self.excIgnoreList)
-Preferences.Prefs.settings.setValue('DebugInfo/ReportExceptions',
+Preferences.Prefs.settings.setValue(
-self.exceptions)
+'DebugInfo/ReportExceptions', self.exceptions)
-Preferences.Prefs.settings.setValue('DebugInfo/AutoClearShell',
+Preferences.Prefs.settings.setValue(
-self.autoClearShell)
+'DebugInfo/AutoClearShell', self.autoClearShell)
-Preferences.Prefs.settings.setValue('DebugInfo/TracePython',
+Preferences.Prefs.settings.setValue(
-self.tracePython)
+'DebugInfo/TracePython', self.tracePython)
-Preferences.Prefs.settings.setValue('DebugInfo/AutoContinue',
+Preferences.Prefs.settings.setValue(
-self.autoContinue)
+'DebugInfo/AutoContinue', self.autoContinue)
-Preferences.Prefs.settings.setValue('DebugInfo/ForkAutomatically',
+Preferences.Prefs.settings.setValue(
-self.forkAutomatically)
+'DebugInfo/ForkAutomatically', self.forkAutomatically)
-Preferences.Prefs.settings.setValue('DebugInfo/ForkIntoChild',
+Preferences.Prefs.settings.setValue(
-self.forkIntoChild)
+'DebugInfo/ForkIntoChild', self.forkIntoChild)
 def shutdownServer(self):
 """
 Public method to shut down the debug server.
 self.__resetUI()
 if not Preferences.getDebugger("SuppressClientExit") or status != 0:
 if self.ui.currentProg is None:
-E5MessageBox.information(self.ui, Program,
+E5MessageBox.information(
+self.ui, Program,
 self.trUtf8('<p>The program has terminated with an exit'
 ' status of {0}.</p>').format(status))
 else:
-E5MessageBox.information(self.ui, Program,
+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))
 else:
 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
 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,
+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))
 """
 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 \
 exceptionType not in self.excIgnoreList and \
 (not len(self.excList) or \
 (len(self.excList) and exceptionType in self.excList)))\
 or exceptionType.startswith('unhandled'):
 res = None
 if stackTrace:
 try:
 file, line = stackTrace[0][:2]
 else:
 buttons = E5MessageBox.StandardButtons(
 E5MessageBox.No | \
 E5MessageBox.Yes | \
 E5MessageBox.Ignore)
-res = E5MessageBox.critical(self.ui, Program,
+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>')
 stackTrace[0][0],
 stackTrace[0][1]),
 buttons,
 E5MessageBox.No)
 else:
-res = E5MessageBox.critical(self.ui, Program,
+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,
 @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 handle a condition error of a breakpoint.
 @param filename filename of the breakpoint (string)
 @param lineno linenumber of the breakpoint (integer)
 """
-E5MessageBox.critical(self.ui,
+E5MessageBox.critical(
+self.ui,
 self.trUtf8("Breakpoint Condition Error"),
 self.trUtf8(
 """<p>The condition of the breakpoint <b>{0}, {1}</b>"""
 """ contains a syntax error.</p>""")\
 .format(filename, lineno))
 return
 fn, line, cond, temp, enabled, count = bp[:6]
 from .EditBreakpointDialog import EditBreakpointDialog
-dlg = EditBreakpointDialog((fn, line), (cond, temp, enabled, count),
+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))
 Note: This can only happen for normal watch expressions
 @param cond expression of the watch expression (string)
 """
-E5MessageBox.critical(self.ui,
+E5MessageBox.critical(
+self.ui,
 self.trUtf8("Watch Expression Error"),
 self.trUtf8("""<p>The watch expression <b>{0}</b>"""
 """ contains a syntax error.</p>""")\
 .format(cond))
 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>'"""
+msg = self.trUtf8(
-""" for the variable <b>{1}</b> already"""
+"""<p>A watch expression '<b>{0}</b>'"""
-""" exists.</p>""")\
+""" for the variable <b>{1}</b> already"""
-.format(special,
+""" exists.</p>""")\
-Utilities.html_encode(cond))
+.format(special,
-E5MessageBox.warning(self,
+Utilities.html_encode(cond))
+E5MessageBox.warning(
+self.ui,
 self.trUtf8("Watch expression already exists"),
 msg)
 model.deleteWatchPointByIndex(index)
 else:
 model.setWatchPointByIndex(index, cond, special,
 # 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,
+dlg = StartDialog(
+cap, self.argvHistory, self.wdHistory,
 self.envHistory, 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:
 fn = self.project.getMainScript(1)
 if fn is None:
-E5MessageBox.critical(self.ui,
+E5MessageBox.critical(
+self.ui,
 self.trUtf8("Coverage of Project"),
-self.trUtf8("There is no main script defined for the"
+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):
 fn = os.path.join(getConfig('ericDir'), "eric5.py")
 self.debugViewer.initCallStackViewer(runProject)
 # Ask the client to open the new program.
-self.debugServer.remoteCoverage(fn, argv, wd, env,
+self.debugServer.remoteCoverage(
+fn, argv, wd, env,
 autoClearShell=self.autoClearShell, erase=eraseCoverage,
 forProject=runProject, runInConsole=console,
 clientType=self.clientType)
 self.stopAct.setEnabled(True)
 eraseTimings = dlg.getProfilingData()
 if runProject:
 fn = self.project.getMainScript(1)
 if fn is None:
-E5MessageBox.critical(self.ui,
+E5MessageBox.critical(
+self.ui,
 self.trUtf8("Profile of Project"),
-self.trUtf8("There is no main script defined for the"
+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):
 fn = os.path.join(getConfig('ericDir'), "eric5.py")
 self.debugViewer.initCallStackViewer(runProject)
 # Ask the client to open the new program.
-self.debugServer.remoteProfile(fn, argv, wd, env,
+self.debugServer.remoteProfile(
+fn, argv, wd, env,
 autoClearShell=self.autoClearShell, erase=eraseTimings,
 forProject=runProject, runInConsole=console,
 clientType=self.clientType)
 self.stopAct.setEnabled(True)
 forkAutomatically, forkIntoChild = dlg.getRunData()
 if runProject:
 fn = self.project.getMainScript(1)
 if fn is None:
-E5MessageBox.critical(self.ui,
+E5MessageBox.critical(
+self.ui,
 self.trUtf8("Run Project"),
-self.trUtf8("There is no main script defined for the"
+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):
 fn = os.path.join(getConfig('ericDir'), "eric5.py")
 self.debugViewer.initCallStackViewer(runProject)
 # Ask the client to open the new program.
-self.debugServer.remoteRun(fn, argv, wd, env,
+self.debugServer.remoteRun(
+fn, argv, wd, env,
 autoClearShell=self.autoClearShell, forProject=runProject,
 runInConsole=console, autoFork=forkAutomatically,
 forkChild=forkIntoChild, clientType=self.clientType)
 self.stopAct.setEnabled(True)
 dlg.getDebugData()
 if debugProject:
 fn = self.project.getMainScript(True)
 if fn is None:
-E5MessageBox.critical(self.ui,
+E5MessageBox.critical(
+self.ui,
 self.trUtf8("Debug Project"),
-self.trUtf8("There is no main script defined for the"
+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):
 enableCallTrace = self.debugViewer.isCallTraceEnabled()
 self.debugViewer.clearCallTrace()
 self.debugViewer.setCallTraceToProjectMode(debugProject)
 # Ask the client to open the new program.
-self.debugServer.remoteLoad(fn, argv, wd, env,
+self.debugServer.remoteLoad(
+fn, argv, wd, env,
 autoClearShell=self.autoClearShell,
 tracePython=tracePython,
 autoContinue=autoContinue, forProject=debugProject,
 runInConsole=console, autoFork=forkAutomatically,
 forkChild=forkIntoChild, clientType=self.clientType,
 # 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,
+not self.viewmanager.checkDirty(
-Preferences.getDebugger("Autosave")):
+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):
 """
 self.lastAction = 0
 aw = self.viewmanager.activeWindow()
 line = aw.getCursorPosition()[0] + 1
 self.__enterRemote()
-self.debugServer.remoteBreakpoint(aw.getFileName(),
+self.debugServer.remoteBreakpoint(
-line, 1, None, 1)
+aw.getFileName(), line, 1, None, 1)
 self.debugServer.remoteContinue()
 def __eval(self):
 """
 Private method to handle the Eval action.

Mercurial Repositories > eric / file comparison

comparison: Debugger/DebugUI.py

Debugger/DebugUI.py