eric: comparison eric7/UI/UserInterface.py

-:8a7677a63c8d
+:68ec9c3d4de5
 from .Info import Version, VersionOnly, BugAddress, Program, FeatureAddress
 from . import Config
 from .NotificationWidget import NotificationTypes
-from E5Gui.E5SingleApplication import E5SingleApplicationServer
+from E5Gui.EricSingleApplication import EricSingleApplicationServer
-from E5Gui.E5Action import E5Action, createActionGroup
+from E5Gui.EricAction import EricAction, createActionGroup
-from E5Gui.E5ToolBarManager import E5ToolBarManager
+from E5Gui.EricToolBarManager import EricToolBarManager
-from E5Gui import E5MessageBox, E5FileDialog, E5ErrorMessage
+from E5Gui import EricMessageBox, EricFileDialog, EricErrorMessage
-from E5Gui.E5Application import e5App
+from E5Gui.EricApplication import ericApp
-from E5Gui.E5MainWindow import E5MainWindow
+from E5Gui.EricMainWindow import EricMainWindow
-from E5Gui.E5ZoomWidget import E5ZoomWidget
+from E5Gui.EricZoomWidget import EricZoomWidget
-from E5Gui.E5ProgressDialog import E5ProgressDialog
+from E5Gui.EricProgressDialog import EricProgressDialog
-from E5Gui.E5ClickableLabel import E5ClickableLabel
+from E5Gui.EricClickableLabel import EricClickableLabel
 import Preferences
 import Utilities
 import Globals
 """
 self.buffer += str(s)
 self.__nWrite(self.__bufferedWrite())
-class UserInterface(E5MainWindow):
+class UserInterface(EricMainWindow):
 """
 Class implementing the main user interface.
 @signal appendStderr(str) emitted to write data to stderr logger
 @signal appendStdout(str) emitted to write data to stdout logger
 restartArguments, originalPathString):
 """
 Constructor
 @param app reference to the application object
-@type E5Application
+@type EricApplication
 @param locale locale to be used by the UI
 @type str
 @param splash reference to the splashscreen
 @type UI.SplashScreen.SplashScreen
 @param plugin filename of a plug-in to be loaded (used for plugin
 self.profiles = Preferences.getUI("ViewProfiles")
 # Generate the conda interface
 from CondaInterface.Conda import Conda
 self.condaInterface = Conda(self)
-e5App().registerObject("Conda", self.condaInterface)
+ericApp().registerObject("Conda", self.condaInterface)
 # Generate the pip interface
 from PipInterface.Pip import Pip
 self.pipInterface = Pip(self)
-e5App().registerObject("Pip", self.pipInterface)
+ericApp().registerObject("Pip", self.pipInterface)
 # Generate the virtual environment manager
 from VirtualEnv.VirtualenvManager import VirtualenvManager
 self.virtualenvManager = VirtualenvManager(self)
 # register it early because it is needed very soon
-e5App().registerObject("VirtualEnvManager", self.virtualenvManager)
+ericApp().registerObject("VirtualEnvManager", self.virtualenvManager)
 # Generate an empty project object and multi project object
 from Project.Project import Project
 self.project = Project(self)
-e5App().registerObject("Project", self.project)
+ericApp().registerObject("Project", self.project)
 from MultiProject.MultiProject import MultiProject
 self.multiProject = MultiProject(self.project, self)
 # Generate the debug server object
 if self.irc is not None:
 self.irc.autoConnected.connect(self.__ircAutoConnected)
 # create the toolbar manager object
-self.toolbarManager = E5ToolBarManager(self, self)
+self.toolbarManager = EricToolBarManager(self, self)
 self.toolbarManager.setMainWindow(self)
 # Initialize the tool groups and list of started tools
 splash.showMessage(self.tr("Initializing Tools..."))
 self.toolGroups, self.currentToolGroup = Preferences.readToolGroups()
 QDesktopServices.setUrlHandler("http", self.handleUrl)
 QDesktopServices.setUrlHandler("https", self.handleUrl)
 # register all relevant objects
 splash.showMessage(self.tr("Registering Objects..."))
-e5App().registerObject("UserInterface", self)
+ericApp().registerObject("UserInterface", self)
-e5App().registerObject("DebugUI", self.debuggerUI)
+ericApp().registerObject("DebugUI", self.debuggerUI)
-e5App().registerObject("DebugServer", debugServer)
+ericApp().registerObject("DebugServer", debugServer)
-e5App().registerObject("BackgroundService", self.backgroundService)
+ericApp().registerObject("BackgroundService", self.backgroundService)
-e5App().registerObject("ViewManager", self.viewmanager)
+ericApp().registerObject("ViewManager", self.viewmanager)
-e5App().registerObject("ProjectBrowser", self.projectBrowser)
+ericApp().registerObject("ProjectBrowser", self.projectBrowser)
-e5App().registerObject("MultiProject", self.multiProject)
+ericApp().registerObject("MultiProject", self.multiProject)
-e5App().registerObject("TaskViewer", self.taskViewer)
+ericApp().registerObject("TaskViewer", self.taskViewer)
 if self.templateViewer is not None:
-e5App().registerObject("TemplateViewer", self.templateViewer)
+ericApp().registerObject("TemplateViewer", self.templateViewer)
-e5App().registerObject("Shell", self.shell)
+ericApp().registerObject("Shell", self.shell)
-e5App().registerObject("PluginManager", self.pluginManager)
+ericApp().registerObject("PluginManager", self.pluginManager)
-e5App().registerObject("ToolbarManager", self.toolbarManager)
+ericApp().registerObject("ToolbarManager", self.toolbarManager)
 if self.cooperation is not None:
-e5App().registerObject("Cooperation", self.cooperation)
+ericApp().registerObject("Cooperation", self.cooperation)
 if self.irc is not None:
-e5App().registerObject("IRC", self.irc)
+ericApp().registerObject("IRC", self.irc)
 if self.symbolsViewer is not None:
-e5App().registerObject("Symbols", self.symbolsViewer)
+ericApp().registerObject("Symbols", self.symbolsViewer)
 if self.numbersViewer is not None:
-e5App().registerObject("Numbers", self.numbersViewer)
+ericApp().registerObject("Numbers", self.numbersViewer)
 if self.codeDocumentationViewer is not None:
-e5App().registerObject("DocuViewer", self.codeDocumentationViewer)
+ericApp().registerObject("DocuViewer", self.codeDocumentationViewer)
 if self.microPythonWidget is not None:
-e5App().registerObject("MicroPython", self.microPythonWidget)
+ericApp().registerObject("MicroPython", self.microPythonWidget)
 # list of web addresses serving the versions file
 self.__httpAlternatives = Preferences.getUI("VersionsUrls7")
 self.__inVersionCheck = False
 self.__versionCheckProgress = None
 # now fire up the single application server
 if Preferences.getUI("SingleApplicationMode"):
 splash.showMessage(
 self.tr("Initializing Single Application Server..."))
-self.SAServer = E5SingleApplicationServer()
+self.SAServer = EricSingleApplicationServer()
 else:
 self.SAServer = None
 # now finalize the plugin manager setup
 splash.showMessage(self.tr("Initializing Plugins..."))
 """
 Private method to create the Toolboxes layout.
 @param debugServer reference to the debug server object
 """
-from E5Gui.E5ToolBox import E5VerticalToolBox, E5HorizontalToolBox
+from E5Gui.EricToolBox import EricVerticalToolBox, EricHorizontalToolBox
 logging.debug("Creating Toolboxes Layout...")
 # Create the left toolbox
 self.lToolboxDock = self.__createDockWindow("lToolboxDock")
-self.lToolbox = E5VerticalToolBox(self.lToolboxDock)
+self.lToolbox = EricVerticalToolBox(self.lToolboxDock)
 self.__setupDockWindow(self.lToolboxDock,
 Qt.DockWidgetArea.LeftDockWidgetArea,
 self.lToolbox,
 self.tr("Left Toolbox"))
 # Create the horizontal toolbox
 self.hToolboxDock = self.__createDockWindow("hToolboxDock")
-self.hToolbox = E5HorizontalToolBox(self.hToolboxDock)
+self.hToolbox = EricHorizontalToolBox(self.hToolboxDock)
 self.__setupDockWindow(self.hToolboxDock,
 Qt.DockWidgetArea.BottomDockWidgetArea,
 self.hToolbox,
 self.tr("Horizontal Toolbox"))
 # Create the right toolbox
 self.rToolboxDock = self.__createDockWindow("rToolboxDock")
-self.rToolbox = E5VerticalToolBox(self.rToolboxDock)
+self.rToolbox = EricVerticalToolBox(self.rToolboxDock)
 self.__setupDockWindow(self.rToolboxDock,
 Qt.DockWidgetArea.RightDockWidgetArea,
 self.rToolbox,
 self.tr("Right Toolbox"))
 """
 Private method to create the Sidebars layout.
 @param debugServer reference to the debug server object
 """
-from E5Gui.E5SideBar import E5SideBar, E5SideBarSide
+from E5Gui.EricSideBar import EricSideBar, EricSideBarSide
 logging.debug("Creating Sidebars Layout...")
 delay = Preferences.getUI("SidebarDelay")
 # Create the left sidebar
-self.leftSidebar = E5SideBar(E5SideBarSide.WEST, delay)
+self.leftSidebar = EricSideBar(EricSideBarSide.WEST, delay)
 # Create the bottom sidebar
-self.bottomSidebar = E5SideBar(E5SideBarSide.SOUTH, delay)
+self.bottomSidebar = EricSideBar(EricSideBarSide.SOUTH, delay)
 # Create the right sidebar
-self.rightSidebar = E5SideBar(E5SideBarSide.EAST, delay)
+self.rightSidebar = EricSideBar(EricSideBarSide.EAST, delay)
 ####################################################
 ## Populate the left side bar
 ####################################################
 Private method to define the user interface actions.
 """
 self.actions = []
 self.wizardsActions = []
-self.exitAct = E5Action(
+self.exitAct = EricAction(
 self.tr('Quit'),
 UI.PixmapCache.getIcon("exit"),
 self.tr('&Quit'),
 QKeySequence(self.tr("Ctrl+Q", "File|Quit")),
 0, self, 'quit')
 ))
 self.exitAct.triggered.connect(self.__quit)
 self.exitAct.setMenuRole(QAction.MenuRole.QuitRole)
 self.actions.append(self.exitAct)
-self.restartAct = E5Action(
+self.restartAct = EricAction(
 self.tr('Restart'),
 UI.PixmapCache.getIcon("restart"),
 self.tr('Restart'),
 QKeySequence(self.tr("Ctrl+Shift+Q", "File|Quit")),
 0, self, 'restart_eric')
 """ and the preferences will be written to disc.</p>"""
 ))
 self.restartAct.triggered.connect(self.__restart)
 self.actions.append(self.restartAct)
-self.saveSessionAct = E5Action(
+self.saveSessionAct = EricAction(
 self.tr('Save session'),
 self.tr('Save session...'),
 0, 0, self, 'save_session_to_file')
 self.saveSessionAct.setStatusTip(self.tr('Save session'))
 self.saveSessionAct.setWhatsThis(self.tr(
 """ opened to select the file name.</p>"""
 ))
 self.saveSessionAct.triggered.connect(self.__saveSessionToFile)
 self.actions.append(self.saveSessionAct)
-self.loadSessionAct = E5Action(
+self.loadSessionAct = EricAction(
 self.tr('Load session'),
 self.tr('Load session...'),
 0, 0, self, 'load_session_from_file')
 self.loadSessionAct.setStatusTip(self.tr('Load session'))
 self.loadSessionAct.setWhatsThis(self.tr(
 """ opened to select the file name.</p>"""
 ))
 self.loadSessionAct.triggered.connect(self.__loadSessionFromFile)
 self.actions.append(self.loadSessionAct)
-self.newWindowAct = E5Action(
+self.newWindowAct = EricAction(
 self.tr('New Window'),
 UI.PixmapCache.getIcon("newWindow"),
 self.tr('New &Window'),
 QKeySequence(self.tr("Ctrl+Shift+N", "File|New Window")),
 0, self, 'new_window')
 self.newWindowAct.setEnabled(
 not Preferences.getUI("SingleApplicationMode"))
 self.viewProfileActGrp = createActionGroup(self, "viewprofiles", True)
-self.setEditProfileAct = E5Action(
+self.setEditProfileAct = EricAction(
 self.tr('Edit Profile'),
 UI.PixmapCache.getIcon("viewProfileEdit"),
 self.tr('Edit Profile'),
 0, 0,
 self.viewProfileActGrp, 'edit_profile', True)
 """ "View Profile Configuration" dialog.</p>"""
 ))
 self.setEditProfileAct.triggered.connect(self.__setEditProfile)
 self.actions.append(self.setEditProfileAct)
-self.setDebugProfileAct = E5Action(
+self.setDebugProfileAct = EricAction(
 self.tr('Debug Profile'),
 UI.PixmapCache.getIcon("viewProfileDebug"),
 self.tr('Debug Profile'),
 0, 0,
 self.viewProfileActGrp, 'debug_profile', True)
 """ "View Profile Configuration" dialog.</p>"""
 ))
 self.setDebugProfileAct.triggered.connect(self.setDebugProfile)
 self.actions.append(self.setDebugProfileAct)
-self.pbActivateAct = E5Action(
+self.pbActivateAct = EricAction(
 self.tr('Project-Viewer'),
 self.tr('&Project-Viewer'),
 QKeySequence(self.tr("Alt+Shift+P")),
 0, self,
 'project_viewer_activate')
 ))
 self.pbActivateAct.triggered.connect(self.__activateProjectBrowser)
 self.actions.append(self.pbActivateAct)
 self.addAction(self.pbActivateAct)
-self.mpbActivateAct = E5Action(
+self.mpbActivateAct = EricAction(
 self.tr('Multiproject-Viewer'),
 self.tr('&Multiproject-Viewer'),
 QKeySequence(self.tr("Alt+Shift+M")),
 0, self,
 'multi_project_viewer_activate')
 self.mpbActivateAct.triggered.connect(
 self.__activateMultiProjectBrowser)
 self.actions.append(self.mpbActivateAct)
 self.addAction(self.mpbActivateAct)
-self.debugViewerActivateAct = E5Action(
+self.debugViewerActivateAct = EricAction(
 self.tr('Debug-Viewer'),
 self.tr('&Debug-Viewer'),
 QKeySequence(self.tr("Alt+Shift+D")),
 0, self,
 'debug_viewer_activate')
 self.debugViewerActivateAct.triggered.connect(
 self.activateDebugViewer)
 self.actions.append(self.debugViewerActivateAct)
 self.addAction(self.debugViewerActivateAct)
-self.shellActivateAct = E5Action(
+self.shellActivateAct = EricAction(
 self.tr('Shell'),
 self.tr('&Shell'),
 QKeySequence(self.tr("Alt+Shift+S")),
 0, self,
 'interpreter_shell_activate')
 self.shellActivateAct.triggered.connect(self.__activateShell)
 self.actions.append(self.shellActivateAct)
 self.addAction(self.shellActivateAct)
 if self.browser is not None:
-self.browserActivateAct = E5Action(
+self.browserActivateAct = EricAction(
 self.tr('File-Browser'),
 self.tr('&File-Browser'),
 QKeySequence(self.tr("Alt+Shift+F")),
 0, self,
 'file_browser_activate')
 ))
 self.browserActivateAct.triggered.connect(self.__activateBrowser)
 self.actions.append(self.browserActivateAct)
 self.addAction(self.browserActivateAct)
-self.logViewerActivateAct = E5Action(
+self.logViewerActivateAct = EricAction(
 self.tr('Log-Viewer'),
 self.tr('Lo&g-Viewer'),
 QKeySequence(self.tr("Alt+Shift+G")),
 0, self,
 'log_viewer_activate')
 self.logViewerActivateAct.triggered.connect(
 self.__activateLogViewer)
 self.actions.append(self.logViewerActivateAct)
 self.addAction(self.logViewerActivateAct)
-self.taskViewerActivateAct = E5Action(
+self.taskViewerActivateAct = EricAction(
 self.tr('Task-Viewer'),
 self.tr('&Task-Viewer'),
 QKeySequence(self.tr("Alt+Shift+T")),
 0, self,
 'task_viewer_activate')
 self.__activateTaskViewer)
 self.actions.append(self.taskViewerActivateAct)
 self.addAction(self.taskViewerActivateAct)
 if self.templateViewer is not None:
-self.templateViewerActivateAct = E5Action(
+self.templateViewerActivateAct = EricAction(
 self.tr('Template-Viewer'),
 self.tr('Templ&ate-Viewer'),
 QKeySequence(self.tr("Alt+Shift+A")),
 0, self,
 'template_viewer_activate')
 self.templateViewerActivateAct.triggered.connect(
 self.__activateTemplateViewer)
 self.actions.append(self.templateViewerActivateAct)
 self.addAction(self.templateViewerActivateAct)
-self.ltAct = E5Action(
+self.ltAct = EricAction(
 self.tr('Left Toolbox'),
 self.tr('&Left Toolbox'), 0, 0, self, 'vertical_toolbox', True)
 self.ltAct.setStatusTip(self.tr('Toggle the Left Toolbox window'))
 self.ltAct.setWhatsThis(self.tr(
 """<b>Toggle the Left Toolbox window</b>"""
 """ If it is displayed then close it.</p>"""
 ))
 self.ltAct.triggered.connect(self.__toggleLeftToolbox)
 self.actions.append(self.ltAct)
-self.rtAct = E5Action(
+self.rtAct = EricAction(
 self.tr('Right Toolbox'),
 self.tr('&Right Toolbox'),
 0, 0, self, 'vertical_toolbox', True)
 self.rtAct.setStatusTip(self.tr('Toggle the Right Toolbox window'))
 self.rtAct.setWhatsThis(self.tr(
 """ If it is displayed then close it.</p>"""
 ))
 self.rtAct.triggered.connect(self.__toggleRightToolbox)
 self.actions.append(self.rtAct)
-self.htAct = E5Action(
+self.htAct = EricAction(
 self.tr('Horizontal Toolbox'),
 self.tr('&Horizontal Toolbox'), 0, 0, self,
 'horizontal_toolbox', True)
 self.htAct.setStatusTip(self.tr(
 'Toggle the Horizontal Toolbox window'))
 """ it. If it is displayed then close it.</p>"""
 ))
 self.htAct.triggered.connect(self.__toggleHorizontalToolbox)
 self.actions.append(self.htAct)
-self.lsbAct = E5Action(
+self.lsbAct = EricAction(
 self.tr('Left Sidebar'),
 self.tr('&Left Sidebar'),
 0, 0, self, 'left_sidebar', True)
 self.lsbAct.setStatusTip(self.tr('Toggle the left sidebar window'))
 self.lsbAct.setWhatsThis(self.tr(
 """ If it is displayed then close it.</p>"""
 ))
 self.lsbAct.triggered.connect(self.__toggleLeftSidebar)
 self.actions.append(self.lsbAct)
-self.rsbAct = E5Action(
+self.rsbAct = EricAction(
 self.tr('Right Sidebar'),
 self.tr('&Right Sidebar'),
 0, 0, self, 'right_sidebar', True)
 self.rsbAct.setStatusTip(self.tr(
 'Toggle the right sidebar window'))
 """ If it is displayed then close it.</p>"""
 ))
 self.rsbAct.triggered.connect(self.__toggleRightSidebar)
 self.actions.append(self.rsbAct)
-self.bsbAct = E5Action(
+self.bsbAct = EricAction(
 self.tr('Bottom Sidebar'),
 self.tr('&Bottom Sidebar'), 0, 0, self,
 'bottom_sidebar', True)
 self.bsbAct.setStatusTip(self.tr(
 'Toggle the bottom sidebar window'))
 ))
 self.bsbAct.triggered.connect(self.__toggleBottomSidebar)
 self.actions.append(self.bsbAct)
 if self.cooperation is not None:
-self.cooperationViewerActivateAct = E5Action(
+self.cooperationViewerActivateAct = EricAction(
 self.tr('Cooperation-Viewer'),
 self.tr('Co&operation-Viewer'),
 QKeySequence(self.tr("Alt+Shift+O")),
 0, self,
 'cooperation_viewer_activate')
 self.activateCooperationViewer)
 self.actions.append(self.cooperationViewerActivateAct)
 self.addAction(self.cooperationViewerActivateAct)
 if self.irc is not None:
-self.ircActivateAct = E5Action(
+self.ircActivateAct = EricAction(
 self.tr('IRC'),
 self.tr('&IRC'),
 QKeySequence(self.tr("Ctrl+Alt+Shift+I")),
 0, self,
 'irc_widget_activate')
 self.__activateIRC)
 self.actions.append(self.ircActivateAct)
 self.addAction(self.ircActivateAct)
 if self.symbolsViewer is not None:
-self.symbolsViewerActivateAct = E5Action(
+self.symbolsViewerActivateAct = EricAction(
 self.tr('Symbols-Viewer'),
 self.tr('S&ymbols-Viewer'),
 QKeySequence(self.tr("Alt+Shift+Y")),
 0, self,
 'symbols_viewer_activate')
 self.__activateSymbolsViewer)
 self.actions.append(self.symbolsViewerActivateAct)
 self.addAction(self.symbolsViewerActivateAct)
 if self.numbersViewer is not None:
-self.numbersViewerActivateAct = E5Action(
+self.numbersViewerActivateAct = EricAction(
 self.tr('Numbers-Viewer'),
 self.tr('Num&bers-Viewer'),
 QKeySequence(self.tr("Alt+Shift+B")),
 0, self,
 'numbers_viewer_activate')
 self.__activateNumbersViewer)
 self.actions.append(self.numbersViewerActivateAct)
 self.addAction(self.numbersViewerActivateAct)
 if self.codeDocumentationViewer is not None:
-self.codeDocumentationViewerActivateAct = E5Action(
+self.codeDocumentationViewerActivateAct = EricAction(
 self.tr('Code Documentation Viewer'),
 self.tr('Code Documentation Viewer'),
 QKeySequence(self.tr("Ctrl+Alt+Shift+D")),
 0, self,
 'code_documentation_viewer_activate')
 self.activateCodeDocumentationViewer)
 self.actions.append(self.codeDocumentationViewerActivateAct)
 self.addAction(self.codeDocumentationViewerActivateAct)
 if self.pipWidget is not None:
-self.pipWidgetActivateAct = E5Action(
+self.pipWidgetActivateAct = EricAction(
 self.tr('PyPI'),
 self.tr('PyPI'),
 QKeySequence(self.tr("Ctrl+Alt+Shift+P")),
 0, self,
 'pip_widget_activate')
 self.__activatePipWidget)
 self.actions.append(self.pipWidgetActivateAct)
 self.addAction(self.pipWidgetActivateAct)
 if self.condaWidget is not None:
-self.condaWidgetActivateAct = E5Action(
+self.condaWidgetActivateAct = EricAction(
 self.tr('Conda'),
 self.tr('Conda'),
 QKeySequence(self.tr("Ctrl+Alt+Shift+C")),
 0, self,
 'conda_widget_activate')
 self.__activateCondaWidget)
 self.actions.append(self.condaWidgetActivateAct)
 self.addAction(self.condaWidgetActivateAct)
 if self.microPythonWidget is not None:
-self.microPythonWidgetActivateAct = E5Action(
+self.microPythonWidgetActivateAct = EricAction(
 self.tr('MicroPython'),
 self.tr('MicroPython'),
 QKeySequence(self.tr("Ctrl+Alt+Shift+M")),
 0, self,
 'micropython_widget_activate')
 self.microPythonWidgetActivateAct.triggered.connect(
 self.__activateMicroPython)
 self.actions.append(self.microPythonWidgetActivateAct)
 self.addAction(self.microPythonWidgetActivateAct)
-self.whatsThisAct = E5Action(
+self.whatsThisAct = EricAction(
 self.tr('What\'s This?'),
 UI.PixmapCache.getIcon("whatsThis"),
 self.tr('&What\'s This?'),
 QKeySequence(self.tr("Shift+F1")),
 0, self, 'whatsThis')
 """ context help button in the titlebar.</p>"""
 ))
 self.whatsThisAct.triggered.connect(self.__whatsThis)
 self.actions.append(self.whatsThisAct)
-self.helpviewerAct = E5Action(
+self.helpviewerAct = EricAction(
 self.tr('Helpviewer'),
 UI.PixmapCache.getIcon("help"),
 self.tr('&Helpviewer...'),
 QKeySequence(self.tr("F1")),
 0, self, 'helpviewer')
 self.__initQtDocActions()
 self.__initPythonDocActions()
 self.__initEricDocAction()
 self.__initPySideDocActions()
-self.versionAct = E5Action(
+self.versionAct = EricAction(
 self.tr('Show Versions'),
 self.tr('Show &Versions'),
 0, 0, self, 'show_versions')
 self.versionAct.setStatusTip(self.tr(
 'Display version information'))
 """<p>Display version information.</p>"""
 ))
 self.versionAct.triggered.connect(self.__showVersions)
 self.actions.append(self.versionAct)
-self.checkUpdateAct = E5Action(
+self.checkUpdateAct = EricAction(
 self.tr('Check for Updates'),
 self.tr('Check for &Updates...'), 0, 0, self, 'check_updates')
 self.checkUpdateAct.setStatusTip(self.tr('Check for Updates'))
 self.checkUpdateAct.setWhatsThis(self.tr(
 """<b>Check for Updates...</b>"""
 """<p>Checks the internet for updates of eric.</p>"""
 ))
 self.checkUpdateAct.triggered.connect(self.performVersionCheck)
 self.actions.append(self.checkUpdateAct)
-self.showVersionsAct = E5Action(
+self.showVersionsAct = EricAction(
 self.tr('Show downloadable versions'),
 self.tr('Show &downloadable versions...'),
 0, 0, self, 'show_downloadable_versions')
 self.showVersionsAct.setStatusTip(
 self.tr('Show the versions available for download'))
 ))
 self.showVersionsAct.triggered.connect(
 self.showAvailableVersionsInfo)
 self.actions.append(self.showVersionsAct)
-self.showErrorLogAct = E5Action(
+self.showErrorLogAct = EricAction(
 self.tr('Show Error Log'),
 self.tr('Show Error &Log...'),
 0, 0, self, 'show_error_log')
 self.showErrorLogAct.setStatusTip(self.tr('Show Error Log'))
 self.showErrorLogAct.setWhatsThis(self.tr(
 """<p>Opens a dialog showing the most recent error log.</p>"""
 ))
 self.showErrorLogAct.triggered.connect(self.__showErrorLog)
 self.actions.append(self.showErrorLogAct)
-self.showInstallInfoAct = E5Action(
+self.showInstallInfoAct = EricAction(
 self.tr('Show Install Info'),
 self.tr('Show Install &Info...'),
 0, 0, self, 'show_install_info')
 self.showInstallInfoAct.setStatusTip(self.tr(
 'Show Installation Information'))
 """ installation process.</p>"""
 ))
 self.showInstallInfoAct.triggered.connect(self.__showInstallInfo)
 self.actions.append(self.showInstallInfoAct)
-self.reportBugAct = E5Action(
+self.reportBugAct = EricAction(
 self.tr('Report Bug'),
 self.tr('Report &Bug...'),
 0, 0, self, 'report_bug')
 self.reportBugAct.setStatusTip(self.tr('Report a bug'))
 self.reportBugAct.setWhatsThis(self.tr(
 """<p>Opens a dialog to report a bug.</p>"""
 ))
 self.reportBugAct.triggered.connect(self.__reportBug)
 self.actions.append(self.reportBugAct)
-self.requestFeatureAct = E5Action(
+self.requestFeatureAct = EricAction(
 self.tr('Request Feature'),
 self.tr('Request &Feature...'),
 0, 0, self, 'request_feature')
 self.requestFeatureAct.setStatusTip(self.tr(
 'Send a feature request'))
 self.requestFeatureAct.triggered.connect(self.__requestFeature)
 self.actions.append(self.requestFeatureAct)
 self.utActGrp = createActionGroup(self)
-self.utDialogAct = E5Action(
+self.utDialogAct = EricAction(
 self.tr('Unittest'),
 UI.PixmapCache.getIcon("unittest"),
 self.tr('&Unittest...'),
 0, 0, self.utActGrp, 'unittest')
 self.utDialogAct.setStatusTip(self.tr('Start unittest dialog'))
 """ ability to select and run a unittest suite.</p>"""
 ))
 self.utDialogAct.triggered.connect(self.__unittest)
 self.actions.append(self.utDialogAct)
-self.utRestartAct = E5Action(
+self.utRestartAct = EricAction(
 self.tr('Unittest Restart'),
 UI.PixmapCache.getIcon("unittestRestart"),
 self.tr('&Restart Unittest...'),
 0, 0, self.utActGrp, 'unittest_restart')
 self.utRestartAct.setStatusTip(self.tr('Restart last unittest'))
 ))
 self.utRestartAct.triggered.connect(self.__unittestRestart)
 self.utRestartAct.setEnabled(False)
 self.actions.append(self.utRestartAct)
-self.utRerunFailedAct = E5Action(
+self.utRerunFailedAct = EricAction(
 self.tr('Unittest Rerun Failed'),
 UI.PixmapCache.getIcon("unittestRerunFailed"),
 self.tr('Rerun Failed Tests...'),
 0, 0, self.utActGrp, 'unittest_rerun_failed')
 self.utRerunFailedAct.setStatusTip(self.tr(
 ))
 self.utRerunFailedAct.triggered.connect(self.__unittestRerunFailed)
 self.utRerunFailedAct.setEnabled(False)
 self.actions.append(self.utRerunFailedAct)
-self.utScriptAct = E5Action(
+self.utScriptAct = EricAction(
 self.tr('Unittest Script'),
 UI.PixmapCache.getIcon("unittestScript"),
 self.tr('Unittest &Script...'),
 0, 0, self.utActGrp, 'unittest_script')
 self.utScriptAct.setStatusTip(self.tr(
 ))
 self.utScriptAct.triggered.connect(self.__unittestScript)
 self.utScriptAct.setEnabled(False)
 self.actions.append(self.utScriptAct)
-self.utProjectAct = E5Action(
+self.utProjectAct = EricAction(
 self.tr('Unittest Project'),
 UI.PixmapCache.getIcon("unittestProject"),
 self.tr('Unittest &Project...'),
 0, 0, self.utActGrp, 'unittest_project')
 self.utProjectAct.setStatusTip(self.tr(
 else:
 designerExe = os.path.join(
 Utilities.getQtBinariesPath(),
 Utilities.generateQtToolName("designer"))
 if os.path.exists(designerExe):
-self.designer4Act = E5Action(
+self.designer4Act = EricAction(
 self.tr('Qt-Designer'),
 UI.PixmapCache.getIcon("designer4"),
 self.tr('Qt-&Designer...'),
 0, 0, self, 'qt_designer4')
 self.designer4Act.setStatusTip(self.tr('Start Qt-Designer'))
 else:
 linguistExe = os.path.join(
 Utilities.getQtBinariesPath(),
 Utilities.generateQtToolName("linguist"))
 if os.path.exists(linguistExe):
-self.linguist4Act = E5Action(
+self.linguist4Act = EricAction(
 self.tr('Qt-Linguist'),
 UI.PixmapCache.getIcon("linguist4"),
 self.tr('Qt-&Linguist...'),
 0, 0, self, 'qt_linguist4')
 self.linguist4Act.setStatusTip(self.tr('Start Qt-Linguist'))
 self.linguist4Act.triggered.connect(self.__linguist)
 self.actions.append(self.linguist4Act)
 else:
 self.linguist4Act = None
-self.uipreviewerAct = E5Action(
+self.uipreviewerAct = EricAction(
 self.tr('UI Previewer'),
 UI.PixmapCache.getIcon("uiPreviewer"),
 self.tr('&UI Previewer...'),
 0, 0, self, 'ui_previewer')
 self.uipreviewerAct.setStatusTip(self.tr('Start the UI Previewer'))
 """<p>Start the UI Previewer.</p>"""
 ))
 self.uipreviewerAct.triggered.connect(self.__UIPreviewer)
 self.actions.append(self.uipreviewerAct)
-self.trpreviewerAct = E5Action(
+self.trpreviewerAct = EricAction(
 self.tr('Translations Previewer'),
 UI.PixmapCache.getIcon("trPreviewer"),
 self.tr('&Translations Previewer...'),
 0, 0, self, 'tr_previewer')
 self.trpreviewerAct.setStatusTip(self.tr(
 """<p>Start the Translations Previewer.</p>"""
 ))
 self.trpreviewerAct.triggered.connect(self.__TRPreviewer)
 self.actions.append(self.trpreviewerAct)
-self.diffAct = E5Action(
+self.diffAct = EricAction(
 self.tr('Compare Files'),
 UI.PixmapCache.getIcon("diffFiles"),
 self.tr('&Compare Files...'),
 0, 0, self, 'diff_files')
 self.diffAct.setStatusTip(self.tr('Compare two files'))
 """<p>Open a dialog to compare two files.</p>"""
 ))
 self.diffAct.triggered.connect(self.__compareFiles)
 self.actions.append(self.diffAct)
-self.compareAct = E5Action(
+self.compareAct = EricAction(
 self.tr('Compare Files side by side'),
 UI.PixmapCache.getIcon("compareFiles"),
 self.tr('Compare &Files side by side...'),
 0, 0, self, 'compare_files')
 self.compareAct.setStatusTip(self.tr('Compare two files'))
 """ side by side.</p>"""
 ))
 self.compareAct.triggered.connect(self.__compareFilesSbs)
 self.actions.append(self.compareAct)
-self.sqlBrowserAct = E5Action(
+self.sqlBrowserAct = EricAction(
 self.tr('SQL Browser'),
 UI.PixmapCache.getIcon("sqlBrowser"),
 self.tr('SQL &Browser...'),
 0, 0, self, 'sql_browser')
 self.sqlBrowserAct.setStatusTip(self.tr('Browse a SQL database'))
 """<p>Browse a SQL database.</p>"""
 ))
 self.sqlBrowserAct.triggered.connect(self.__sqlBrowser)
 self.actions.append(self.sqlBrowserAct)
-self.miniEditorAct = E5Action(
+self.miniEditorAct = EricAction(
 self.tr('Mini Editor'),
 UI.PixmapCache.getIcon("editor"),
 self.tr('Mini &Editor...'),
 0, 0, self, 'mini_editor')
 self.miniEditorAct.setStatusTip(self.tr('Mini Editor'))
 """<p>Open a dialog with a simplified editor.</p>"""
 ))
 self.miniEditorAct.triggered.connect(self.__openMiniEditor)
 self.actions.append(self.miniEditorAct)
-self.hexEditorAct = E5Action(
+self.hexEditorAct = EricAction(
 self.tr('Hex Editor'),
 UI.PixmapCache.getIcon("hexEditor"),
 self.tr('&Hex Editor...'),
 0, 0, self, 'hex_editor')
 self.hexEditorAct.setStatusTip(self.tr(
 """ binary files.</p>"""
 ))
 self.hexEditorAct.triggered.connect(self.__openHexEditor)
 self.actions.append(self.hexEditorAct)
-self.webBrowserAct = E5Action(
+self.webBrowserAct = EricAction(
 self.tr('eric Web Browser'),
 UI.PixmapCache.getIcon("ericWeb"),
 self.tr('eric &Web Browser...'),
 0, 0, self, 'web_browser')
 self.webBrowserAct.setStatusTip(self.tr(
 """<p>Browse the Internet with the eric Web Browser.</p>"""
 ))
 self.webBrowserAct.triggered.connect(self.__startWebBrowser)
 self.actions.append(self.webBrowserAct)
-self.iconEditorAct = E5Action(
+self.iconEditorAct = EricAction(
 self.tr('Icon Editor'),
 UI.PixmapCache.getIcon("iconEditor"),
 self.tr('&Icon Editor...'),
 0, 0, self, 'icon_editor')
 self.iconEditorAct.setStatusTip(self.tr(
 """<p>Starts the eric Icon Editor for editing simple icons.</p>"""
 ))
 self.iconEditorAct.triggered.connect(self.__editPixmap)
 self.actions.append(self.iconEditorAct)
-self.snapshotAct = E5Action(
+self.snapshotAct = EricAction(
 self.tr('Snapshot'),
 UI.PixmapCache.getIcon("ericSnap"),
 self.tr('&Snapshot...'),
 0, 0, self, 'snapshot')
 self.snapshotAct.setStatusTip(self.tr(
 """ region.</p>"""
 ))
 self.snapshotAct.triggered.connect(self.__snapshot)
 self.actions.append(self.snapshotAct)
-self.prefAct = E5Action(
+self.prefAct = EricAction(
 self.tr('Preferences'),
 UI.PixmapCache.getIcon("configure"),
 self.tr('&Preferences...'),
 0, 0, self, 'preferences')
 self.prefAct.setStatusTip(self.tr(
 ))
 self.prefAct.triggered.connect(self.showPreferences)
 self.prefAct.setMenuRole(QAction.MenuRole.PreferencesRole)
 self.actions.append(self.prefAct)
-self.prefExportAct = E5Action(
+self.prefExportAct = EricAction(
 self.tr('Export Preferences'),
 UI.PixmapCache.getIcon("configureExport"),
 self.tr('E&xport Preferences...'),
 0, 0, self, 'export_preferences')
 self.prefExportAct.setStatusTip(self.tr(
 """<p>Export the current configuration to a file.</p>"""
 ))
 self.prefExportAct.triggered.connect(self.__exportPreferences)
 self.actions.append(self.prefExportAct)
-self.prefImportAct = E5Action(
+self.prefImportAct = EricAction(
 self.tr('Import Preferences'),
 UI.PixmapCache.getIcon("configureImport"),
 self.tr('I&mport Preferences...'),
 0, 0, self, 'import_preferences')
 self.prefImportAct.setStatusTip(self.tr(
 """<p>Import a previously exported configuration.</p>"""
 ))
 self.prefImportAct.triggered.connect(self.__importPreferences)
 self.actions.append(self.prefImportAct)
-self.reloadAPIsAct = E5Action(
+self.reloadAPIsAct = EricAction(
 self.tr('Reload APIs'),
 self.tr('Reload &APIs'),
 0, 0, self, 'reload_apis')
 self.reloadAPIsAct.setStatusTip(self.tr(
 'Reload the API information'))
 """<p>Reload the API information.</p>"""
 ))
 self.reloadAPIsAct.triggered.connect(self.__reloadAPIs)
 self.actions.append(self.reloadAPIsAct)
-self.showExternalToolsAct = E5Action(
+self.showExternalToolsAct = EricAction(
 self.tr('Show external tools'),
 UI.PixmapCache.getIcon("showPrograms"),
 self.tr('Show external &tools'),
 0, 0, self, 'show_external_tools')
 self.showExternalToolsAct.setStatusTip(self.tr(
 ))
 self.showExternalToolsAct.triggered.connect(
 self.__showExternalTools)
 self.actions.append(self.showExternalToolsAct)
-self.configViewProfilesAct = E5Action(
+self.configViewProfilesAct = EricAction(
 self.tr('View Profiles'),
 UI.PixmapCache.getIcon("configureViewProfiles"),
 self.tr('&View Profiles...'),
 0, 0, self, 'view_profiles')
 self.configViewProfilesAct.setStatusTip(self.tr(
 ))
 self.configViewProfilesAct.triggered.connect(
 self.__configViewProfiles)
 self.actions.append(self.configViewProfilesAct)
-self.configToolBarsAct = E5Action(
+self.configToolBarsAct = EricAction(
 self.tr('Toolbars'),
 UI.PixmapCache.getIcon("toolbarsConfigure"),
 self.tr('Tool&bars...'),
 0, 0, self, 'configure_toolbars')
 self.configToolBarsAct.setStatusTip(self.tr('Configure toolbars'))
 """ define your own toolbars.</p>"""
 ))
 self.configToolBarsAct.triggered.connect(self.__configToolBars)
 self.actions.append(self.configToolBarsAct)
-self.shortcutsAct = E5Action(
+self.shortcutsAct = EricAction(
 self.tr('Keyboard Shortcuts'),
 UI.PixmapCache.getIcon("configureShortcuts"),
 self.tr('Keyboard &Shortcuts...'),
 0, 0, self, 'keyboard_shortcuts')
 self.shortcutsAct.setStatusTip(self.tr(
 """ with your prefered values.</p>"""
 ))
 self.shortcutsAct.triggered.connect(self.__configShortcuts)
 self.actions.append(self.shortcutsAct)
-self.exportShortcutsAct = E5Action(
+self.exportShortcutsAct = EricAction(
 self.tr('Export Keyboard Shortcuts'),
 UI.PixmapCache.getIcon("exportShortcuts"),
 self.tr('&Export Keyboard Shortcuts...'),
 0, 0, self, 'export_keyboard_shortcuts')
 self.exportShortcutsAct.setStatusTip(self.tr(
 """<p>Export the keyboard shortcuts of the application.</p>"""
 ))
 self.exportShortcutsAct.triggered.connect(self.__exportShortcuts)
 self.actions.append(self.exportShortcutsAct)
-self.importShortcutsAct = E5Action(
+self.importShortcutsAct = EricAction(
 self.tr('Import Keyboard Shortcuts'),
 UI.PixmapCache.getIcon("importShortcuts"),
 self.tr('&Import Keyboard Shortcuts...'),
 0, 0, self, 'import_keyboard_shortcuts')
 self.importShortcutsAct.setStatusTip(self.tr(
 ))
 self.importShortcutsAct.triggered.connect(self.__importShortcuts)
 self.actions.append(self.importShortcutsAct)
 if SSL_AVAILABLE:
-self.certificatesAct = E5Action(
+self.certificatesAct = EricAction(
 self.tr('Manage SSL Certificates'),
 UI.PixmapCache.getIcon("certificates"),
 self.tr('Manage SSL Certificates...'),
 0, 0, self, 'manage_ssl_certificates')
 self.certificatesAct.setStatusTip(self.tr(
 ))
 self.certificatesAct.triggered.connect(
 self.__showCertificatesDialog)
 self.actions.append(self.certificatesAct)
-self.editMessageFilterAct = E5Action(
+self.editMessageFilterAct = EricAction(
 self.tr('Edit Message Filters'),
 UI.PixmapCache.getIcon("warning"),
 self.tr('Edit Message Filters...'),
 0, 0, self, 'manage_message_filters')
 self.editMessageFilterAct.setStatusTip(self.tr(
 """<p>Opens a dialog to edit the message filters used to"""
 """ suppress unwanted messages been shown in an error"""
 """ window.</p>"""
 ))
 self.editMessageFilterAct.triggered.connect(
-E5ErrorMessage.editMessageFilters)
+EricErrorMessage.editMessageFilters)
 self.actions.append(self.editMessageFilterAct)
-self.clearPrivateDataAct = E5Action(
+self.clearPrivateDataAct = EricAction(
 self.tr('Clear private data'),
 UI.PixmapCache.getIcon("clearPrivateData"),
 self.tr('Clear private data'),
 0, 0,
 self, 'clear_private_data')
 ))
 self.clearPrivateDataAct.triggered.connect(
 self.__clearPrivateData)
 self.actions.append(self.clearPrivateDataAct)
-self.viewmanagerActivateAct = E5Action(
+self.viewmanagerActivateAct = EricAction(
 self.tr('Activate current editor'),
 self.tr('Activate current editor'),
 QKeySequence(self.tr("Alt+Shift+E")),
 0, self, 'viewmanager_activate')
 self.viewmanagerActivateAct.triggered.connect(
 self.__activateViewmanager)
 self.actions.append(self.viewmanagerActivateAct)
 self.addAction(self.viewmanagerActivateAct)
-self.nextTabAct = E5Action(
+self.nextTabAct = EricAction(
 self.tr('Show next'),
 self.tr('Show next'),
 QKeySequence(self.tr('Ctrl+Alt+Tab')), 0,
 self, 'view_next_tab')
 self.nextTabAct.triggered.connect(self.__showNext)
 self.actions.append(self.nextTabAct)
 self.addAction(self.nextTabAct)
-self.prevTabAct = E5Action(
+self.prevTabAct = EricAction(
 self.tr('Show previous'),
 self.tr('Show previous'),
 QKeySequence(self.tr('Shift+Ctrl+Alt+Tab')), 0,
 self, 'view_previous_tab')
 self.prevTabAct.triggered.connect(self.__showPrevious)
 self.actions.append(self.prevTabAct)
 self.addAction(self.prevTabAct)
-self.switchTabAct = E5Action(
+self.switchTabAct = EricAction(
 self.tr('Switch between tabs'),
 self.tr('Switch between tabs'),
 QKeySequence(self.tr('Ctrl+1')), 0,
 self, 'switch_tabs')
 self.switchTabAct.triggered.connect(self.__switchTab)
 self.actions.append(self.switchTabAct)
 self.addAction(self.switchTabAct)
-self.pluginInfoAct = E5Action(
+self.pluginInfoAct = EricAction(
 self.tr('Plugin Infos'),
 UI.PixmapCache.getIcon("plugin"),
 self.tr('&Plugin Infos...'), 0, 0, self, 'plugin_infos')
 self.pluginInfoAct.setStatusTip(self.tr('Show Plugin Infos'))
 self.pluginInfoAct.setWhatsThis(self.tr(
 """ loaded plugins.</p>"""
 ))
 self.pluginInfoAct.triggered.connect(self.__showPluginInfo)
 self.actions.append(self.pluginInfoAct)
-self.pluginInstallAct = E5Action(
+self.pluginInstallAct = EricAction(
 self.tr('Install Plugins'),
 UI.PixmapCache.getIcon("pluginInstall"),
 self.tr('&Install Plugins...'),
 0, 0, self, 'plugin_install')
 self.pluginInstallAct.setStatusTip(self.tr('Install Plugins'))
 """<p>This opens a dialog to install or update plugins.</p>"""
 ))
 self.pluginInstallAct.triggered.connect(self.__installPlugins)
 self.actions.append(self.pluginInstallAct)
-self.pluginDeinstallAct = E5Action(
+self.pluginDeinstallAct = EricAction(
 self.tr('Uninstall Plugin'),
 UI.PixmapCache.getIcon("pluginUninstall"),
 self.tr('&Uninstall Plugin...'),
 0, 0, self, 'plugin_deinstall')
 self.pluginDeinstallAct.setStatusTip(self.tr('Uninstall Plugin'))
 """<p>This opens a dialog to uninstall a plugin.</p>"""
 ))
 self.pluginDeinstallAct.triggered.connect(self.__deinstallPlugin)
 self.actions.append(self.pluginDeinstallAct)
-self.pluginRepoAct = E5Action(
+self.pluginRepoAct = EricAction(
 self.tr('Plugin Repository'),
 UI.PixmapCache.getIcon("pluginRepository"),
 self.tr('Plugin &Repository...'),
 0, 0, self, 'plugin_repository')
 self.pluginRepoAct.setStatusTip(self.tr(
 """available on the Internet.</p>"""
 ))
 self.pluginRepoAct.triggered.connect(self.showPluginsAvailable)
 self.actions.append(self.pluginRepoAct)
-self.virtualenvManagerAct = E5Action(
+self.virtualenvManagerAct = EricAction(
 self.tr('Virtualenv Manager'),
 UI.PixmapCache.getIcon("virtualenv"),
 self.tr('&Virtualenv Manager...'),
 0, 0, self,
 'virtualenv_manager')
 ))
 self.virtualenvManagerAct.triggered.connect(
 self.virtualenvManager.showVirtualenvManagerDialog)
 self.actions.append(self.virtualenvManagerAct)
-self.virtualenvConfigAct = E5Action(
+self.virtualenvConfigAct = EricAction(
 self.tr('Virtualenv Configurator'),
 UI.PixmapCache.getIcon("virtualenvConfig"),
 self.tr('Virtualenv &Configurator...'),
 0, 0, self,
 'virtualenv_configurator')
 def __initQtDocActions(self):
 """
 Private slot to initialize the action to show the Qt documentation.
 """
-self.qt5DocAct = E5Action(
+self.qt5DocAct = EricAction(
 self.tr('Qt5 Documentation'),
 self.tr('Qt5 Documentation'),
 0, 0, self, 'qt5_documentation')
 self.qt5DocAct.setStatusTip(self.tr('Open Qt5 Documentation'))
 self.qt5DocAct.setWhatsThis(self.tr(
 """ Assistant. </p>"""
 ))
 self.qt5DocAct.triggered.connect(lambda: self.__showQtDoc(5))
 self.actions.append(self.qt5DocAct)
-self.qt6DocAct = E5Action(
+self.qt6DocAct = EricAction(
 self.tr('Qt6 Documentation'),
 self.tr('Qt6 Documentation'),
 0, 0, self, 'qt6_documentation')
 self.qt6DocAct.setStatusTip(self.tr('Open Qt6 Documentation'))
 self.qt6DocAct.setWhatsThis(self.tr(
 """ Assistant. </p>"""
 ))
 self.qt6DocAct.triggered.connect(lambda: self.__showQtDoc(6))
 self.actions.append(self.qt6DocAct)
-self.pyqt5DocAct = E5Action(
+self.pyqt5DocAct = EricAction(
 self.tr('PyQt5 Documentation'),
 self.tr('PyQt5 Documentation'),
 0, 0, self, 'pyqt5_documentation')
 self.pyqt5DocAct.setStatusTip(self.tr(
 'Open PyQt5 Documentation'))
 ))
 self.pyqt5DocAct.triggered.connect(
 lambda: self.__showPyQtDoc(variant=5))
 self.actions.append(self.pyqt5DocAct)
-self.pyqt6DocAct = E5Action(
+self.pyqt6DocAct = EricAction(
 self.tr('PyQt6 Documentation'),
 self.tr('PyQt6 Documentation'),
 0, 0, self, 'pyqt6_documentation')
 self.pyqt6DocAct.setStatusTip(self.tr(
 'Open PyQt6 Documentation'))
 def __initPythonDocActions(self):
 """
 Private slot to initialize the actions to show the Python
 documentation.
 """
-self.pythonDocAct = E5Action(
+self.pythonDocAct = EricAction(
 self.tr('Python 3 Documentation'),
 self.tr('Python 3 Documentation'),
 0, 0, self, 'python3_documentation')
 self.pythonDocAct.setStatusTip(self.tr(
 'Open Python 3 Documentation'))
 def __initEricDocAction(self):
 """
 Private slot to initialize the action to show the eric documentation.
 """
-self.ericDocAct = E5Action(
+self.ericDocAct = EricAction(
 self.tr("Eric API Documentation"),
 self.tr('Eric API Documentation'),
 0, 0, self, 'eric_documentation')
 self.ericDocAct.setStatusTip(self.tr(
 "Open Eric API Documentation"))
 """
 Private slot to initialize the actions to show the PySide
 documentation.
 """
 if Utilities.checkPyside(variant=2):
-self.pyside2DocAct = E5Action(
+self.pyside2DocAct = EricAction(
 self.tr('PySide2 Documentation'),
 self.tr('PySide2 Documentation'),
 0, 0, self, 'pyside2_documentation')
 self.pyside2DocAct.setStatusTip(self.tr(
 'Open PySide2 Documentation'))
 self.actions.append(self.pyside2DocAct)
 else:
 self.pyside2DocAct = None
 if Utilities.checkPyside(variant=6):
-self.pyside6DocAct = E5Action(
+self.pyside6DocAct = EricAction(
 self.tr('PySide6 Documentation'),
 self.tr('PySide6 Documentation'),
 0, 0, self, 'pyside6_documentation')
 self.pyside6DocAct.setStatusTip(self.tr(
 'Open PySide6 Documentation'))
 Private slot to set up the status bar.
 """
 self.__statusBar = self.statusBar()
 self.__statusBar.setSizeGripEnabled(True)
-self.sbLanguage = E5ClickableLabel(self.__statusBar)
+self.sbLanguage = EricClickableLabel(self.__statusBar)
 self.__statusBar.addPermanentWidget(self.sbLanguage)
 self.sbLanguage.setWhatsThis(self.tr(
 """<p>This part of the status bar displays the"""
 """ current editors language.</p>"""
 ))
-self.sbEncoding = E5ClickableLabel(self.__statusBar)
+self.sbEncoding = EricClickableLabel(self.__statusBar)
 self.__statusBar.addPermanentWidget(self.sbEncoding)
 self.sbEncoding.setWhatsThis(self.tr(
 """<p>This part of the status bar displays the"""
 """ current editors encoding.</p>"""
 ))
-self.sbEol = E5ClickableLabel(self.__statusBar)
+self.sbEol = EricClickableLabel(self.__statusBar)
 self.__statusBar.addPermanentWidget(self.sbEol)
 self.sbEol.setWhatsThis(self.tr(
 """<p>This part of the status bar displays the"""
 """ current editors eol setting.</p>"""
 ))
 self.sbPos.setWhatsThis(self.tr(
 """<p>This part of the status bar displays the cursor position"""
 """ of the current editor.</p>"""
 ))
-self.sbZoom = E5ZoomWidget(
+self.sbZoom = EricZoomWidget(
 UI.PixmapCache.getPixmap("zoomOut"),
 UI.PixmapCache.getPixmap("zoomIn"),
 UI.PixmapCache.getPixmap("zoomReset"),
 self.__statusBar)
 self.__statusBar.addPermanentWidget(self.sbZoom)
 def __showSettingsMenu(self):
 """
 Private slot to show the Settings menu.
 """
 self.editMessageFilterAct.setEnabled(
-E5ErrorMessage.messageHandlerInstalled())
+EricErrorMessage.messageHandlerInstalled())
 self.showMenu.emit("Settings", self.__menus["settings"])
 def __showNext(self):
 """
 ).format(chromeVersion)
 versionText += ("""<tr><td><b>{0}</b></td><td>{1}</td></tr>"""
 ).format(Program, Version)
 versionText += self.tr("""</table>""")
-E5MessageBox.about(self, Program, versionText)
+EricMessageBox.about(self, Program, versionText)
 def __reportBug(self):
 """
 Private slot to handle the Report Bug dialog.
 """
 self.__showSystemEmailClient(mode, attachFile, deleteAttachFile)
 else:
 if not Preferences.getUser("UseGoogleMailOAuth2") and (
 Preferences.getUser("Email") == "" or
 Preferences.getUser("MailServer") == ""):
-E5MessageBox.critical(
+EricMessageBox.critical(
 self,
 self.tr("Report Bug"),
 self.tr(
 """Email address or mail server address is empty."""
 """ Please configure your Email settings in the"""
 """
 from QScintilla.MiniEditor import MiniEditor
 editor = MiniEditor(parent=self)
 editor.show()
-def addE5Actions(self, actions, actionType):
+def addEricActions(self, actions, actionType):
 """
 Public method to add actions to the list of actions.
-@param actions list of actions to be added (list of E5Action)
+@param actions list of actions to be added (list of EricAction)
 @param actionType string denoting the action set to add to.
 It must be one of "ui" or "wizards".
 """
 if actionType == 'ui':
 self.actions.extend(actions)
 elif actionType == 'wizards':
 self.wizardsActions.extend(actions)
-def removeE5Actions(self, actions, actionType='ui'):
+def removeEricActions(self, actions, actionType='ui'):
 """
 Public method to remove actions from the list of actions.
-@param actions list of actions (list of E5Action)
+@param actions list of actions (list of EricAction)
 @param actionType string denoting the action set to remove from.
 It must be one of "ui" or "wizards".
 """
 for act in actions:
 with contextlib.suppress(ValueError):
 """
 Public method to get a list of all actions.
 @param actionType string denoting the action set to get.
 It must be one of "ui" or "wizards".
-@return list of all actions (list of E5Action)
+@return list of all actions (list of EricAction)
 """
 if actionType == 'ui':
 return self.actions[:]
 elif actionType == 'wizards':
 return self.wizardsActions[:]
 def __quit(self):
 """
 Private method to quit the application.
 """
 if self.__shutdown():
-e5App().closeAllWindows()
+ericApp().closeAllWindows()
 @pyqtSlot()
 def __restart(self, ask=False):
 """
 Private method to restart the application.
 @param ask flag indicating to ask the user for permission
 @type bool
 """
 res = (
-E5MessageBox.yesNo(
+EricMessageBox.yesNo(
 self,
 self.tr("Restart application"),
 self.tr(
 """The application needs to be restarted. Do it now?"""),
 yesDefault=True)
 if ask else
 True
 )
 if res and self.__shutdown():
-e5App().closeAllWindows()
+ericApp().closeAllWindows()
 program = sys.executable
 eric7 = os.path.join(getConfig("ericDir"), "eric7.py")
 args = [eric7]
 args.append("--start-session")
 args.extend(self.__restartArgs)
 if fn is not None:
 try:
 if os.path.isfile(fn) and os.path.getsize(fn):
 args.append(fn)
 else:
-E5MessageBox.critical(
+EricMessageBox.critical(
 self,
 self.tr('Problem'),
 self.tr(
 '<p>The file <b>{0}</b> does not exist or'
 ' is zero length.</p>')
 .format(fn))
 return
 except OSError:
-E5MessageBox.critical(
+EricMessageBox.critical(
 self,
 self.tr('Problem'),
 self.tr(
 '<p>The file <b>{0}</b> does not exist or'
 ' is zero length.</p>')
 designer += '.exe'
 if designer:
 proc = QProcess()
 if not proc.startDetached(designer, args):
-E5MessageBox.critical(
+EricMessageBox.critical(
 self,
 self.tr('Process Generation Error'),
 self.tr(
 '<p>Could not start Qt-Designer.<br>'
 'Ensure that it is available as <b>{0}</b>.</p>'
 ).format(designer)
 )
 else:
-E5MessageBox.critical(
+EricMessageBox.critical(
 self,
 self.tr('Process Generation Error'),
 self.tr(
 '<p>Could not find the Qt-Designer executable.<br>'
 'Ensure that it is installed and optionally configured on'
 os.path.getsize(fn) and
 fn not in args
 ):
 args.append(fn)
 else:
-E5MessageBox.critical(
+EricMessageBox.critical(
 self,
 self.tr('Problem'),
 self.tr(
 '<p>The file <b>{0}</b> does not exist or'
 ' is zero length.</p>')
 .format(fn))
 return
 except OSError:
-E5MessageBox.critical(
+EricMessageBox.critical(
 self,
 self.tr('Problem'),
 self.tr(
 '<p>The file <b>{0}</b> does not exist or'
 ' is zero length.</p>')
 linguist += '.exe'
 if linguist:
 proc = QProcess()
 if not proc.startDetached(linguist, args):
-E5MessageBox.critical(
+EricMessageBox.critical(
 self,
 self.tr('Process Generation Error'),
 self.tr(
 '<p>Could not start Qt-Linguist.<br>'
 'Ensure that it is available as <b>{0}</b>.</p>'
 ).format(linguist)
 )
 else:
-E5MessageBox.critical(
+EricMessageBox.critical(
 self,
 self.tr('Process Generation Error'),
 self.tr(
 '<p>Could not find the Qt-Linguist executable.<br>'
 'Ensure that it is installed and optionally configured on'
 assistant += '.exe'
 if assistant:
 proc = QProcess()
 if not proc.startDetached(assistant, args):
-E5MessageBox.critical(
+EricMessageBox.critical(
 self,
 self.tr('Process Generation Error'),
 self.tr(
 '<p>Could not start Qt-Assistant.<br>'
 'Ensure that it is available as <b>{0}</b>.</p>'
 ).format(assistant)
 )
 else:
-E5MessageBox.critical(
+EricMessageBox.critical(
 self,
 self.tr('Process Generation Error'),
 self.tr(
 '<p>Could not find the Qt-Assistant executable.<br>'
 'Ensure that it is installed and optionally configured on'
 @param home full pathname of a file to display (string)
 """
 customViewer = Preferences.getHelp("CustomViewer")
 if not customViewer:
-E5MessageBox.information(
+EricMessageBox.information(
 self,
 self.tr("Help"),
 self.tr(
 """Currently no custom viewer is selected."""
 """ Please use the preferences dialog to specify one."""))
 args = []
 if home:
 args.append(home)
 if not proc.startDetached(customViewer, args):
-E5MessageBox.critical(
+EricMessageBox.critical(
 self,
 self.tr('Process Generation Error'),
 self.tr(
 '<p>Could not start custom viewer.<br>'
 'Ensure that it is available as <b>{0}</b>.</p>'
 proc = QProcess()
 args = []
 args.append(home)
 if not proc.startDetached("hh", args):
-E5MessageBox.critical(
+EricMessageBox.critical(
 self,
 self.tr('Process Generation Error'),
 self.tr(
 '<p>Could not start the help viewer.<br>'
 'Ensure that it is available as <b>hh</b>.</p>'
 if fn is not None:
 try:
 if os.path.isfile(fn) and os.path.getsize(fn):
 args.append(fn)
 else:
-E5MessageBox.critical(
+EricMessageBox.critical(
 self,
 self.tr('Problem'),
 self.tr(
 '<p>The file <b>{0}</b> does not exist or'
 ' is zero length.</p>')
 .format(fn))
 return
 except OSError:
-E5MessageBox.critical(
+EricMessageBox.critical(
 self,
 self.tr('Problem'),
 self.tr(
 '<p>The file <b>{0}</b> does not exist or'
 ' is zero length.</p>')
 if (
 not os.path.isfile(viewer) or
 not proc.startDetached(sys.executable, args)
 ):
-E5MessageBox.critical(
+EricMessageBox.critical(
 self,
 self.tr('Process Generation Error'),
 self.tr(
 '<p>Could not start UI Previewer.<br>'
 'Ensure that it is available as <b>{0}</b>.</p>'
 try:
 if os.path.isfile(fn) and os.path.getsize(fn):
 args.append(fn)
 else:
 if not ignore:
-E5MessageBox.critical(
+EricMessageBox.critical(
 self,
 self.tr('Problem'),
 self.tr(
 '<p>The file <b>{0}</b> does not exist or'
 ' is zero length.</p>')
 .format(fn))
 return
 except OSError:
 if not ignore:
-E5MessageBox.critical(
+EricMessageBox.critical(
 self,
 self.tr('Problem'),
 self.tr(
 '<p>The file <b>{0}</b> does not exist or'
 ' is zero length.</p>')
 if (
 not os.path.isfile(viewer) or
 not proc.startDetached(sys.executable, args)
 ):
-E5MessageBox.critical(
+EricMessageBox.critical(
 self,
 self.tr('Process Generation Error'),
 self.tr(
 '<p>Could not start Translation Previewer.<br>'
 'Ensure that it is available as <b>{0}</b>.</p>'
 if (
 not os.path.isfile(browser) or
 not proc.startDetached(sys.executable, args)
 ):
-E5MessageBox.critical(
+EricMessageBox.critical(
 self,
 self.tr('Process Generation Error'),
 self.tr(
 '<p>Could not start SQL Browser.<br>'
 'Ensure that it is available as <b>{0}</b>.</p>'
 if (
 not os.path.isfile(snap) or
 not proc.startDetached(sys.executable, args)
 ):
-E5MessageBox.critical(
+EricMessageBox.critical(
 self,
 self.tr('Process Generation Error'),
 self.tr(
 '<p>Could not start Snapshot tool.<br>'
 'Ensure that it is available as <b>{0}</b>.</p>'
 for tool in toolGroup[1]:
 if tool['menutext'] == toolMenuText:
 self.__startToolProcess(tool)
 return
-E5MessageBox.information(
+EricMessageBox.information(
 self,
 self.tr("External Tools"),
 self.tr(
 """No tool entry found for external tool '{0}' """
 """in tool group '{1}'.""")
 .format(toolMenuText, toolGroupName))
 return
-E5MessageBox.information(
+EricMessageBox.information(
 self,
 self.tr("External Tools"),
 self.tr("""No toolgroup entry '{0}' found.""")
 .format(toolGroupName)
 )
 if aw is not None:
 aw.beginUndoAction()
 proc.start(program, args)
 if not proc.waitForStarted():
-E5MessageBox.critical(
+EricMessageBox.critical(
 self,
 self.tr('Process Generation Error'),
 self.tr(
 '<p>Could not start the tool entry <b>{0}</b>.<br>'
 'Ensure that it is available as <b>{1}</b>.</p>')
 pythonDocDir = Preferences.getHelp("PythonDocDir")
 if not pythonDocDir:
 if Utilities.isWindowsPlatform():
 venvName = Preferences.getDebugger("Python3VirtualEnv")
 interpreter = (
-e5App().getObject("VirtualEnvManager")
+ericApp().getObject("VirtualEnvManager")
 .getVirtualenvInterpreter(venvName)
 )
 if interpreter:
 default = os.path.join(os.path.dirname(interpreter), "doc")
 else:
 pythonDocDir, "python{0}.chm".format(vers))
 else:
 home = pythonDocDir
 if not os.path.exists(home):
-E5MessageBox.warning(
+EricMessageBox.warning(
 self,
 self.tr("Documentation Missing"),
 self.tr("""<p>The documentation starting point"""
 """ "<b>{0}</b>" could not be found.</p>""")
 .format(home))
 home = Utilities.normjoinpath(qtDocDir, 'index.html')
 else:
 home = qtDocDir
 if not os.path.exists(home):
-E5MessageBox.warning(
+EricMessageBox.warning(
 self,
 self.tr("Documentation Missing"),
 self.tr("""<p>The documentation starting point"""
 """ "<b>{0}</b>" could not be found.</p>""")
 .format(home))
 if not pyqtDocDir:
 pyqtDocDir = Utilities.getEnvironmentEntry(
 "PYQT{0}DOCDIR".format(variant), None)
 if not pyqtDocDir:
-E5MessageBox.warning(
+EricMessageBox.warning(
 self,
 self.tr("Documentation"),
 self.tr("""<p>The PyQt{0} documentation starting point"""
 """ has not been configured.</p>""").format(variant))
 return
 break
 else:
 home = pyqtDocDir
 if not home or not os.path.exists(home):
-E5MessageBox.warning(
+EricMessageBox.warning(
 self,
 self.tr("Documentation Missing"),
 self.tr("""<p>The documentation starting point"""
 """ "<b>{0}</b>" could not be found.</p>""")
 .format(home))
 home = Utilities.normjoinpath(
 getConfig('ericDocDir'), "Source", "index.html")
 if not home.startswith(("http://", "https://", "qthelp://")):
 if not os.path.exists(home):
-E5MessageBox.warning(
+EricMessageBox.warning(
 self,
 self.tr("Documentation Missing"),
 self.tr("""<p>The documentation starting point"""
 """ "<b>{0}</b>" could not be found.</p>""")
 .format(home))
 if not pysideDocDir:
 pysideDocDir = Utilities.getEnvironmentEntry(
 "PYSIDE{0}DOCDIR".format(variant), None)
 if not pysideDocDir:
-E5MessageBox.warning(
+EricMessageBox.warning(
 self,
 self.tr("Documentation"),
 self.tr("""<p>The PySide{0} documentation starting point"""
 """ has not been configured.</p>""").format(
 variant)
 if not os.path.splitext(pysideDocDir)[1]:
 home = Utilities.normjoinpath(pysideDocDir, 'index.html')
 else:
 home = pysideDocDir
 if not os.path.exists(home):
-E5MessageBox.warning(
+EricMessageBox.warning(
 self,
 self.tr("Documentation Missing"),
 self.tr("""<p>The documentation starting point"""
 """ "<b>{0}</b>" could not be found.</p>""")
 .format(home))
 "--name={0}".format(self.__webBrowserSAName),
 home
 ]
 process.start(sys.executable, args)
 if not process.waitForStarted():
-E5MessageBox.warning(
+EricMessageBox.warning(
 self,
 self.tr("Start Web Browser"),
 self.tr("""The eric web browser could not be"""
 """ started."""))
 return False
 process.exitCode() == 100
 ):
 # Process exited prematurely due to missing pre-requisites
 return -1
 if res <= 0:
-E5MessageBox.warning(
+EricMessageBox.warning(
 self,
 self.tr("Start Web Browser"),
 self.tr("""<p>The eric web browser is not started.</p>"""
 """<p>Reason: {0}</p>""").format(
 webBrowserClient.errstr())
 @param home full pathname of a file to display (string)
 """
 started = QDesktopServices.openUrl(QUrl(home))
 if not started:
-E5MessageBox.critical(
+EricMessageBox.critical(
 self,
 self.tr('Open Browser'),
 self.tr('Could not start a web browser'))
 @pyqtSlot()
 self.setStyle(Preferences.getUI("Style"),
 Preferences.getUI("StyleSheet"))
 if Preferences.getUI("SingleApplicationMode"):
 if self.SAServer is None:
-self.SAServer = E5SingleApplicationServer()
+self.SAServer = EricSingleApplicationServer()
 else:
 if self.SAServer is not None:
 self.SAServer.shutdown()
 self.SAServer = None
 self.newWindowAct.setEnabled(
 def __configToolBars(self):
 """
 Private slot to configure the various toolbars.
 """
-from E5Gui.E5ToolBarDialog import E5ToolBarDialog
+from E5Gui.EricToolBarDialog import EricToolBarDialog
-dlg = E5ToolBarDialog(self.toolbarManager)
+dlg = EricToolBarDialog(self.toolbarManager)
 if dlg.exec() == QDialog.DialogCode.Accepted:
 Preferences.setUI(
 "ToolbarManagerState", self.toolbarManager.saveState())
 def __configShortcuts(self):
 def __exportShortcuts(self):
 """
 Private slot to export the keyboard shortcuts.
 """
-fn, selectedFilter = E5FileDialog.getSaveFileNameAndFilter(
+fn, selectedFilter = EricFileDialog.getSaveFileNameAndFilter(
 None,
 self.tr("Export Keyboard Shortcuts"),
 "",
 self.tr("Keyboard Shortcuts File (*.ekj)"),
 "",
-E5FileDialog.DontConfirmOverwrite)
+EricFileDialog.DontConfirmOverwrite)
 if not fn:
 return
 ext = QFileInfo(fn).suffix()
 ex = selectedFilter.split("(*")[1].split(")")[0]
 if ex:
 fn += ex
 ok = (
-E5MessageBox.yesNo(
+EricMessageBox.yesNo(
 self,
 self.tr("Export Keyboard Shortcuts"),
 self.tr("""<p>The keyboard shortcuts file <b>{0}</b> exists"""
 """ already. Overwrite it?</p>""").format(fn))
 if os.path.exists(fn) else
 def __importShortcuts(self):
 """
 Private slot to import the keyboard shortcuts.
 """
-fn = E5FileDialog.getOpenFileName(
+fn = EricFileDialog.getOpenFileName(
 None,
 self.tr("Import Keyboard Shortcuts"),
 "",
 self.tr("Keyboard Shortcuts File (*.ekj);;"
 "XML Keyboard shortcut file (*.e4k)"))
 """
 Private slot to handle the projectOpened signal.
 """
 from Debugger.DebugClientCapabilities import HasUnittest
 self.__setWindowCaption(project=self.project.name)
-cap = e5App().getObject("DebugServer").getClientCapabilities(
+cap = ericApp().getObject("DebugServer").getClientCapabilities(
 self.project.getProjectLanguage())
 self.utProjectAct.setEnabled(cap & HasUnittest)
 self.utProjectOpen = cap & HasUnittest
 def __projectClosed(self):
 """
 self.wizardsMenuAct.setEnabled(
 len(self.__menus["wizards"].actions()) > 0)
 if fn and str(fn) != "None":
-dbs = e5App().getObject("DebugServer")
+dbs = ericApp().getObject("DebugServer")
 for language in dbs.getSupportedLanguages():
 exts = dbs.getExtensions(language)
 if fn.endswith(exts):
 from Debugger.DebugClientCapabilities import HasUnittest
 cap = dbs.getClientCapabilities(language)
 @param editor editor window
 """
 fn = editor.getFileName() if editor else None
 if fn:
-dbs = e5App().getObject("DebugServer")
+dbs = ericApp().getObject("DebugServer")
 for language in dbs.getSupportedLanguages():
 exts = dbs.getExtensions(language)
 if fn.endswith(exts):
 from Debugger.DebugClientCapabilities import HasUnittest
 cap = dbs.getClientCapabilities(language)
 from EricXML.TasksReader import TasksReader
 reader = TasksReader(f, viewer=self.taskViewer)
 reader.readXML()
 f.close()
 else:
-E5MessageBox.critical(
+EricMessageBox.critical(
 self,
 self.tr("Read Tasks"),
 self.tr(
 "<p>The tasks file <b>{0}</b> could not be"
 " read.</p>")
 "eric7session.esj")
 if not os.path.exists(fn):
 fn = os.path.join(Utilities.getConfigDir(),
 "eric7session.e5s")
 if not os.path.exists(fn):
-E5MessageBox.critical(
+EricMessageBox.critical(
 self,
 self.tr("Read Session"),
 self.tr("<p>The session file <b>{0}</b> could not"
 " be read.</p>")
 .format(fn))
 reader.readXML()
 self.__readingSession = False
 f.close()
 res = True
 else:
-E5MessageBox.critical(
+EricMessageBox.critical(
 self,
 self.tr("Read session"),
 self.tr("<p>The session file <b>{0}</b> could not be"
 " read.</p>")
 .format(fn))
 def __saveSessionToFile(self):
 """
 Private slot to save a session to disk.
 """
-sessionFile, selectedFilter = E5FileDialog.getSaveFileNameAndFilter(
+sessionFile, selectedFilter = EricFileDialog.getSaveFileNameAndFilter(
 self,
 self.tr("Save Session"),
 Utilities.getHomeDir(),
 self.tr("eric Session Files (*.esj)"),
 "")
 def __loadSessionFromFile(self):
 """
 Private slot to load a session from disk.
 """
-sessionFile = E5FileDialog.getOpenFileName(
+sessionFile = EricFileDialog.getOpenFileName(
 self,
 self.tr("Load session"),
 Utilities.getHomeDir(),
 self.tr("eric Session Files (*.esj);;"
 "eric XML Session Files (*.e5s)"))
 Preferences.getUI("OpenCrashSessionOnStartup")
 ):
 fn = os.path.join(Utilities.getConfigDir(),
 "eric7_crash_session.esj")
 if os.path.exists(fn):
-yes = E5MessageBox.yesNo(
+yes = EricMessageBox.yesNo(
 self,
 self.tr("Crash Session found!"),
 self.tr("""A session file of a crashed session was"""
 """ found. Shall this session be restored?"""))
 if yes:
 fname = url.toLocalFile()
 if fname:
 if QFileInfo(fname).isFile():
 self.viewmanager.openSourceFile(fname)
 else:
-E5MessageBox.information(
+EricMessageBox.information(
 self,
 self.tr("Drop Error"),
 self.tr("""<p><b>{0}</b> is not a file.</p>""")
 .format(fname))
 """
 if self.__shutdown():
 event.accept()
 if not self.inCloseEvent:
 self.inCloseEvent = True
-QTimer.singleShot(0, e5App().closeAllWindows)
+QTimer.singleShot(0, ericApp().closeAllWindows)
 else:
 event.ignore()
 def __shutdown(self):
 """
 self.httpAlternative = alternative
 url = QUrl(self.__httpAlternatives[alternative])
 self.__versionCheckCanceled = False
 if manual:
 if self.__versionCheckProgress is None:
-self.__versionCheckProgress = E5ProgressDialog(
+self.__versionCheckProgress = EricProgressDialog(
 "", self.tr("&Cancel"),
 0, len(self.__httpAlternatives),
 self.tr("%v/%m"), self)
 self.__versionCheckProgress.setWindowTitle(
 self.tr("Version Check"))
 "Updates/FirstFailedCheckDate", QDate.currentDate())
 failedDuration = firstFailure.daysTo(QDate.currentDate())
 Preferences.Prefs.settings.setValue(
 "Updates/FirstFailedCheckDate", firstFailure)
 if self.manualUpdatesCheck:
-E5MessageBox.warning(
+EricMessageBox.warning(
 self,
 self.tr("Error getting versions information"),
 self.tr("""The versions information could not be"""
 """ downloaded."""
 """ Please go online and try again."""))
 elif failedDuration > 7:
-E5MessageBox.warning(
+EricMessageBox.warning(
 self,
 self.tr("Error getting versions information"),
 self.tr("""The versions information could not be"""
 """ downloaded for the last 7 days."""
 """ Please go online and try again."""))
 # check snapshot version like snapshot-20170810
 if "snapshot-" in versions[2]:
 installedSnapshotDate = VersionOnly.rsplit("-", 1)[-1]
 availableSnapshotDate = versions[2].rsplit("-", 1)[-1]
 if availableSnapshotDate > installedSnapshotDate:
-res = E5MessageBox.yesNo(
+res = EricMessageBox.yesNo(
 self,
 self.tr("Update available"),
 self.tr(
 """The update to <b>{0}</b> of eric is"""
 """ available at <b>{1}</b>. Would you like"""
 .format(versions[2], versions[3]),
 yesDefault=True)
 url = res and versions[3] or ''
 else:
 if self.manualUpdatesCheck:
-E5MessageBox.information(
+EricMessageBox.information(
 self,
 self.tr("Update Check"),
 self.tr(
 """You are using a snapshot release of"""
 """ eric. A more up-to-date stable release"""
 """ might be available."""))
 elif VersionOnly.startswith(("rev_", "@@")):
 # check installation from source
 if self.manualUpdatesCheck:
-E5MessageBox.information(
+EricMessageBox.information(
 self,
 self.tr("Update Check"),
 self.tr(
 """You installed eric directly from the source"""
 """ code. There is no possibility to check"""
 else:
 # check release version
 installedVersionTuple = self.__versionToTuple(VersionOnly)
 availableVersionTuple = self.__versionToTuple(versions[0])
 if availableVersionTuple > installedVersionTuple:
-res = E5MessageBox.yesNo(
+res = EricMessageBox.yesNo(
 self,
 self.tr("Update available"),
 self.tr(
 """The update to <b>{0}</b> of eric is"""
 """ available at <b>{1}</b>. Would you like"""
 .format(versions[0], versions[1]),
 yesDefault=True)
 url = res and versions[1] or ''
 else:
 if self.manualUpdatesCheck:
-E5MessageBox.information(
+EricMessageBox.information(
 self,
 self.tr("eric is up to date"),
 self.tr(
 """You are using the latest version of"""
 """ eric"""))
 except (IndexError, TypeError):
-E5MessageBox.warning(
+EricMessageBox.warning(
 self,
 self.tr("Error during updates check"),
 self.tr("""Could not perform updates check."""))
 if url:
 'sourceforge' in versions[line + 1] and
 "SourceForge" or versions[line + 1])
 line += 2
 versionText += self.tr("""</table>""")
-self.__versionsDialog = E5MessageBox.E5MessageBox(
+self.__versionsDialog = EricMessageBox.EricMessageBox(
-E5MessageBox.NoIcon,
+EricMessageBox.NoIcon,
 Program,
 versionText,
 modal=False,
-buttons=E5MessageBox.Ok,
+buttons=EricMessageBox.Ok,
 parent=self
 )
 self.__versionsDialog.setIconPixmap(
 UI.PixmapCache.getPixmap("eric").scaled(64, 64))
 self.__versionsDialog.show()
 the configuration dialog is shown.
 """
 if not Preferences.isConfigured():
 self.__initDebugToolbarsLayout()
-E5MessageBox.information(
+EricMessageBox.information(
 self,
 self.tr("First time usage"),
 self.tr("""eric has not been configured yet. """
 """The configuration dialog will be started."""))
 self.showPreferences()
 self.checkConfigurationStatus()
 workspace = Preferences.getMultiProject("Workspace")
 if workspace == "":
 default = Utilities.getHomeDir()
-workspace = E5FileDialog.getExistingDirectory(
+workspace = EricFileDialog.getExistingDirectory(
 None,
 self.tr("Select Workspace Directory"),
 default,
-E5FileDialog.Option(0))
+EricFileDialog.Option(0))
 Preferences.setMultiProject("Workspace", workspace)
 def versionIsNewer(self, required, snapshot=None):
 """
 Public method to check, if the eric version is good compared to

Mercurial Repositories > eric / file comparison

comparison: eric7/UI/UserInterface.py

eric7/UI/UserInterface.py