eric: comparison Debugger/DebugUI.py

-:0bc58cbb64b2
+:a81097a85889
 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.connect(self.runAct, SIGNAL('triggered()'), self.__runScript)
+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,
 """<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"""
 """ be saved first.</p>"""
 ))
-self.connect(self.runProjectAct, SIGNAL('triggered()'), self.__runProject)
+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')
 """<b>Coverage run of Script</b>"""
 """<p>Set the command line arguments and run the script under the control"""
 """ of a coverage analysis tool. If the file has unsaved changes it may be"""
 """ saved first.</p>"""
 ))
-self.connect(self.coverageAct, SIGNAL('triggered()'), self.__coverageScript)
+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')
 """<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"""
 """ be saved first.</p>"""
 ))
-self.connect(self.coverageProjectAct, SIGNAL('triggered()'), self.__coverageProject)
+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.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.connect(self.profileAct, SIGNAL('triggered()'), self.__profileScript)
+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')
 """<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"""
 """ be saved first.</p>"""
 ))
-self.connect(self.profileProjectAct, SIGNAL('triggered()'), self.__profileProject)
+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')
 """<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."""
 """ If the file has unsaved changes it may be saved first.</p>"""
 ))
-self.connect(self.debugAct, SIGNAL('triggered()'), self.__debugScript)
+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,
 """<p>Set the command line arguments and set the current line to be the"""
 """ first executable Python statement of the main script of the current"""
 """ project. If files of the current project have unsaved changes they may"""
 """ be saved first.</p>"""
 ))
-self.connect(self.debugProjectAct, SIGNAL('triggered()'), self.__debugProject)
+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')
 """<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."""
 """ If there are unsaved changes, they may be saved first.</p>"""
 ))
-self.connect(self.restartAct, SIGNAL('triggered()'), self.__doRestart)
+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.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.connect(self.stopAct, SIGNAL('triggered()'), self.__stopScript)
+self.stopAct.triggered.connect(self.__stopScript)
 self.actions.append(self.stopAct)
 self.debugActGrp = createActionGroup(self)
 act = E5Action(self.trUtf8('Continue'),
 act.setWhatsThis(self.trUtf8(
 """<b>Continue</b>"""
 """<p>Continue running the program from the current line. The program will"""
 """ stop when it terminates or when a breakpoint is reached.</p>"""
 ))
-self.connect(act, SIGNAL('triggered()'), self.__continue)
+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,
 act.setWhatsThis(self.trUtf8(
 """<b>Continue To Cursor</b>"""
 """<p>Continue running the program from the current line to the"""
 """ current cursor position.</p>"""
 ))
-self.connect(act, SIGNAL('triggered()'), self.__runToCursor)
+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,
 """<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"""
 """ the next statement.</p>"""
 ))
-self.connect(act, SIGNAL('triggered()'), self.__step)
+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,
 """<p>Execute a single Python statement staying in the same frame. 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"""
 """ after the statement has completed.</p>"""
 ))
-self.connect(act, SIGNAL('triggered()'), self.__stepOver)
+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,
 """<p>Execute Python statements until leaving the current frame. If"""
 """ the statements are inside an <tt>import</tt> statement, a class"""
 """ constructor, or a method or function call then control is returned"""
 """ to the debugger after the current frame has been left.</p>"""
 ))
-self.connect(act, SIGNAL('triggered()'), self.__stepOut)
+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,
 act.setStatusTip(self.trUtf8('Stop debugging'))
 act.setWhatsThis(self.trUtf8(
 """<b>Stop</b>"""
 """<p>Stop the running debugging session.</p>"""
 ))
-self.connect(act, SIGNAL('triggered()'), self.__stepQuit)
+act.triggered.connect(self.__stepQuit)
 self.actions.append(act)
 self.debugActGrp2 = createActionGroup(self)
 act = E5Action(self.trUtf8('Evaluate'),
 """<b>Evaluate</b>"""
 """<p>Evaluate an expression in the current context of the"""
 """ debugged program. The result is displayed in the"""
 """ shell window.</p>"""
 ))
-self.connect(act, SIGNAL('triggered()'), self.__eval)
+act.triggered.connect(self.__eval)
 self.actions.append(act)
 act = E5Action(self.trUtf8('Execute'),
 self.trUtf8('E&xecute...'),
 0,0,self.debugActGrp2,'dbg_execute')
 act.setWhatsThis(self.trUtf8(
 """<b>Execute</b>"""
 """<p>Execute a one line statement in the current context"""
 """ of the debugged program.</p>"""
 ))
-self.connect(act, SIGNAL('triggered()'), self.__exec)
+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')
 """<b>Variables Type Filter</b>"""
 """<p>Configure the variables type filter. Only variable types that are not"""
 """ selected are displayed in the global or local variables window"""
 """ during a debugging session.</p>"""
 ))
-self.connect(self.dbgFilterAct, SIGNAL('triggered()'),
+self.dbgFilterAct.triggered.connect(self.__configureVariablesFilters)
-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.excFilterAct.setStatusTip(self.trUtf8('Configure exceptions filter'))
 """<p>Configure the exceptions filter. Only exception types that are"""
 """ listed are highlighted during a debugging session.</p>"""
 """<p>Please note, that all unhandled exceptions are highlighted"""
 """ indepent from the filter list.</p>"""
 ))
-self.connect(self.excFilterAct, SIGNAL('triggered()'),
+self.excFilterAct.triggered.connect(self.__configureExceptionsFilter)
-self.__configureExceptionsFilter)
 self.actions.append(self.excFilterAct)
 self.excIgnoreFilterAct = E5Action(self.trUtf8('Ignored Exceptions'),
 self.trUtf8('&Ignored Exceptions...'), 0, 0,
 self, 'dbg_ignored_exceptions')
 """<b>Ignored Exceptions</b>"""
 """<p>Configure the ignored exceptions. Only exception types that are"""
 """ not listed are highlighted during a debugging session.</p>"""
 """<p>Please note, that unhandled exceptions cannot be ignored.</p>"""
 ))
-self.connect(self.excIgnoreFilterAct, SIGNAL('triggered()'),
+self.excIgnoreFilterAct.triggered.connect(self.__configureIgnoredExceptions)
-self.__configureIgnoredExceptions)
 self.actions.append(self.excIgnoreFilterAct)
 self.dbgSetBpActGrp = createActionGroup(self)
 self.dbgToggleBpAct = E5Action(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.connect(self.dbgToggleBpAct, SIGNAL('triggered()'), self.__toggleBreakpoint)
+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...'),
 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.connect(self.dbgEditBpAct, SIGNAL('triggered()'), self.__editBreakpoint)
+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'),
 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.connect(self.dbgNextBpAct, SIGNAL('triggered()'), self.__nextBreakpoint)
+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'),
 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.connect(self.dbgPrevBpAct, SIGNAL('triggered()'), self.__previousBreakpoint)
+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,
 act.setStatusTip(self.trUtf8('Clear Breakpoints'))
 act.setWhatsThis(self.trUtf8(
 """<b>Clear Breakpoints</b>"""
 """<p>Clear breakpoints of all editors.</p>"""
 ))
-self.connect(act, SIGNAL('triggered()'), self.__clearBreakpoints)
+act.triggered.connect(self.__clearBreakpoints)
 self.actions.append(act)
 self.debugActGrp.setEnabled(False)
 self.debugActGrp2.setEnabled(False)
 self.dbgSetBpActGrp.setEnabled(False)

Mercurial Repositories > eric / file comparison

comparison: Debugger/DebugUI.py

Debugger/DebugUI.py