eric: comparison UI/UserInterface.py

-:1b59c4ba121e
+:8cd4d08fa9f6
 @param s data to be written (it must support the str-method)
 """
 self.buffer += str(s)
 self.__nWrite(self.__bufferedWrite())
 class UserInterface(QMainWindow):
 """
 Class implementing the main user interface.
 self.multiProject = MultiProject(self.project, self)
 splash.showMessage(self.trUtf8("Initializing Plugin Manager..."))
 # Initialize the Plugin Manager (Plugins are initialized later
-self.pluginManager = PluginManager(self, develPlugin = plugin)
+self.pluginManager = PluginManager(self, develPlugin=plugin)
 splash.showMessage(self.trUtf8("Generating Main User Interface..."))
 # Create the main window now so that we can connect QActions to it.
 logging.debug("Creating Layout...")
 self.__createLayout(debugServer)
 # Generate the debugger part of the ui
 logging.debug("Creating Debugger UI...")
 self.debuggerUI = DebugUI(self, self.viewmanager, debugServer,
 self.debugViewer, self.project)
 self.debugViewer.setDebugger(self.debuggerUI)
 self.shell.setDebuggerUI(self.debuggerUI)
 # Generate the redirection helpers
 # Generate the find in project files dialog
 self.findFilesDialog = FindFileDialog(self.project)
 self.findFilesDialog.sourceFile.connect(
 self.viewmanager.openSourceFile)
 self.findFilesDialog.designerFile.connect(self.__designer)
-self.replaceFilesDialog = FindFileDialog(self.project, replaceMode = True)
+self.replaceFilesDialog = FindFileDialog(self.project, replaceMode=True)
 self.replaceFilesDialog.sourceFile.connect(
 self.viewmanager.openSourceFile)
 self.replaceFilesDialog.designerFile.connect(self.__designer)
 # generate the find file dialog
 # step 2: set a style sheet
 styleSheetFile = Preferences.getUI("StyleSheet")
 if styleSheetFile:
 try:
-f = open(styleSheetFile, "r", encoding = "utf-8")
+f = open(styleSheetFile, "r", encoding="utf-8")
 styleSheet = f.read()
 f.close()
 except IOError as msg:
 E5MessageBox.warning(self,
 self.trUtf8("Loading Style Sheet"),
 self.multiProjectBrowser = MultiProjectBrowser(self.multiProject)
 self.multiProjectBrowser.setWindowTitle(self.trUtf8("Multiproject-Viewer"))
 # Create the debug viewer maybe without the embedded shell
 self.debugViewer = DebugViewer(debugServer, False, self.viewmanager, None,
 embeddedShell=self.embeddedShell,
 embeddedBrowser=(self.embeddedFileBrowser == 1))
 self.debugViewer.setWindowTitle(self.trUtf8("Debug-Viewer"))
 # Create the chat part of the user interface
 self.cooperation = ChatWidget()
 # Create the numbers viewer
 self.numbersViewer = NumbersWidget()
 self.numbersViewer.setWindowTitle(self.trUtf8("Numbers"))
 self.windows = [self.projectBrowser, None, self.debugViewer,
 None, self.logViewer, self.taskViewer, self.templateViewer,
 self.multiProjectBrowser, self.terminal, self.cooperation,
 self.symbolsViewer, self.numbersViewer]
 if self.embeddedShell:
 self.shell = self.debugViewer.shell
 else:
 if self.embeddedFileBrowser == 0:   # separate window
 # Create the file browser
 self.browser = Browser(None)
 self.browser.setWindowTitle(self.trUtf8("File-Browser"))
 self.windows[1] = self.browser
-elif self.embeddedFileBrowser == 1: # embedded in debug browser
+elif self.embeddedFileBrowser == 1:  # embedded in debug browser
 self.browser = self.debugViewer.browser
 else:                               # embedded in project browser
 self.browser = self.projectBrowser.fileBrowser
 def __createDockWindowsLayout(self, debugServer):
 # Create the multi project browser
 self.multiProjectBrowserDock = \
 self.__createDockWindow("MultiProjectBrowserDock")
 self.multiProjectBrowser = MultiProjectBrowser(self.multiProject)
 self.__setupDockWindow(self.multiProjectBrowserDock, Qt.LeftDockWidgetArea,
 self.multiProjectBrowser,
 self.trUtf8("Multiproject-Viewer"))
 # Create the debug viewer maybe without the embedded shell
 self.debugViewerDock = self.__createDockWindow("DebugViewerDock")
 self.debugViewer = DebugViewer(debugServer, True, self.viewmanager,
 self.debugViewerDock,
 embeddedShell=self.embeddedShell,
 embeddedBrowser=(self.embeddedFileBrowser == 1))
 self.__setupDockWindow(self.debugViewerDock, Qt.RightDockWidgetArea,
 self.debugViewer, self.trUtf8("Debug-Viewer"))
 # Create the chat part of the user interface
 self.cooperationDock = self.__createDockWindow("CooperationDock")
-self.cooperation = ChatWidget(parent = self.cooperationDock)
+self.cooperation = ChatWidget(parent=self.cooperationDock)
 self.__setupDockWindow(self.cooperationDock, Qt.RightDockWidgetArea,
 self.cooperation, self.trUtf8("Cooperation"))
 # Create the log viewer part of the user interface
 self.logViewerDock = self.__createDockWindow("LogViewerDock")
 self.__setupDockWindow(self.taskViewerDock, Qt.BottomDockWidgetArea,
 self.taskViewer, self.trUtf8("Task-Viewer"))
 # Create the template viewer part of the user interface
 self.templateViewerDock = self.__createDockWindow("TemplateViewerDock")
 self.templateViewer = TemplateViewer(self.templateViewerDock,
 self.viewmanager)
 self.__setupDockWindow(self.templateViewerDock, Qt.RightDockWidgetArea,
 self.templateViewer, self.trUtf8("Template-Viewer"))
 # Create the terminal
 self.terminalDock = self.__createDockWindow("TerminalDock")
 self.terminal = Terminal(self.viewmanager, self.terminalDock)
 self.__setupDockWindow(self.terminalDock, Qt.BottomDockWidgetArea,
 self.terminal, self.trUtf8("Terminal"))
 self.windows = [self.projectBrowserDock, None, self.debugViewerDock,
 None, self.logViewerDock, self.taskViewerDock, self.templateViewerDock,
 self.multiProjectBrowserDock, self.terminalDock, self.cooperationDock]
 if self.embeddedShell:
 self.shell = self.debugViewer.shell
 else:
 self.browserDock = self.__createDockWindow("BrowserDock")
 self.browser = Browser(self.browserDock)
 self.__setupDockWindow(self.browserDock, Qt.RightDockWidgetArea,
 self.browser, self.trUtf8("File-Browser"))
 self.windows[1] = self.browserDock
-elif self.embeddedFileBrowser == 1: # embedded in debug browser
+elif self.embeddedFileBrowser == 1:  # embedded in debug browser
 self.browser = self.debugViewer.browser
 else:                               # embedded in project browser
 self.browser = self.projectBrowser.fileBrowser
 # Create the symbols viewer
 @param debugServer reference to the debug server object
 """
 # Create the vertical toolbox
 self.vToolboxDock = self.__createDockWindow("vToolboxDock")
 self.vToolbox = E5VerticalToolBox(self.vToolboxDock)
 self.__setupDockWindow(self.vToolboxDock, Qt.LeftDockWidgetArea,
 self.vToolbox, self.trUtf8("Vertical Toolbox"))
 # Create the horizontal toolbox
 self.hToolboxDock = self.__createDockWindow("hToolboxDock")
 self.hToolbox = E5HorizontalToolBox(self.hToolboxDock)
 self.__setupDockWindow(self.hToolboxDock, Qt.BottomDockWidgetArea,
 self.hToolbox, self.trUtf8("Horizontal Toolbox"))
 # Create the project browser
 self.projectBrowser = ProjectBrowser(self.project, None,
 embeddedBrowser=(self.embeddedFileBrowser == 2))
 self.vToolbox.addItem(self.projectBrowser,
 UI.PixmapCache.getIcon("projectViewer.png"),
 self.trUtf8("Project-Viewer"))
 # Create the multi project browser
 self.multiProjectBrowser = MultiProjectBrowser(self.multiProject)
 self.vToolbox.addItem(self.multiProjectBrowser,
 UI.PixmapCache.getIcon("multiProjectViewer.png"),
 self.trUtf8("Multiproject-Viewer"))
 # Create the template viewer part of the user interface
 self.templateViewer = TemplateViewer(None,
 self.viewmanager)
 self.vToolbox.addItem(self.templateViewer,
 UI.PixmapCache.getIcon("templateViewer.png"),
 self.trUtf8("Template-Viewer"))
 # Create the debug viewer maybe without the embedded shell
 self.debugViewerDock = self.__createDockWindow("DebugViewerDock")
 self.debugViewer = DebugViewer(debugServer, True, self.viewmanager,
 self.debugViewerDock,
 embeddedShell=self.embeddedShell,
 embeddedBrowser=(self.embeddedFileBrowser == 1))
 self.__setupDockWindow(self.debugViewerDock, Qt.RightDockWidgetArea,
 self.debugViewer, self.trUtf8("Debug-Viewer"))
 # Create the chat part of the user interface
 self.cooperationDock = self.__createDockWindow("CooperationDock")
-self.cooperation = ChatWidget(parent = self.cooperationDock)
+self.cooperation = ChatWidget(parent=self.cooperationDock)
 self.__setupDockWindow(self.cooperationDock, Qt.RightDockWidgetArea,
 self.cooperation, self.trUtf8("Cooperation"))
 # Create the terminal part of the user interface
 self.terminal = Terminal(self.viewmanager)
 self.hToolbox.addItem(self.terminal,
 UI.PixmapCache.getIcon("terminal.png"),
 self.trUtf8("Terminal"))
 # Create the task viewer part of the user interface
 self.taskViewer = TaskViewer(None, self.project)
 self.hToolbox.addItem(self.taskViewer,
 UI.PixmapCache.getIcon("task.png"),
 self.trUtf8("Task-Viewer"))
 # Create the log viewer part of the user interface
 self.logViewer = LogViewer()
 self.hToolbox.addItem(self.logViewer,
 UI.PixmapCache.getIcon("logViewer.png"),
 self.trUtf8("Log-Viewer"))
 self.windows = [None, None, self.debugViewerDock, None, None,
 None, None, None, None, self.cooperationDock]
 if self.embeddedShell:
 self.shell = self.debugViewer.shell
 else:
 # Create the shell
 self.shell = Shell(debugServer, self.viewmanager)
 self.hToolbox.insertItem(0, self.shell,
 UI.PixmapCache.getIcon("shell.png"),
 self.trUtf8("Shell"))
 if self.embeddedFileBrowser == 0:   # separate window
 # Create the file browser
 self.browser = Browser()
 self.vToolbox.addItem(self.browser,
 UI.PixmapCache.getIcon("browser.png"),
 self.trUtf8("File-Browser"))
-elif self.embeddedFileBrowser == 1: # embedded in debug browser
+elif self.embeddedFileBrowser == 1:  # embedded in debug browser
 self.browser = self.debugViewer.browser
 else:                               # embedded in project browser
 self.browser = self.projectBrowser.fileBrowser
 # Create the symbols viewer
 self.symbolsViewer = SymbolsWidget()
 self.vToolbox.addItem(self.symbolsViewer,
 UI.PixmapCache.getIcon("symbols.png"),
 self.trUtf8("Symbols"))
 # Create the numbers viewer
 self.numbersViewer = NumbersWidget()
 self.hToolbox.addItem(self.numbersViewer,
 UI.PixmapCache.getIcon("numbers.png"),
 self.trUtf8("Numbers"))
 self.hToolbox.setCurrentIndex(0)
 def __createSidebarsLayout(self, debugServer):
 # Create the project browser
 logging.debug("Creating Project Browser...")
 self.projectBrowser = ProjectBrowser(self.project, None,
 embeddedBrowser=(self.embeddedFileBrowser == 2))
 self.leftSidebar.addTab(self.projectBrowser,
 UI.PixmapCache.getIcon("projectViewer.png"),
 self.trUtf8("Project-Viewer"))
 # Create the multi project browser
 logging.debug("Creating Multiproject Browser...")
 self.multiProjectBrowser = MultiProjectBrowser(self.multiProject)
 self.leftSidebar.addTab(self.multiProjectBrowser,
 UI.PixmapCache.getIcon("multiProjectViewer.png"),
 self.trUtf8("Multiproject-Viewer"))
 # Create the template viewer part of the user interface
 logging.debug("Creating Template Viewer...")
 self.templateViewer = TemplateViewer(None,
 self.viewmanager)
 self.leftSidebar.addTab(self.templateViewer,
 UI.PixmapCache.getIcon("templateViewer.png"),
 self.trUtf8("Template-Viewer"))
 # Create the debug viewer maybe without the embedded shell
 logging.debug("Creating Debug Viewer...")
 self.debugViewerDock = self.__createDockWindow("DebugViewerDock")
 self.debugViewer = DebugViewer(debugServer, True, self.viewmanager,
 self.debugViewerDock,
 embeddedShell=self.embeddedShell,
 embeddedBrowser=(self.embeddedFileBrowser == 1))
 self.__setupDockWindow(self.debugViewerDock, Qt.RightDockWidgetArea,
 self.debugViewer, self.trUtf8("Debug-Viewer"))
 # Create the chat part of the user interface
 self.cooperationDock = self.__createDockWindow("CooperationDock")
-self.cooperation = ChatWidget(parent = self.cooperationDock)
+self.cooperation = ChatWidget(parent=self.cooperationDock)
 self.__setupDockWindow(self.cooperationDock, Qt.RightDockWidgetArea,
 self.cooperation, self.trUtf8("Cooperation"))
 # Create the terminal part of the user interface
 logging.debug("Creating Terminal...")
 self.terminal = Terminal(self.viewmanager)
 self.bottomSidebar.addTab(self.terminal,
 UI.PixmapCache.getIcon("terminal.png"),
 self.trUtf8("Terminal"))
 # Create the task viewer part of the user interface
 logging.debug("Creating Task Viewer...")
 self.taskViewer = TaskViewer(None, self.project)
 self.bottomSidebar.addTab(self.taskViewer,
 UI.PixmapCache.getIcon("task.png"),
 self.trUtf8("Task-Viewer"))
 # Create the log viewer part of the user interface
 logging.debug("Creating Log Viewer...")
 self.logViewer = LogViewer()
 self.bottomSidebar.addTab(self.logViewer,
 UI.PixmapCache.getIcon("logViewer.png"),
 self.trUtf8("Log-Viewer"))
 self.windows = [None, None, self.debugViewerDock, None, None,
 None, None, None, None, self.cooperationDock]
 if self.embeddedShell:
 self.shell = self.debugViewer.shell
 else:
 # Create the shell
 logging.debug("Creating Shell...")
 self.shell = Shell(debugServer, self.viewmanager)
 self.bottomSidebar.insertTab(0, self.shell,
 UI.PixmapCache.getIcon("shell.png"),
 self.trUtf8("Shell"))
 if self.embeddedFileBrowser == 0:   # separate window
 # Create the file browser
 logging.debug("Creating File Browser...")
 self.browser = Browser()
 self.leftSidebar.addTab(self.browser,
 UI.PixmapCache.getIcon("browser.png"),
 self.trUtf8("File-Browser"))
-elif self.embeddedFileBrowser == 1: # embedded in debug browser
+elif self.embeddedFileBrowser == 1:  # embedded in debug browser
 self.browser = self.debugViewer.browser
 else:                               # embedded in project browser
 self.browser = self.projectBrowser.fileBrowser
 # Create the symbols viewer
 self.symbolsViewer = SymbolsWidget()
 self.leftSidebar.addTab(self.symbolsViewer,
 UI.PixmapCache.getIcon("symbols.png"),
 self.trUtf8("Symbols"))
 # Create the numbers viewer
 self.numbersViewer = NumbersWidget()
 self.bottomSidebar.addTab(self.numbersViewer,
 UI.PixmapCache.getIcon("numbers.png"),
 self.trUtf8("Numbers"))
 self.bottomSidebar.setCurrentIndex(0)
 # create the central widget
 self.bottomSidebar.setCurrentWidget(self.logViewer)
 self.bottomSidebar.raise_()
 if self.bottomSidebar.isAutoHiding():
 self.bottomSidebar.setFocus()
-def __openOnStartup(self, startupType = None):
+def __openOnStartup(self, startupType=None):
 """
 Private method to open the last file, project or multiproject.
 @param startupType type of startup requested (string, one of
 "Nothing", "File", "Project", "MultiProject" or "Session")
 """
 startupTypeMapping = {
-"Nothing"       : 0,
+"Nothing": 0,
-"File"          : 1,
+"File": 1,
-"Project"       : 2,
+"Project": 2,
-"MultiProject"  : 3,
+"MultiProject": 3,
-"Session"       : 4,
+"Session": 4,
 }
 if startupType is None:
 startup = Preferences.getUI("OpenOnStartup")
 else:
 """
 Public method to process the command line args passed to the UI.
 @param args list of files to open<br />
 The args are processed one at a time. All arguments after a
 '--' option are considered debug arguments to the program
 for the debugger. All files named before the '--' option
 are opened in a text editor, unless the argument ends in
 .e4p, then it is opened as a project file. If it ends in
 .e4m, it is opened as a multiproject.
 """
 # no args, return
 if args is None:
 if not self.__noOpenAtStartup:
 self.addDockWidget(where, dock)
 dock.setWidget(widget)
 dock.setWindowTitle(caption)
 dock.show()
-def __setWindowCaption(self, editor = None, project = None):
+def __setWindowCaption(self, editor=None, project=None):
 """
 Private method to set the caption of the Main Window.
 @param editor filename to be displayed (string)
 @param project project name to be displayed (string)
 self.wizardsActions = []
 self.exitAct = E5Action(self.trUtf8('Quit'),
 UI.PixmapCache.getIcon("exit.png"),
 self.trUtf8('&Quit'),
-QKeySequence(self.trUtf8("Ctrl+Q","File|Quit")),
+QKeySequence(self.trUtf8("Ctrl+Q", "File|Quit")),
 0, self, 'quit')
 self.exitAct.setStatusTip(self.trUtf8('Quit the IDE'))
 self.exitAct.setWhatsThis(self.trUtf8(
 """<b>Quit the IDE</b>"""
 """<p>This quits the IDE. Any unsaved changes may be saved first."""
 self.pbActivateAct.triggered[()].connect(self.__activateProjectBrowser)
 self.actions.append(self.pbActivateAct)
 self.addAction(self.pbActivateAct)
 self.mpbAct = E5Action(self.trUtf8('Multiproject-Viewer'),
 self.trUtf8('&Multiproject-Viewer'), 0, 0, self,
 'multi_project_viewer', True)
 self.mpbAct.setStatusTip(self.trUtf8('Toggle the Multiproject-Viewer window'))
 self.mpbAct.setWhatsThis(self.trUtf8(
 """<b>Toggle the Multiproject-Viewer window</b>"""
 """<p>If the Multiproject-Viewer window is hidden then display it."""
 self.taskViewerActivateAct = E5Action(self.trUtf8('Activate Task-Viewer'),
 self.trUtf8('Activate Task-Viewer'),
 QKeySequence(self.trUtf8("Alt+Shift+T")),
 0, self,
-'task_viewer_activate',1)
+'task_viewer_activate', 1)
 self.taskViewerActivateAct.triggered[()].connect(self.__activateTaskViewer)
 self.actions.append(self.taskViewerActivateAct)
 self.addAction(self.taskViewerActivateAct)
 self.templateViewerAct = E5Action(self.trUtf8('Template-Viewer'),
 self.templateViewerActivateAct = E5Action(self.trUtf8('Activate Template-Viewer'),
 self.trUtf8('Activate Template-Viewer'),
 QKeySequence(self.trUtf8("Alt+Shift+A")),
 0, self,
-'template_viewer_activate',1)
+'template_viewer_activate', 1)
 self.templateViewerActivateAct.triggered[()].connect(self.__activateTemplateViewer)
 self.actions.append(self.templateViewerActivateAct)
 self.addAction(self.templateViewerActivateAct)
 self.vtAct = E5Action(self.trUtf8('Vertical Toolbox'),
 ))
 self.vtAct.triggered[()].connect(self.__toggleVerticalToolbox)
 self.actions.append(self.vtAct)
 self.htAct = E5Action(self.trUtf8('Horizontal Toolbox'),
 self.trUtf8('&Horizontal Toolbox'), 0, 0, self,
 'horizontal_toolbox', True)
 self.htAct.setStatusTip(self.trUtf8('Toggle the Horizontal Toolbox window'))
 self.htAct.setWhatsThis(self.trUtf8(
 """<b>Toggle the Horizontal Toolbox window</b>"""
 """<p>If the Horizontal Toolbox window is hidden then display it."""
 ))
 self.lsbAct.triggered[()].connect(self.__toggleLeftSidebar)
 self.actions.append(self.lsbAct)
 self.bsbAct = E5Action(self.trUtf8('Bottom Sidebar'),
 self.trUtf8('&Bottom Sidebar'), 0, 0, self,
 'bottom_sidebar', True)
 self.bsbAct.setStatusTip(self.trUtf8('Toggle the bottom sidebar window'))
 self.bsbAct.setWhatsThis(self.trUtf8(
 """<b>Toggle the bottom sidebar window</b>"""
 """<p>If the bottom sidebar window is hidden then display it."""
 self.actions.append(self.numbersViewerActivateAct)
 self.addAction(self.numbersViewerActivateAct)
 self.whatsThisAct = E5Action(self.trUtf8('What\'s This?'),
 UI.PixmapCache.getIcon("whatsThis.png"),
 self.trUtf8('&What\'s This?'),
 QKeySequence(self.trUtf8("Shift+F1")),
 0, self, 'whatsThis')
 self.whatsThisAct.setStatusTip(self.trUtf8('Context sensitive help'))
 self.whatsThisAct.setWhatsThis(self.trUtf8(
 """<b>Display context sensitive help</b>"""
 self.whatsThisAct.triggered[()].connect(self.__whatsThis)
 self.actions.append(self.whatsThisAct)
 self.helpviewerAct = E5Action(self.trUtf8('Helpviewer'),
 UI.PixmapCache.getIcon("help.png"),
 self.trUtf8('&Helpviewer...'),
 QKeySequence(self.trUtf8("F1")),
 0, self, 'helpviewer')
 self.helpviewerAct.setStatusTip(self.trUtf8('Open the helpviewer window'))
 self.helpviewerAct.setWhatsThis(self.trUtf8(
 """<b>Helpviewer</b>"""
 ))
 self.checkUpdateAct.triggered[()].connect(self.performVersionCheck)
 self.actions.append(self.checkUpdateAct)
 self.showVersionsAct = E5Action(self.trUtf8('Show downloadable versions'),
 self.trUtf8('Show &downloadable versions...'),
 0, 0, self, 'show_downloadable_versions')
 self.showVersionsAct.setStatusTip(
 self.trUtf8('Show the versions available for download'))
 self.showVersionsAct.setWhatsThis(self.trUtf8(
 """<b>Show downloadable versions...</b>"""
 self.requestFeatureAct.triggered[()].connect(self.__requestFeature)
 self.actions.append(self.requestFeatureAct)
 self.utActGrp = createActionGroup(self)
 self.utDialogAct = E5Action(self.trUtf8('Unittest'),
 UI.PixmapCache.getIcon("unittest.png"),
 self.trUtf8('&Unittest...'),
 0, 0, self.utActGrp, 'unittest')
 self.utDialogAct.setStatusTip(self.trUtf8('Start unittest dialog'))
 self.utDialogAct.setWhatsThis(self.trUtf8(
 # check for Qt4 designer and linguist
 designerExe = Utilities.isWindowsPlatform() and \
 "{0}.exe".format(Utilities.generateQtToolName("designer")) or \
 Utilities.generateQtToolName("designer")
 if Utilities.isinpath(designerExe):
 self.designer4Act = E5Action(self.trUtf8('Qt-Designer 4'),
 UI.PixmapCache.getIcon("designer4.png"),
 self.trUtf8('&Designer 4...'), 0, 0, self, 'qt_designer4')
 self.designer4Act.setStatusTip(self.trUtf8('Start Qt-Designer 4'))
 self.designer4Act.setWhatsThis(self.trUtf8(
 """<b>Qt-Designer 4</b>"""
 linguistExe = Utilities.isWindowsPlatform() and \
 "{0}.exe".format(Utilities.generateQtToolName("linguist")) or \
 Utilities.generateQtToolName("linguist")
 if Utilities.isinpath(linguistExe):
 self.linguist4Act = E5Action(self.trUtf8('Qt-Linguist 4'),
 UI.PixmapCache.getIcon("linguist4.png"),
 self.trUtf8('&Linguist 4...'), 0, 0, self, 'qt_linguist4')
 self.linguist4Act.setStatusTip(self.trUtf8('Start Qt-Linguist 4'))
 self.linguist4Act.setWhatsThis(self.trUtf8(
 """<b>Qt-Linguist 4</b>"""
 self.linguist4Act.triggered[()].connect(self.__linguist4)
 self.actions.append(self.linguist4Act)
 else:
 self.linguist4Act = None
 self.uipreviewerAct = E5Action(self.trUtf8('UI Previewer'),
 UI.PixmapCache.getIcon("uiPreviewer.png"),
 self.trUtf8('&UI Previewer...'), 0, 0, self, 'ui_previewer')
 self.uipreviewerAct.setStatusTip(self.trUtf8('Start the UI Previewer'))
 self.uipreviewerAct.setWhatsThis(self.trUtf8(
 """<b>UI Previewer</b>"""
 """<p>Start the UI Previewer.</p>"""
 ))
 self.uipreviewerAct.triggered[()].connect(self.__UIPreviewer)
 self.actions.append(self.uipreviewerAct)
 self.trpreviewerAct = E5Action(self.trUtf8('Translations Previewer'),
 UI.PixmapCache.getIcon("trPreviewer.png"),
 self.trUtf8('&Translations Previewer...'), 0, 0, self, 'tr_previewer')
 self.trpreviewerAct.setStatusTip(self.trUtf8('Start the Translations Previewer'))
 self.trpreviewerAct.setWhatsThis(self.trUtf8(
 """<b>Translations Previewer</b>"""
 self.diffAct.triggered[()].connect(self.__compareFiles)
 self.actions.append(self.diffAct)
 self.compareAct = E5Action(self.trUtf8('Compare Files side by side'),
 UI.PixmapCache.getIcon("compareFiles.png"),
 self.trUtf8('Compare Files &side by side...'),
 0, 0, self, 'compare_files')
 self.compareAct.setStatusTip(self.trUtf8('Compare two files'))
 self.compareAct.setWhatsThis(self.trUtf8(
 """<b>Compare Files side by side</b>"""
 """<p>Open a dialog to compare two files and show the result"""
 self.compareAct.triggered[()].connect(self.__compareFilesSbs)
 self.actions.append(self.compareAct)
 self.sqlBrowserAct = E5Action(self.trUtf8('SQL Browser'),
 UI.PixmapCache.getIcon("sqlBrowser.png"),
 self.trUtf8('SQL &Browser...'),
 0, 0, self, 'sql_browser')
 self.sqlBrowserAct.setStatusTip(self.trUtf8('Browse a SQL database'))
 self.sqlBrowserAct.setWhatsThis(self.trUtf8(
 """<b>SQL Browser</b>"""
 """<p>Browse a SQL database.</p>"""
 self.sqlBrowserAct.triggered[()].connect(self.__sqlBrowser)
 self.actions.append(self.sqlBrowserAct)
 self.miniEditorAct = E5Action(self.trUtf8('Mini Editor'),
 UI.PixmapCache.getIcon("editor.png"),
 self.trUtf8('Mini &Editor...'),
 0, 0, self, 'mini_editor')
 self.miniEditorAct.setStatusTip(self.trUtf8('Mini Editor'))
 self.miniEditorAct.setWhatsThis(self.trUtf8(
 """<b>Mini Editor</b>"""
 """<p>Open a dialog with a simplified editor.</p>"""
 self.miniEditorAct.triggered[()].connect(self.__openMiniEditor)
 self.actions.append(self.miniEditorAct)
 self.webBrowserAct = E5Action(self.trUtf8('Web Browser'),
 UI.PixmapCache.getIcon("ericWeb.png"),
 self.trUtf8('&Web Browser...'),
 0, 0, self, 'web_browser')
 self.webBrowserAct.setStatusTip(self.trUtf8('Start the eric5 Web Browser'))
 self.webBrowserAct.setWhatsThis(self.trUtf8(
 """<b>Web Browser</b>"""
 """<p>Browse the Internet with the eric5 Web Browser.</p>"""
 self.webBrowserAct.triggered[()].connect(self.__startWebBrowser)
 self.actions.append(self.webBrowserAct)
 self.iconEditorAct = E5Action(self.trUtf8('Icon Editor'),
 UI.PixmapCache.getIcon("iconEditor.png"),
 self.trUtf8('&Icon Editor...'),
 0, 0, self, 'icon_editor')
 self.iconEditorAct.setStatusTip(self.trUtf8('Start the eric5 Icon Editor'))
 self.iconEditorAct.setWhatsThis(self.trUtf8(
 """<b>Icon Editor</b>"""
 """<p>Starts the eric5 Icon Editor for editing simple icons.</p>"""
 self.viewmanagerActivateAct = E5Action(self.trUtf8('Activate current editor'),
 self.trUtf8('Activate current editor'),
 QKeySequence(self.trUtf8("Alt+Shift+E")),
 0, self,
-'viewmanager_activate',1)
+'viewmanager_activate', 1)
 self.viewmanagerActivateAct.triggered[()].connect(self.__activateViewmanager)
 self.actions.append(self.viewmanagerActivateAct)
 self.addAction(self.viewmanagerActivateAct)
 self.nextTabAct = E5Action(self.trUtf8('Show next'),
 self.trUtf8('Show next'),
 QKeySequence(self.trUtf8('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.trUtf8('Show previous'),
 self.trUtf8('Show previous'),
 QKeySequence(self.trUtf8('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.trUtf8('Switch between tabs'),
 self.trUtf8('Switch between tabs'),
 QKeySequence(self.trUtf8('Ctrl+1')), 0,
 self, 'switch_tabs')
 self.switchTabAct.triggered[()].connect(self.__switchTab)
 self.actions.append(self.switchTabAct)
 self.addAction(self.switchTabAct)
 QMenu(self.trUtf8("&Toolbars"), self.__menus["window"])
 self.__menus["toolbars"].setTearOffEnabled(True)
 self.__menus["toolbars"].aboutToShow.connect(self.__showToolbarsMenu)
 self.__menus["toolbars"].triggered.connect(self.__TBMenuTriggered)
-self.__showWindowMenu() # to initialize these actions
+self.__showWindowMenu()  # to initialize these actions
 self.__menus["bookmarks"] = self.viewmanager.initBookmarkMenu()
 mb.addMenu(self.__menus["bookmarks"])
 self.__menus["bookmarks"].setTearOffEnabled(True)
 self.sbPos.setWhatsThis(self.trUtf8(
 """<p>This part of the status bar displays the cursor position of"""
 """ the current editor.</p>"""
 ))
 self.viewmanager.setSbInfo(self.sbFile, self.sbLine, self.sbPos,
 self.sbWritable, self.sbEncoding, self.sbLanguage,
 self.sbEol)
 self.sbVcsMonitorLed = StatusMonitorLed(self.project, self.__statusBar)
 self.__statusBar.addPermanentWidget(self.sbVcsMonitorLed)
 self.toolGroupActions = {}
 for toolGroup in self.toolGroups:
 category = self.trUtf8("External Tools/{0}").format(toolGroup[0])
 for tool in toolGroup[1]:
 if tool['menutext'] != '--':
 act = QAction(UI.PixmapCache.getIcon(tool['icon']), tool['menutext'],
 self)
 act.setObjectName("{0}@@{1}".format(toolGroup[0],
 tool['menutext']))
 act.triggered[()].connect(self.__toolActionTriggered)
 self.toolGroupActions[act.objectName()] = act
 self.toolbarManager.addAction(act, category)
 category = self.trUtf8("External Tools/{0}").format(toolGroup[0])
 for tool in toolGroup[1]:
 if tool['menutext'] != '--':
 key = "{0}@@{1}".format(toolGroup[0], tool['menutext'])
 if key not in groupActionKeys:
 act = QAction(UI.PixmapCache.getIcon(tool['icon']), tool['menutext'],
 self)
 act.setObjectName(key)
 act.triggered[()].connect(self.__toolActionTriggered)
 self.toolGroupActions[key] = act
 """
 Private slot to handle the Feature Request dialog.
 """
 self.__showEmailDialog("feature")
-def __showEmailDialog(self, mode, attachFile = None, deleteAttachFile = False):
+def __showEmailDialog(self, mode, attachFile=None, deleteAttachFile=False):
 """
 Private slot to show the email dialog in a given mode.
 @param mode mode of the email dialog (string, "bug" or "feature")
 @param attachFile name of a file to attach to the email (string)
 else:
 if Preferences.getUser("Email") == "" or \
 Preferences.getUser("MailServer") == "":
 E5MessageBox.critical(self,
 self.trUtf8("Report Bug"),
 self.trUtf8("""Email address or mail server address is empty."""
 """ Please configure your Email settings in the"""
 """ Preferences Dialog."""))
 self.showPreferences("emailPage")
 return
-self.dlg = EmailDialog(mode = mode)
+self.dlg = EmailDialog(mode=mode)
 if attachFile is not None:
 self.dlg.attachFile(attachFile, deleteAttachFile)
 self.dlg.show()
-def __showSystemEmailClient(self, mode, attachFile = None, deleteAttachFile = False):
+def __showSystemEmailClient(self, mode, attachFile=None, deleteAttachFile=False):
 """
 Private slot to show the system email dialog.
 @param mode mode of the email dialog (string, "bug" or "feature")
 @param attachFile name of a file to put into the body of the
 email (string)
 @param deleteAttachFile flag indicating to delete the file after
 it has been read (boolean)
 """
 if mode == "feature":
 address = FeatureAddress
 else:
 address = BugAddress
 subject = "[eric5] "
 if attachFile is not None:
-f = open(attachFile, "r", encoding = "utf-8")
+f = open(attachFile, "r", encoding="utf-8")
 body = f.read()
 f.close()
 if deleteAttachFile:
 os.remove(attachFile)
 else:
 body = "\r\n----\r\n{0}----\r\n{1}----\r\n{2}".format(
 Utilities.generateVersionInfo("\r\n"),
 Utilities.generatePluginsVersionInfo("\r\n"),
 Utilities.generateDistroInfo("\r\n"))
 url = QUrl("mailto:{0}".format(address))
 url.addQueryItem("subject", subject)
 url.addQueryItem("body", body)
 what to do with it.
 """
 if Preferences.getUI("CheckErrorLog"):
 logFile = os.path.join(Utilities.getConfigDir(), "eric5_error.log")
 if os.path.exists(logFile):
 dlg = E5MessageBox.E5MessageBox(E5MessageBox.Question,
 self.trUtf8("Error log found"),
 self.trUtf8("An error log file was found. "
 "What should be done with it?"),
-modal = True, parent = self)
+modal=True, parent=self)
 try:
-f = open(logFile, "r", encoding = "utf-8")
+f = open(logFile, "r", encoding="utf-8")
 txt = f.read()
 f.close()
 dlg.setDetailedText(txt)
 except IOError:
 pass
 emailButton = \
 dlg.addButton(self.trUtf8("Send Bug Email"),
 E5MessageBox.AcceptRole)
 deleteButton = \
 dlg.addButton(self.trUtf8("Ignore and Delete"),
 E5MessageBox.AcceptRole)
 keepButton = \
 dlg.addButton(self.trUtf8("Ignore but Keep"),
 E5MessageBox.AcceptRole)
 dlg.setDefaultButton(emailButton)
 dlg.setEscapeButton(keepButton)
 dlg.exec_()
 btn = dlg.clickedButton()
 if btn == emailButton:
 # start email dialog
 self.__showEmailDialog("bug",
-attachFile = logFile, deleteAttachFile = True)
+attachFile=logFile, deleteAttachFile=True)
 elif btn == deleteButton:
 # delete the error log
 os.remove(logFile)
 elif btn == keepButton:
 # keep the error log
 def __openMiniEditor(self):
 """
 Private slot to show a mini editor window.
 """
-editor = MiniEditor(parent = self)
+editor = MiniEditor(parent=self)
 editor.show()
 def addE5Actions(self, actions, type):
 """
 Public method to add actions to the list of actions.
 if type == 'ui':
 self.actions.extend(actions)
 elif type == 'wizards':
 self.wizardsActions.extend(actions)
-def removeE5Actions(self, actions, type = 'ui'):
+def removeE5Actions(self, actions, type='ui'):
 """
 Public method to remove actions from the list of actions.
 @param type string denoting the action set to get.
 It must be one of "ui" or "wizards".
 def getMenuAction(self, menuName, actionName):
 """
 Public method to get a reference to an action of a menu.
 @param menuName name of the menu to search in (string)
 @param actionName object name of the action to search for
 (string)
 """
 try:
 menu = self.__menus[menuName]
 except KeyError:
 Private method to restart the application.
 """
 res = E5MessageBox.yesNo(self,
 self.trUtf8("Restart application"),
 self.trUtf8("""The application needs to be restarted. Do it now?"""),
-yesDefault = True)
+yesDefault=True)
 if res and self.__shutdown():
 e5App().closeAllWindows()
 program = sys.executable
 eric5 = os.path.join(getConfig("ericDir"), "eric5.py")
 self.__menus["tools"].addMenu(self.toolGroupsMenu)
 act = self.__menus["tools"].addAction(self.trUtf8("Configure Tool Groups ..."),
 self.__toolGroupsConfiguration)
 act.setData(-1)
 act = self.__menus["tools"].addAction(
 self.trUtf8("Configure current Tool Group ..."),
 self.__toolsConfiguration)
 act.setData(-2)
 self.__menus["tools"].addSeparator()
 if self.currentToolGroup == -1:
 elif self.layout == "Sidebars":
 self.profiles[self.currentProfile][5][0] = self.leftSidebar.isVisible()
 self.profiles[self.currentProfile][5][1] = self.bottomSidebar.isVisible()
 Preferences.setUI("ViewProfiles", self.profiles)
-def __activateViewProfile(self, name, save = True):
+def __activateViewProfile(self, name, save=True):
 """
 Private slot to activate a view profile.
 @param name name of the profile to be activated (string)
 @param save flag indicating that the current profile should
 if self.__menus["toolbars"].isTearOffMenuVisible():
 self.__showToolbarsMenu()
 if self.__menus["window"].isTearOffMenuVisible():
 self.__showWindowMenu()
-def __setEditProfile(self, save = True):
+def __setEditProfile(self, save=True):
 """
 Private slot to activate the edit view profile.
 @param save flag indicating that the current profile should
 be saved (boolean)
 self.hToolbox.setCurrentWidget(self.shell)
 elif self.layout == "Sidebars":
 if not self.embeddedShell:
 self.bottomSidebar.setCurrentWidget(self.shell)
-def setDebugProfile(self, save = True):
+def setDebugProfile(self, save=True):
 """
 Public slot to activate the debug view profile.
 @param save flag indicating that the current profile should
 be saved (boolean)
 elif self.layout == "Sidebars":
 self.leftSidebar.show()
 self.leftSidebar.setCurrentWidget(self.browser)
 else:
 self.browser.show()
-elif self.embeddedFileBrowser == 1: # embedded in debug browser
+elif self.embeddedFileBrowser == 1:  # embedded in debug browser
 if self.layout in ["DockWindows", "Toolboxes", "Sidebars"]:
 self.debugViewerDock.show()
 self.debugViewerDock.raise_()
 else:
 self.debugViewer.show()
 Private slot for displaying the unittest dialog.
 """
 self.unittestDialog.show()
 self.unittestDialog.raise_()
-def __unittestScript(self, prog = None):
+def __unittestScript(self, prog=None):
 """
 Private slot for displaying the unittest dialog and run the current script.
 @param prog the python program to be opened
 """
 """
 self.unittestDialog.show()
 self.unittestDialog.raise_()
 self.unittestDialog.on_startButton_clicked()
-def __designer(self, fn = None, version = 0):
+def __designer(self, fn=None, version=0):
 """
 Private slot to start the Qt-Designer executable.
 @param fn filename of the form to be opened
 @param version indication for the requested version (Qt 4) (integer)
 """
 if fn is not None and version == 0:
 # determine version from file, if not specified
 try:
-f = open(fn, "r", encoding = "utf-8")
+f = open(fn, "r", encoding="utf-8")
 found = False
 while not found:
 uiLine = f.readline()
 found = uiLine.lower().startswith("<ui ")
 f.close()
 def __designer4(self):
 """
 Private slot to start the Qt-Designer 4 executable.
 """
-self.__designer(version = 4)
+self.__designer(version=4)
-def __linguist(self, fn = None, version = 0):
+def __linguist(self, fn=None, version=0):
 """
 Private slot to start the Qt-Linguist executable.
 @param fn filename of the translation file to be opened
 @param version indication for the requested version (Qt 4) (integer)
 self.trUtf8(
 '<p>Could not start Qt-Linguist.<br>'
 'Ensure that it is available as <b>{0}</b>.</p>'
 ).format(linguist))
-def __linguist4(self, fn = None):
+def __linguist4(self, fn=None):
 """
 Private slot to start the Qt-Linguist 4 executable.
 @param fn filename of the translation file to be opened
 """
-self.__linguist(fn, version = 4)
+self.__linguist(fn, version=4)
-def __assistant(self, home = None, version = 0):
+def __assistant(self, home=None, version=0):
 """
 Private slot to start the Qt-Assistant executable.
 @param home full pathname of a file to display (string)
 @param version indication for the requested version (Qt 4) (integer)
 def __assistant4(self):
 """
 Private slot to start the Qt-Assistant 4 executable.
 """
-self.__assistant(version = 4)
+self.__assistant(version=4)
-def __startWebBrowser(self, home = ""):
+def __startWebBrowser(self, home=""):
 """
 Private slot to start the eric5 web browser.
 @param home full pathname of a file to display (string)
 """
 self.launchHelpViewer(home)
-def __customViewer(self, home = None):
+def __customViewer(self, home=None):
 """
 Private slot to start a custom viewer.
 @param home full pathname of a file to display (string)
 """
 self.trUtf8(
 '<p>Could not start the help viewer.<br>'
 'Ensure that it is available as <b>hh</b>.</p>'
 ))
-def __UIPreviewer(self,fn=None):
+def __UIPreviewer(self, fn=None):
 """
 Private slot to start the UI Previewer executable.
 @param fn filename of the form to be previewed (string)
 """
 self.trUtf8(
 '<p>Could not start UI Previewer.<br>'
 'Ensure that it is available as <b>{0}</b>.</p>'
 ).format(viewer))
-def __TRPreviewer(self, fileNames = None, ignore = False):
+def __TRPreviewer(self, fileNames=None, ignore=False):
 """
 Private slot to start the Translation Previewer executable.
 @param fileNames filenames of forms and/or translations to be previewed
 (list of strings)
 self.trUtf8(
 '<p>Could not start SQL Browser.<br>'
 'Ensure that it is available as <b>{0}</b>.</p>'
 ).format(browser))
-def __editPixmap(self, fn = ""):
+def __editPixmap(self, fn=""):
 """
 Private slot to show a pixmap in a dialog.
 @param fn filename of the file to show (string)
 """
-dlg = IconEditorWindow(fn, self, fromEric = True)
+dlg = IconEditorWindow(fn, self, fromEric=True)
 dlg.show()
 def __showPixmap(self, fn):
 """
 Private slot to show a pixmap in a dialog.
 # loop through all running tool processes
 for program, toolProc, toolProcData in self.toolProcs:
 toolProc.setReadChannel(QProcess.StandardOutput)
 if toolProcData[0] is None or \
 toolProcData[1] not in ["insert", "replaceSelection"]:
 # not connected to an editor or wrong mode
 while toolProc.canReadLine():
 s = "{0} - ".format(program)
 output = str(toolProc.readLine(), ioEncoding, 'replace')
 s.append(output)
 Private slot to show the Python 3 documentation.
 """
 pythonDocDir = Preferences.getHelp("PythonDocDir")
 if not pythonDocDir:
 if Utilities.isWindowsPlatform():
 pythonDocDir = Utilities.getEnvironmentEntry("PYTHON3DOCDIR",
 os.path.join(os.path.dirname(sys.executable), "doc"))
 else:
 pythonDocDir = Utilities.getEnvironmentEntry("PYTHON3DOCDIR",
 '/usr/share/doc/packages/python/html')
 if not pythonDocDir.startswith("http://") and \
 not pythonDocDir.startswith("https://"):
 if pythonDocDir.startswith("file://"):
 pythonDocDir = pythonDocDir[7:]
 else:
 hvType = Preferences.getHelp("HelpViewerType")
 if hvType == 1:
 self.launchHelpViewer(home)
 elif hvType == 2:
-self.__assistant(home, version = 4)
+self.__assistant(home, version=4)
 elif hvType == 3:
 self.__webBrowser(home)
 else:
 self.__customViewer(home)
 default = os.path.join(os.path.dirname(executable), "doc")
 else:
 default = ""
 pythonDocDir = Utilities.getEnvironmentEntry("PYTHON2DOCDIR", default)
 else:
 pythonDocDir = Utilities.getEnvironmentEntry("PYTHON3DOCDIR",
 '/usr/share/doc/packages/python/html/python-docs-html')
 if not pythonDocDir.startswith("http://") and \
 not pythonDocDir.startswith("https://"):
 if pythonDocDir.startswith("file://"):
 pythonDocDir = pythonDocDir[7:]
 else:
 hvType = Preferences.getHelp("HelpViewerType")
 if hvType == 1:
 self.launchHelpViewer(home)
 elif hvType == 2:
-self.__assistant(home, version = 4)
+self.__assistant(home, version=4)
 elif hvType == 3:
 self.__webBrowser(home)
 else:
 self.__customViewer(home)
 hvType = Preferences.getHelp("HelpViewerType")
 if hvType == 1:
 self.launchHelpViewer(home)
 elif hvType == 2:
-self.__assistant(home, version = 4)
+self.__assistant(home, version=4)
 elif hvType == 3:
 self.__webBrowser(home)
 else:
 self.__customViewer(home)
 hvType = Preferences.getHelp("HelpViewerType")
 if hvType == 1:
 self.launchHelpViewer(home)
 elif hvType == 2:
-self.__assistant(home, version = 4)
+self.__assistant(home, version=4)
 elif hvType == 3:
 self.__webBrowser(home)
 else:
 self.__customViewer(home)
 hvType = Preferences.getHelp("HelpViewerType")
 if hvType == 1:
 self.launchHelpViewer(home)
 elif hvType == 2:
-self.__assistant(home, version = 4)
+self.__assistant(home, version=4)
 elif hvType == 3:
 self.__webBrowser(home)
 else:
 self.__customViewer(home)
 hvType = Preferences.getHelp("HelpViewerType")
 if hvType == 1:
 self.launchHelpViewer(home)
 elif hvType == 2:
-self.__assistant(home, version = 4)
+self.__assistant(home, version=4)
 elif hvType == 3:
 self.__webBrowser(home)
 else:
 self.__customViewer(home)
-def launchHelpViewer(self, home, searchWord = None):
+def launchHelpViewer(self, home, searchWord=None):
 """
 Public slot to start the help viewer.
 @param home filename of file to be shown (string)
 @keyparam searchWord word to search for (string)
 if len(home) > 0:
 homeUrl = QUrl(home)
 if not homeUrl.scheme():
 home = QUrl.fromLocalFile(home).toString()
 if not Preferences.getHelp("SingleHelpWindow") or self.helpWindow is None:
 help = HelpWindow(home, '.', None, 'help viewer', True,
-searchWord = searchWord)
+searchWord=searchWord)
 if QApplication.desktop().width() > 400 and \
 QApplication.desktop().height() > 500:
 help.show()
 else:
 """
 searchWord = self.viewmanager.textForFind(False)
 if searchWord == "":
 searchWord = None
-self.launchHelpViewer("", searchWord = searchWord)
+self.launchHelpViewer("", searchWord=searchWord)
 def __webBrowser(self):
 """
 Private slot to start the eric5 web browser.
 """
 self.launchHelpViewer("")
-def showPreferences(self, pageName = None):
+def showPreferences(self, pageName=None):
 """
 Public slot to set the preferences.
 @param pageName name of the configuration page to show (string)
 """
 self.SAServer = None
 self.maxEditorPathLen = Preferences.getUI("CaptionFilenameLength")
 self.captionShowsFilename = Preferences.getUI("CaptionShowsFilename")
 if not self.captionShowsFilename:
-self.__setWindowCaption(editor = "")
+self.__setWindowCaption(editor="")
 else:
 aw = self.viewmanager.activeWindow()
 fn = aw and aw.getFileName() or None
 if fn:
-self.__setWindowCaption(editor = fn)
+self.__setWindowCaption(editor=fn)
 else:
-self.__setWindowCaption(editor = "")
+self.__setWindowCaption(editor="")
 self.__httpAlternatives = Preferences.getUI("VersionsUrls5")
 self.performVersionCheck(False)
 self.__configureDockareaCornerUsage()
 def __newProject(self):
 """
 Private slot to handle the NewProject signal.
 """
-self.__setWindowCaption(project = self.project.name)
+self.__setWindowCaption(project=self.project.name)
 def __projectOpened(self):
 """
 Private slot to handle the projectOpened signal.
 """
-self.__setWindowCaption(project = self.project.name)
+self.__setWindowCaption(project=self.project.name)
 cap = e5App().getObject("DebugServer")\
 .getClientCapabilities(self.project.pdata["PROGLANGUAGE"][0])
 self.utProjectAct.setEnabled(cap & HasUnittest)
 self.utProjectOpen = cap & HasUnittest
 def __projectClosed(self):
 """
 Private slot to handle the projectClosed signal.
 """
-self.__setWindowCaption(project = "")
+self.__setWindowCaption(project="")
 self.utProjectAct.setEnabled(False)
 if not self.utEditorOpen:
 self.utRestartAct.setEnabled(False)
 self.utProjectOpen = False
 self.wizardsMenuAct.setEnabled(False)
 self.utScriptAct.setEnabled(False)
 self.utEditorOpen = False
 if not self.utProjectOpen:
 self.utRestartAct.setEnabled(False)
-self.__setWindowCaption(editor = "")
+self.__setWindowCaption(editor="")
 def __editorOpened(self, fn):
 """
 Private slot to handle the editorOpened signal.
 fn = os.path.join(Utilities.getConfigDir(), "eric5tasks.e4t")
 if not os.path.exists(fn):
 return
 f = QFile(fn)
 if f.open(QIODevice.ReadOnly):
-reader = TasksReader(f, viewer = self.taskViewer)
+reader = TasksReader(f, viewer=self.taskViewer)
 reader.readXML()
 f.close()
 else:
 E5MessageBox.critical(self,
 self.trUtf8("Read tasks"),
 Private slot to show the plugin info dialog.
 """
 self.__pluginInfoDialog = PluginInfoDialog(self.pluginManager, self)
 self.__pluginInfoDialog.show()
-def __installPlugins(self, pluginFileNames = []):
+def __installPlugins(self, pluginFileNames=[]):
 """
 Private slot to show a dialog to install a new plugin.
 @param pluginFileNames list of plugin files suggested for
 installation list of strings
 """
 dlg = PluginInstallDialog(self.pluginManager, pluginFileNames, self)
 dlg.exec_()
 if dlg.restartNeeded():
 windows = {
 "ProjectBrowser": self.projectBrowser,
 "DebugViewer": self.debugViewer,
 "LogViewer": self.logViewer,
 "Shell": self.shell,
-"FileBrowser" : self.browser,
+"FileBrowser": self.browser,
-"TaskViewer" : self.taskViewer,
+"TaskViewer": self.taskViewer,
-"TemplateViewer" : self.templateViewer,
+"TemplateViewer": self.templateViewer,
 "MultiProjectBrowser": self.multiProjectBrowser,
 }
 if self.embeddedShell:
 del windows["Shell"]
 if self.embeddedFileBrowser:
 def showAvailableVersionsInfo(self):
 """
 Public method to show the eric5 versions available for download.
 """
-self.performVersionCheck(manual = True, showVersions = True)
+self.performVersionCheck(manual=True, showVersions=True)
-def performVersionCheck(self, manual = True,  alternative = 0, showVersions = False):
+def performVersionCheck(self, manual=True,  alternative=0, showVersions=False):
 """
 Public method to check the internet for an eric5 update.
 @param manual flag indicating an invocation via the menu (boolean)
 @param alternative index of server to download from (integer)
 url = QUrl(self.__httpAlternatives[alternative])
 self.__versionCheckCanceled = False
 if manual:
 if self.__versionCheckProgress is None:
 self.__versionCheckProgress = \
 QProgressDialog("", self.trUtf8("&Cancel"),
 0,  len(self.__httpAlternatives),  self)
 self.__versionCheckProgress.setMinimumDuration(0)
 self.__versionCheckProgress.canceled.connect(
 self.__versionsDownloadCanceled)
 self.__versionCheckProgress.setLabelText(
 E5MessageBox.warning(self,
 self.trUtf8("Error downloading versions file"),
 self.trUtf8("""Could not download the versions file."""))
 return
 else:
 self.performVersionCheck(self.manualUpdatesCheck, self.httpAlternative,
 self.showAvailableVersions)
 return
 self.__inVersionCheck = False
 if self.__versionCheckProgress is not None:
 res = E5MessageBox.yesNo(self,
 self.trUtf8("Update available"),
 self.trUtf8("""The update to <b>{0}</b> of eric5 is available"""
 """ at <b>{1}</b>. Would you like to get it?""")\
 .format(versions[2], versions[3]),
-yesDefault = True)
+yesDefault=True)
 url = res and versions[3] or ''
 elif versions[0] > Version:
 res = E5MessageBox.yesNo(self,
 self.trUtf8("Update available"),
 self.trUtf8("""The update to <b>{0}</b> of eric5 is available"""
 """ at <b>{1}</b>. Would you like to get it?""")\
 .format(versions[0], versions[1]),
-yesDefault = True)
+yesDefault=True)
 url = res and versions[1] or ''
 else:
 if self.manualUpdatesCheck:
 E5MessageBox.information(self,
 self.trUtf8("Eric5 is up to date"),
 res = E5MessageBox.yesNo(self,
 self.trUtf8("Update available"),
 self.trUtf8("""The update to <b>{0}</b> of eric5 is available"""
 """ at <b>{1}</b>. Would you like to get it?""")\
 .format(versions[0], versions[1]),
-yesDefault = True)
+yesDefault=True)
 url = res and versions[1] or ''
 else:
 if self.manualUpdatesCheck:
 E5MessageBox.information(self,
 self.trUtf8("Eric5 is up to date"),
 while line < len(versions):
 if versions[line] == "---":
 break
 versionText += """<tr><td>{0}</td><td><a href="{1}">{2}</a></td></tr>"""\
 .format(versions[line], versions[line + 1],
 'sourceforge' in versions[line + 1] and \
 "SourceForge" or versions[line + 1])
 line += 2
 versionText += self.trUtf8("""</table>""")
 self.trUtf8("SSL Errors"),
 self.trUtf8("""<p>SSL Errors:</p>"""
 """<p>{0}</p>"""
 """<p>Do you want to ignore these errors?</p>""")\
 .format(errorString),
-icon = E5MessageBox.Warning)
+icon=E5MessageBox.Warning)
 if ret:
 reply.ignoreSslErrors()
 else:
 self.__downloadCancelled = True
 reply.abort()
 ## Below are methods for various checks
 #######################################
 def checkConfigurationStatus(self):
 """
 Public method to check, if eric5 has been configured. If it is not,
 the configuration dialog is shown.
 """
 if not Preferences.isConfigured():
 self.__initDebugToolbarsLayout()
 self.trUtf8("First time usage"),
 self.trUtf8("""eric5 has not been configured yet. """
 """The configuration dialog will be started."""))
 self.showPreferences()
-def versionIsNewer(self, required, snapshot = None):
+def versionIsNewer(self, required, snapshot=None):
 """
 Public method to check, if the eric5 version is good compared to
 the required version.
 @param required required version (string)

Mercurial Repositories > eric / file comparison

comparison: UI/UserInterface.py

UI/UserInterface.py