eric: comparison eric7/Debugger/DebugUI.py

-:8a7677a63c8d
+:68ec9c3d4de5
 from PyQt6.QtCore import pyqtSignal, pyqtSlot, QObject, Qt, QKeyCombination
 from PyQt6.QtGui import QKeySequence
 from PyQt6.QtWidgets import QMenu, QToolBar, QApplication, QDialog
-from E5Gui.E5Action import E5Action, createActionGroup
+from E5Gui.EricAction import EricAction, createActionGroup
-from E5Gui import E5MessageBox
+from E5Gui import EricMessageBox
 from UI.Info import Program
 from UI.NotificationWidget import NotificationTypes
 from .DebugClientCapabilities import (
 """
 Public method defining the user interface actions.
 """
 self.actions = []
-self.runAct = E5Action(
+self.runAct = EricAction(
 self.tr('Run Script'),
 UI.PixmapCache.getIcon("runScript"),
 self.tr('&Run Script...'),
 Qt.Key.Key_F2, 0, self, 'dbg_run_script')
 self.runAct.setStatusTip(self.tr('Run the current Script'))
 """ saved first.</p>"""
 ))
 self.runAct.triggered.connect(self.__runScript)
 self.actions.append(self.runAct)
-self.runProjectAct = E5Action(
+self.runProjectAct = EricAction(
 self.tr('Run Project'),
 UI.PixmapCache.getIcon("runProject"),
 self.tr('Run &Project...'),
 QKeyCombination(Qt.Modifier.SHIFT, Qt.Key.Key_F2),
 0, self, 'dbg_run_project')
 """ may be saved first.</p>"""
 ))
 self.runProjectAct.triggered.connect(self.__runProject)
 self.actions.append(self.runProjectAct)
-self.coverageAct = E5Action(
+self.coverageAct = EricAction(
 self.tr('Coverage run of Script'),
 UI.PixmapCache.getIcon("coverageScript"),
 self.tr('Coverage run of Script...'), 0, 0, self,
 'dbg_coverage_script')
 self.coverageAct.setStatusTip(
 """ unsaved changes it may be saved first.</p>"""
 ))
 self.coverageAct.triggered.connect(self.__coverageScript)
 self.actions.append(self.coverageAct)
-self.coverageProjectAct = E5Action(
+self.coverageProjectAct = EricAction(
 self.tr('Coverage run of Project'),
 UI.PixmapCache.getIcon("coverageProject"),
 self.tr('Coverage run of Project...'), 0, 0, self,
 'dbg_coverage_project')
 self.coverageProjectAct.setStatusTip(
 """ they may be saved first.</p>"""
 ))
 self.coverageProjectAct.triggered.connect(self.__coverageProject)
 self.actions.append(self.coverageProjectAct)
-self.profileAct = E5Action(
+self.profileAct = EricAction(
 self.tr('Profile Script'),
 UI.PixmapCache.getIcon("profileScript"),
 self.tr('Profile Script...'), 0, 0, self, 'dbg_profile_script')
 self.profileAct.setStatusTip(self.tr('Profile the current Script'))
 self.profileAct.setWhatsThis(self.tr(
 """ 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.profileProjectAct = EricAction(
 self.tr('Profile Project'),
 UI.PixmapCache.getIcon("profileProject"),
 self.tr('Profile Project...'), 0, 0, self,
 'dbg_profile_project')
 self.profileProjectAct.setStatusTip(
 """ changes they may be saved first.</p>"""
 ))
 self.profileProjectAct.triggered.connect(self.__profileProject)
 self.actions.append(self.profileProjectAct)
-self.debugAct = E5Action(
+self.debugAct = EricAction(
 self.tr('Debug Script'),
 UI.PixmapCache.getIcon("debugScript"),
 self.tr('&Debug Script...'), Qt.Key.Key_F5, 0, self,
 'dbg_debug_script')
 self.debugAct.setStatusTip(self.tr('Debug the current Script'))
 """ saved first.</p>"""
 ))
 self.debugAct.triggered.connect(self.__debugScript)
 self.actions.append(self.debugAct)
-self.debugProjectAct = E5Action(
+self.debugProjectAct = EricAction(
 self.tr('Debug Project'),
 UI.PixmapCache.getIcon("debugProject"),
 self.tr('Debug &Project...'),
 QKeyCombination(Qt.Modifier.SHIFT, Qt.Key.Key_F5),
 0, self, 'dbg_debug_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.restartAct = EricAction(
 self.tr('Restart'),
 UI.PixmapCache.getIcon("debugRestart"),
 self.tr('Restart'), Qt.Key.Key_F4, 0, self, 'dbg_restart_script')
 self.restartAct.setStatusTip(self.tr(
 'Restart the last debugged script'))
 """ may be saved first.</p>"""
 ))
 self.restartAct.triggered.connect(self.__doRestart)
 self.actions.append(self.restartAct)
-self.stopAct = E5Action(
+self.stopAct = EricAction(
 self.tr('Stop'),
 UI.PixmapCache.getIcon("stopScript"),
 self.tr('Stop'),
 QKeyCombination(Qt.Modifier.SHIFT, Qt.Key.Key_F10),
 0,
 self.stopAct.triggered.connect(self.__stopScript)
 self.actions.append(self.stopAct)
 self.debugActGrp = createActionGroup(self)
-act = E5Action(
+act = EricAction(
 self.tr('Continue'),
 UI.PixmapCache.getIcon("continue"),
 self.tr('&Continue'), Qt.Key.Key_F6, 0,
 self.debugActGrp, 'dbg_continue')
 act.setStatusTip(
 """ is reached.</p>"""
 ))
 act.triggered.connect(self.__continue)
 self.actions.append(act)
-act = E5Action(
+act = EricAction(
 self.tr('Continue to Cursor'),
 UI.PixmapCache.getIcon("continueToCursor"),
 self.tr('Continue &To Cursor'),
 QKeyCombination(Qt.Modifier.SHIFT, Qt.Key.Key_F6),
 0, self.debugActGrp, 'dbg_continue_to_cursor')
 """ current cursor position.</p>"""
 ))
 act.triggered.connect(self.__runToCursor)
 self.actions.append(act)
-act = E5Action(
+act = EricAction(
 self.tr('Continue Until'),
 UI.PixmapCache.getIcon("continueUntil"),
 self.tr('Continue &Until'),
 QKeyCombination(Qt.Modifier.CTRL, Qt.Key.Key_F6),
 0,
 """ leaving the current frame.</p>"""
 ))
 act.triggered.connect(self.__runUntil)
 self.actions.append(act)
-act = E5Action(
+act = EricAction(
 self.tr('Move Instruction Pointer to Cursor'),
 UI.PixmapCache.getIcon("moveInstructionPointer"),
 self.tr('&Jump To Cursor'), Qt.Key.Key_F12, 0,
 self.debugActGrp, 'dbg_jump_to_cursor')
 act.setStatusTip(self.tr(
 """ message is printed to the log window.</p>"""
 ))
 act.triggered.connect(self.__moveInstructionPointer)
 self.actions.append(act)
-act = E5Action(
+act = EricAction(
 self.tr('Single Step'),
 UI.PixmapCache.getIcon("step"),
 self.tr('Sin&gle Step'), Qt.Key.Key_F7, 0,
 self.debugActGrp, 'dbg_single_step')
 act.setStatusTip(self.tr('Execute a single Python statement'))
 """ debugger at the next statement.</p>"""
 ))
 act.triggered.connect(self.__step)
 self.actions.append(act)
-act = E5Action(
+act = EricAction(
 self.tr('Step Over'),
 UI.PixmapCache.getIcon("stepOver"),
 self.tr('Step &Over'), Qt.Key.Key_F8, 0,
 self.debugActGrp, 'dbg_step_over')
 act.setStatusTip(self.tr(
 """ has completed.</p>"""
 ))
 act.triggered.connect(self.__stepOver)
 self.actions.append(act)
-act = E5Action(
+act = EricAction(
 self.tr('Step Out'),
 UI.PixmapCache.getIcon("stepOut"),
 self.tr('Step Ou&t'), Qt.Key.Key_F9, 0,
 self.debugActGrp, 'dbg_step_out')
 act.setStatusTip(self.tr(
 """ current frame has been left.</p>"""
 ))
 act.triggered.connect(self.__stepOut)
 self.actions.append(act)
-act = E5Action(
+act = EricAction(
 self.tr('Stop'),
 UI.PixmapCache.getIcon("stepQuit"),
 self.tr('&Stop'), Qt.Key.Key_F10, 0,
 self.debugActGrp, 'dbg_stop')
 act.setStatusTip(self.tr('Stop debugging'))
 """<p>Stop the running debugging session.</p>"""
 ))
 act.triggered.connect(self.__stepQuit)
 self.actions.append(act)
-self.dbgFilterAct = E5Action(
+self.dbgFilterAct = EricAction(
 self.tr('Variables Type Filter'),
 self.tr('Varia&bles Type Filter...'), 0, 0, self,
 'dbg_variables_filter')
 self.dbgFilterAct.setStatusTip(self.tr(
 'Configure variables type filter'))
 ))
 self.dbgFilterAct.triggered.connect(
 self.__configureVariablesFilters)
 self.actions.append(self.dbgFilterAct)
-self.excFilterAct = E5Action(
+self.excFilterAct = EricAction(
 self.tr('Exceptions Filter'),
 self.tr('&Exceptions Filter...'), 0, 0, self,
 'dbg_exceptions_filter')
 self.excFilterAct.setStatusTip(self.tr(
 'Configure exceptions filter'))
 ))
 self.excFilterAct.triggered.connect(
 self.__configureExceptionsFilter)
 self.actions.append(self.excFilterAct)
-self.excIgnoreFilterAct = E5Action(
+self.excIgnoreFilterAct = EricAction(
 self.tr('Ignored Exceptions'),
 self.tr('&Ignored Exceptions...'), 0, 0,
 self, 'dbg_ignored_exceptions')
 self.excIgnoreFilterAct.setStatusTip(self.tr(
 'Configure ignored exceptions'))
 self.__configureIgnoredExceptions)
 self.actions.append(self.excIgnoreFilterAct)
 self.dbgSetBpActGrp = createActionGroup(self)
-self.dbgToggleBpAct = E5Action(
+self.dbgToggleBpAct = EricAction(
 self.tr('Toggle Breakpoint'),
 UI.PixmapCache.getIcon("breakpointToggle"),
 self.tr('Toggle Breakpoint'),
 QKeySequence(self.tr("Shift+F11", "Debug|Toggle Breakpoint")),
 0, self.dbgSetBpActGrp, 'dbg_toggle_breakpoint')
 """ current editor.</p>"""
 ))
 self.dbgToggleBpAct.triggered.connect(self.__toggleBreakpoint)
 self.actions.append(self.dbgToggleBpAct)
-self.dbgEditBpAct = E5Action(
+self.dbgEditBpAct = EricAction(
 self.tr('Edit Breakpoint'),
 UI.PixmapCache.getIcon("cBreakpointToggle"),
 self.tr('Edit Breakpoint...'),
 QKeySequence(self.tr("Shift+F12", "Debug|Edit Breakpoint")), 0,
 self.dbgSetBpActGrp, 'dbg_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.dbgNextBpAct = EricAction(
 self.tr('Next Breakpoint'),
 UI.PixmapCache.getIcon("breakpointNext"),
 self.tr('Next Breakpoint'),
 QKeySequence(
 self.tr("Ctrl+Shift+PgDown", "Debug|Next Breakpoint")), 0,
 """<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.dbgPrevBpAct = EricAction(
 self.tr('Previous Breakpoint'),
 UI.PixmapCache.getIcon("breakpointPrevious"),
 self.tr('Previous Breakpoint'),
 QKeySequence(
 self.tr("Ctrl+Shift+PgUp", "Debug|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(
+act = EricAction(
 self.tr('Clear Breakpoints'),
 self.tr('Clear Breakpoints'),
 0, 0,
 self.dbgSetBpActGrp, 'dbg_clear_breakpoint')
 act.setStatusTip(self.tr('Clear Breakpoints'))
 def initToolbars(self, toolbarManager):
 """
 Public slot to initialize the debug toolbars.
 @param toolbarManager reference to a toolbar manager object
-(E5ToolBarManager)
+(EricToolBarManager)
 @return the generated toolbars (list of QToolBar)
 """
 starttb = QToolBar(self.tr("Start"), self.ui)
 starttb.setIconSize(UI.Config.ToolBarIconSize)
 starttb.setObjectName("StartToolbar")
 self.__resetUI()
 self.ui.raise_()
 self.ui.activateWindow()
 if message is None:
-E5MessageBox.critical(
+EricMessageBox.critical(
 self.ui, Program,
 self.tr(
 'The program being debugged contains an unspecified'
 ' syntax error.'))
 return
 if ms is not None:
 d = os.path.dirname(ms)
 if os.path.exists(os.path.join(d, filename)):
 filename = os.path.join(d, filename)
 self.viewmanager.setFileLine(filename, lineNo, True, True)
-E5MessageBox.critical(
+EricMessageBox.critical(
 self.ui, Program,
 self.tr('<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))
 @type str
 """
 self.ui.raise_()
 QApplication.processEvents()
 if not exceptionType:
-E5MessageBox.critical(
+EricMessageBox.critical(
 self.ui, Program,
 self.tr('An unhandled exception occured.'
 ' See the shell window for details.'))
 return
 source[line - 1].strip())
 with contextlib.suppress(IndexError):
 lineFlags += Utilities.extractLineFlags(
 source[line].strip(), flagsLine=True)
 if "__IGNORE_EXCEPTION__" in lineFlags:
-res = E5MessageBox.No
+res = EricMessageBox.No
-if res != E5MessageBox.No:
+if res != EricMessageBox.No:
 self.viewmanager.setFileLine(
 stackTrace[0][0], stackTrace[0][1], True)
-if res != E5MessageBox.No:
+if res != EricMessageBox.No:
 self.ui.activateWindow()
 if Preferences.getDebugger("BreakAlways"):
-res = E5MessageBox.Yes
+res = EricMessageBox.Yes
 else:
 if stackTrace:
 if exceptionType.startswith('unhandled'):
-buttons = E5MessageBox.No | E5MessageBox.Yes
+buttons = EricMessageBox.No | EricMessageBox.Yes
 else:
-buttons = (E5MessageBox.No |
+buttons = (EricMessageBox.No |
-E5MessageBox.Yes |
+EricMessageBox.Yes |
-E5MessageBox.Ignore)
+EricMessageBox.Ignore)
-res = E5MessageBox.critical(
+res = EricMessageBox.critical(
 self.ui, Program,
 self.tr(
 '<p>The debugged program raised the exception'
 ' <b>{0}</b><br>"<b>{1}</b>"<br>'
 'File: <b>{2}</b>, Line: <b>{3}</b></p>'
 exceptionType,
 Utilities.html_encode(exceptionMessage),
 stackTrace[0][0],
 stackTrace[0][1]),
 buttons,
-E5MessageBox.No)
+EricMessageBox.No)
 else:
-res = E5MessageBox.critical(
+res = EricMessageBox.critical(
 self.ui, Program,
 self.tr(
 '<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:
+if res == EricMessageBox.Yes:
 self.debugServer.setDebugging(True)
 self.exceptionInterrupt.emit()
 stack = []
 for fn, ln, func, args in stackTrace:
 stack.append((fn, ln, func, args))
 self.__getClientDisassembly(debuggerId)
 self.ui.setDebugProfile()
 self.debugActGrp.setEnabled(True)
 return
 elif (
-res == E5MessageBox.Ignore and
+res == EricMessageBox.Ignore and
 exceptionType not in self.excIgnoreList
 ):
 self.excIgnoreList.append(exceptionType)
 if self.lastAction != -1:
 """
 self.ui.raise_()
 self.ui.activateWindow()
 QApplication.processEvents()
 self.viewmanager.setFileLine(filename, lineNo, True)
-E5MessageBox.critical(
+EricMessageBox.critical(
 self.ui, Program,
 self.tr("""<p>The program generate the signal "{0}".<br/>"""
 """File: <b>{1}</b>, Line: <b>{2}</b></p>""").format(
 message, filename, lineNo))
 @param unplanned True if the client died, False otherwise
 """
 self.__resetUI()
 if unplanned:
-E5MessageBox.information(
+EricMessageBox.information(
 self.ui, Program,
 self.tr('The program being debugged has terminated'
 ' unexpectedly.'))
 def __getThreadList(self, debuggerId):
 @param lineno line umber of the breakpoint
 @type int
 @param debuggerId ID of the debugger backend
 @type str
 """
-E5MessageBox.critical(
+EricMessageBox.critical(
 self.ui,
 self.tr("Breakpoint Condition Error"),
 self.tr(
 """<p>The condition of the breakpoint <b>{0}, {1}</b>"""
 """ contains a syntax error.</p>""")
 @param cond expression of the watch expression
 @type str
 @param debuggerId ID of the debugger backend
 @type str
 """
-E5MessageBox.critical(
+EricMessageBox.critical(
 self.ui,
 self.tr("Watch Expression Error"),
 self.tr("""<p>The watch expression <b>{0}</b>"""
 """ contains a syntax error.</p>""")
 .format(cond))
 msg = self.tr(
 """<p>A watch expression '<b>{0}</b>'"""
 """ for the variable <b>{1}</b> already"""
 """ exists.</p>"""
 ).format(special, Utilities.html_encode(cond))
-E5MessageBox.warning(
+EricMessageBox.warning(
 self.ui,
 self.tr("Watch expression already exists"),
 msg)
 model.deleteWatchPointByIndex(index)
 else:
 eraseCoverage = dlg.getCoverageData()
 if runProject:
 fn = self.project.getMainScript(True)
 if fn is None:
-E5MessageBox.critical(
+EricMessageBox.critical(
 self.ui,
 self.tr("Coverage of Project"),
 self.tr(
 "There is no main script defined for the"
 " current project. Aborting"))
 eraseTimings = dlg.getProfilingData()
 if runProject:
 fn = self.project.getMainScript(True)
 if fn is None:
-E5MessageBox.critical(
+EricMessageBox.critical(
 self.ui,
 self.tr("Profile of Project"),
 self.tr(
 "There is no main script defined for the"
 " current project. Aborting"))
 configOverride = dlg.getGlobalOverrideData()
 if runProject:
 fn = self.project.getMainScript(True)
 if fn is None:
-E5MessageBox.critical(
+EricMessageBox.critical(
 self.ui,
 self.tr("Run Project"),
 self.tr(
 "There is no main script defined for the"
 " current project. Aborting"))
 multiprocessNoDebug) = dlg.getDebugData()
 if debugProject:
 fn = self.project.getMainScript(True)
 if fn is None:
-E5MessageBox.critical(
+EricMessageBox.critical(
 self.ui,
 self.tr("Debug Project"),
 self.tr(
 "There is no main script defined for the"
 " current project. No debugging possible."))
 def getActions(self):
 """
 Public method to get a list of all actions.
-@return list of all actions (list of E5Action)
+@return list of all actions (list of EricAction)
 """
 return self.actions[:]
 def getSelectedDebuggerId(self):
 """

Mercurial Repositories > eric / file comparison

comparison: eric7/Debugger/DebugUI.py

eric7/Debugger/DebugUI.py