eric: comparison eric6/UI/UserInterface.py

-:babe80d84a3e
+:7eb04391adf7
 """
 Module implementing the main user interface.
 """
-from __future__ import unicode_literals
-try:
-str = unicode       # __IGNORE_EXCEPTION__
-except NameError:
-pass
 import os
 import sys
 import logging
-from PyQt5.QtCore import pyqtSlot, QTimer, QFile, QFileInfo, pyqtSignal, \
+from PyQt5.QtCore import (
-PYQT_VERSION_STR, QDate, QIODevice, qVersion, QProcess, QSize, QUrl, \
+pyqtSlot, QTimer, QFile, QFileInfo, pyqtSignal, PYQT_VERSION_STR, QDate,
-QObject, Qt, QUuid, QThread
+QIODevice, qVersion, QProcess, QSize, QUrl, QObject, Qt, QUuid, QThread,
+QUrlQuery
+)
 from PyQt5.QtGui import QKeySequence, QDesktopServices
-from PyQt5.QtWidgets import QSizePolicy, QWidget, QWhatsThis, QToolBar, \
+from PyQt5.QtWidgets import (
-QDialog, QSplitter, QApplication, QMenu, QVBoxLayout, QDockWidget, \
+QSizePolicy, QWidget, QWhatsThis, QToolBar, QDialog, QSplitter,
-QAction, QLabel
+QApplication, QMenu, QVBoxLayout, QDockWidget, QAction, QLabel
+)
 from PyQt5.Qsci import QSCINTILLA_VERSION_STR
-from PyQt5.QtNetwork import QNetworkProxyFactory, QNetworkAccessManager, \
+from PyQt5.QtNetwork import (
-QNetworkRequest, QNetworkReply
+QNetworkProxyFactory, QNetworkAccessManager, QNetworkRequest, QNetworkReply
+)
 from .Info import Version, VersionOnly, BugAddress, Program, FeatureAddress
 from . import Config
 from E5Gui.E5SingleApplication import E5SingleApplicationServer
 import Utilities
 import UI.PixmapCache
 from E5Network.E5NetworkIcon import E5NetworkIcon
-from E5Network.E5NetworkProxyFactory import E5NetworkProxyFactory, \
+from E5Network.E5NetworkProxyFactory import (
-proxyAuthenticationRequired
+E5NetworkProxyFactory, proxyAuthenticationRequired
+)
 try:
 from E5Network.E5SslErrorHandler import E5SslErrorHandler
 SSL_AVAILABLE = True
 except ImportError:
 SSL_AVAILABLE = False
 from eric6config import getConfig
-from Globals import qVersionTuple
 class Redirector(QObject):
 """
 Helper class used to redirect stdout and stderr to the log window.
 self.pluginManager.activatePlugins()
 splash.showMessage(self.tr("Generating Plugins Toolbars..."))
 self.pluginManager.initPluginToolbars(self.toolbarManager)
 if Preferences.getPluginManager("StartupCleanup"):
 splash.showMessage(self.tr("Cleaning Plugins Download Area..."))
-from PluginManager.PluginRepositoryDialog import \
+from PluginManager.PluginRepositoryDialog import (
 PluginRepositoryDownloadCleanup
+)
 PluginRepositoryDownloadCleanup(quiet=True)
 # now read the keyboard shortcuts for all the actions
 from Preferences import Shortcuts
 Shortcuts.readShortcuts()
 @exception ValueError raised to indicate an invalid layout type
 """
 # Create the view manager depending on the configuration setting
 logging.debug("Creating Viewmanager...")
 import ViewManager
-self.viewmanager = \
+self.viewmanager = ViewManager.factory(
-ViewManager.factory(self, self, debugServer, self.pluginManager)
+self, self, debugServer, self.pluginManager)
 leftWidget = QWidget()
 layout = QVBoxLayout()
 layout.setContentsMargins(1, 1, 1, 1)
 layout.setSpacing(1)
 layout.addWidget(self.viewmanager.mainWidget())
 elif self.__shellPosition == "right":
 self.__shellParent = self.rToolboxDock
 else:
 self.__shellParent = self.hToolboxDock
 from QScintilla.Shell import ShellAssembly
-self.shellAssembly = \
+self.shellAssembly = ShellAssembly(
-ShellAssembly(debugServer, self.viewmanager, self.project, True)
+debugServer, self.viewmanager, self.project, True)
 self.shell = self.shellAssembly.shell()
 self.__shellParent.widget().insertItem(
 0, self.shellAssembly, UI.PixmapCache.getIcon("shell.png"),
 self.tr("Shell"))
 elif self.__shellPosition == "right":
 self.__shellParent = self.rightSidebar
 else:
 self.__shellParent = self.bottomSidebar
 from QScintilla.Shell import ShellAssembly
-self.shellAssembly = \
+self.shellAssembly = ShellAssembly(
-ShellAssembly(debugServer, self.viewmanager, self.project, True)
+debugServer, self.viewmanager, self.project, True)
 self.shell = self.shellAssembly.shell()
 self.__shellParent.insertTab(0, self.shellAssembly,
 UI.PixmapCache.getIcon("shell.png"),
 self.tr("Shell"))
 @param editor filename to be displayed (string)
 @param project project name to be displayed (string)
 """
 if editor is not None and self.captionShowsFilename:
-self.capEditor = \
+self.capEditor = Utilities.compactPath(editor, self.maxFilePathLen)
-Utilities.compactPath(editor, self.maxFilePathLen)
 if project is not None:
 self.capProject = project
 if self.passiveMode:
 if not self.capProject and not self.capEditor:
 self.condaWidgetActivateAct.triggered.connect(
 self.__activateCondaWidget)
 self.actions.append(self.condaWidgetActivateAct)
 self.addAction(self.condaWidgetActivateAct)
-# TODO: add action for "MicroPython", Ctrl+Alt+Shift+M
 if self.microPythonWidget is not None:
 self.microPythonWidgetActivateAct = E5Action(
 self.tr('MicroPython'),
 self.tr('MicroPython'),
 QKeySequence(self.tr("Ctrl+Alt+Shift+M")),
 """ with a word selected, this word is search in the Qt help"""
 """ collection.</p>"""
 ))
 self.helpviewerAct.triggered.connect(self.__helpViewer)
 self.actions.append(self.helpviewerAct)
-##        else:
-##            self.helpviewerAct = None
 self.__initQtDocActions()
 self.__initPythonDocActions()
 self.__initEricDocAction()
 self.__initPySideDocActions()
 self.pyqt4DocAct.triggered.connect(self.__showPyQt4Doc)
 self.actions.append(self.pyqt4DocAct)
 except ImportError:
 self.pyqt4DocAct = None
-try:
+self.pyqt5DocAct = E5Action(
-import PyQt5        # __IGNORE_WARNING__
+self.tr('PyQt5 Documentation'),
-self.pyqt5DocAct = E5Action(
+self.tr('PyQt&5 Documentation'),
-self.tr('PyQt5 Documentation'),
+0, 0, self, 'pyqt5_documentation')
-self.tr('PyQt&5 Documentation'),
+self.pyqt5DocAct.setStatusTip(self.tr(
-0, 0, self, 'pyqt5_documentation')
+'Open PyQt5 Documentation'))
-self.pyqt5DocAct.setStatusTip(self.tr(
+self.pyqt5DocAct.setWhatsThis(self.tr(
-'Open PyQt5 Documentation'))
+"""<b>PyQt5 Documentation</b>"""
-self.pyqt5DocAct.setWhatsThis(self.tr(
+"""<p>Display the PyQt5 Documentation. Dependent upon your"""
-"""<b>PyQt5 Documentation</b>"""
+""" settings, this will either show the help in Eric's"""
-"""<p>Display the PyQt5 Documentation. Dependent upon your"""
+""" internal help viewer/web browser, or execute a web"""
-""" settings, this will either show the help in Eric's"""
+""" browser or Qt Assistant. </p>"""
-""" internal help viewer/web browser, or execute a web"""
+))
-""" browser or Qt Assistant. </p>"""
+self.pyqt5DocAct.triggered.connect(self.__showPyQt5Doc)
-))
+self.actions.append(self.pyqt5DocAct)
-self.pyqt5DocAct.triggered.connect(self.__showPyQt5Doc)
-self.actions.append(self.pyqt5DocAct)
-except ImportError:
-self.pyqt5DocAct = None
 def __initPythonDocActions(self):
 """
 Private slot to initialize the actions to show the Python
 documentation.
 """
 Private slot to create the menus.
 """
 self.__menus = {}
 mb = self.menuBar()
-if Utilities.isLinuxPlatform() and \
+if (
-not Preferences.getUI("UseNativeMenuBar"):
+Utilities.isLinuxPlatform() and
+not Preferences.getUI("UseNativeMenuBar")
+):
 mb.setNativeMenuBar(False)
 ##############################################################
 ## File menu
 ##############################################################
 ##############################################################
 ## Project menu
 ##############################################################
-self.__menus["project"], self.__menus["project_tools"] = \
+self.__menus["project"], self.__menus["project_tools"] = (
 self.project.initMenus()
+)
 mb.addMenu(self.__menus["project"])
 mb.addMenu(self.__menus["project_tools"])
 ##############################################################
 ## Start and Debug menus
 ##############################################################
-self.__menus["start"], self.__menus["debug"] = \
+self.__menus["start"], self.__menus["debug"] = (
 self.debuggerUI.initMenus()
+)
 mb.addMenu(self.__menus["start"])
 mb.addMenu(self.__menus["debug"])
 ##############################################################
 ## Extras menu
 self.__menus["subwindow"] = QMenu(self.tr("&Windows"),
 self.__menus["window"])
 self.__menus["subwindow"].setTearOffEnabled(True)
 # central park
-try:
+self.__menus["subwindow"].addSection(self.tr("Central Park"))
-self.__menus["subwindow"].addSection(self.tr("Central Park"))
-except AttributeError:
-# Qt4
-self.__menus["subwindow"].addSeparator()
 self.__menus["subwindow"].addAction(self.viewmanagerActivateAct)
 # left side
-try:
+self.__menus["subwindow"].addSection(self.tr("Left Side"))
-self.__menus["subwindow"].addSection(self.tr("Left Side"))
-except AttributeError:
-# Qt4
-pass
 if self.__shellPosition == "left":
 self.__menus["subwindow"].addAction(self.shellActivateAct)
 self.__menus["subwindow"].addAction(self.pbActivateAct)
 self.__menus["subwindow"].addAction(self.mpbActivateAct)
 if self.templateViewer is not None:
 if self.browser is not None:
 self.__menus["subwindow"].addAction(self.browserActivateAct)
 if self.symbolsViewer is not None:
 self.__menus["subwindow"].addAction(self.symbolsViewerActivateAct)
 # bottom side
-try:
+self.__menus["subwindow"].addSection(self.tr("Bottom Side"))
-self.__menus["subwindow"].addSection(self.tr("Bottom Side"))
-except AttributeError:
-# Qt4
-self.__menus["subwindow"].addSeparator()
 if self.__shellPosition == "bottom":
 self.__menus["subwindow"].addAction(self.shellActivateAct)
 self.__menus["subwindow"].addAction(self.taskViewerActivateAct)
 self.__menus["subwindow"].addAction(self.logViewerActivateAct)
 if self.numbersViewer is not None:
 self.__menus["subwindow"].addAction(self.numbersViewerActivateAct)
-try:
+self.__menus["subwindow"].addSection(self.tr("Right Side"))
-self.__menus["subwindow"].addSection(self.tr("Right Side"))
-except AttributeError:
-# Qt4
-self.__menus["subwindow"].addSeparator()
 # right side
 if self.__shellPosition == "right":
 self.__menus["subwindow"].addAction(self.shellActivateAct)
 if self.codeDocumentationViewer is not None:
 self.__menus["subwindow"].addAction(
 if self.irc is not None:
 self.__menus["subwindow"].addAction(self.ircActivateAct)
 if self.microPythonWidget is not None:
 self.__menus["subwindow"].addAction(
 self.microPythonWidgetActivateAct)
-try:
+self.__menus["subwindow"].addSection(self.tr("Plug-ins"))
-self.__menus["subwindow"].addSection(self.tr("Plug-ins"))
-except AttributeError:
-# Qt4
-self.__menus["subwindow"].addSeparator()
 ##############################################################
 ## Window/Toolbars menu
 ##############################################################
-self.__menus["toolbars"] = \
+self.__menus["toolbars"] = QMenu(
-QMenu(self.tr("&Toolbars"), self.__menus["window"])
+self.tr("&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
 sizeStr = "32-Bit"
 versionText = self.tr(
 """<h3>Version Numbers</h3>"""
 """<table>""")
-versionText += """<tr><td><b>Python</b></td><td>{0}, {1}</td></tr>"""\
+versionText += (
-.format(sys.version.split()[0], sizeStr)
+"""<tr><td><b>Python</b></td><td>{0}, {1}</td></tr>"""
-versionText += """<tr><td><b>Qt</b></td><td>{0}</td></tr>"""\
+).format(sys.version.split()[0], sizeStr)
-.format(qVersion())
+versionText += (
-versionText += """<tr><td><b>PyQt</b></td><td>{0}</td></tr>"""\
+"""<tr><td><b>Qt</b></td><td>{0}</td></tr>"""
-.format(PYQT_VERSION_STR)
+).format(qVersion())
-versionText += """<tr><td><b>sip</b></td><td>{0}</td></tr>"""\
+versionText += (
-.format(sip_version_str)
+"""<tr><td><b>PyQt</b></td><td>{0}</td></tr>"""
-versionText += """<tr><td><b>QScintilla</b></td><td>{0}</td></tr>"""\
+).format(PYQT_VERSION_STR)
-.format(QSCINTILLA_VERSION_STR)
+versionText += (
+"""<tr><td><b>sip</b></td><td>{0}</td></tr>"""
+).format(sip_version_str)
+versionText += (
+"""<tr><td><b>QScintilla</b></td><td>{0}</td></tr>"""
+).format(QSCINTILLA_VERSION_STR)
 try:
 from WebBrowser.Tools import WebBrowserTools
 chromeVersion = WebBrowserTools.getWebEngineVersions()[0]
-versionText += \
+versionText += (
-"""<tr><td><b>WebEngine</b></td><td>{0}</td></tr>"""\
+"""<tr><td><b>WebEngine</b></td><td>{0}</td></tr>"""
-.format(chromeVersion)
+).format(chromeVersion)
 except ImportError:
 pass
-try:
+versionText += ("""<tr><td><b>{0}</b></td><td>{1}</td></tr>"""
-from PyQt5.QtWebKit import qWebKitVersion
+).format(Program, Version)
-versionText += """<tr><td><b>WebKit</b></td><td>{0}</td></tr>"""\
-.format(qWebKitVersion())
-except ImportError:
-pass
-versionText += """<tr><td><b>{0}</b></td><td>{1}</td></tr>"""\
-.format(Program, Version)
 versionText += self.tr("""</table>""")
 E5MessageBox.about(self, Program, versionText)
 def __reportBug(self):
 Utilities.generateVersionInfo("\r\n"),
 Utilities.generatePluginsVersionInfo("\r\n"),
 Utilities.generateDistroInfo("\r\n"))
 url = QUrl("mailto:{0}".format(address))
-if qVersionTuple() >= (5, 0, 0):
+urlQuery = QUrlQuery(url)
-from PyQt5.QtCore import QUrlQuery
+urlQuery.addQueryItem("subject", subject)
-urlQuery = QUrlQuery(url)
+urlQuery.addQueryItem("body", body)
-urlQuery.addQueryItem("subject", subject)
+url.setQuery(urlQuery)
-urlQuery.addQueryItem("body", body)
-url.setQuery(urlQuery)
-else:
-url.addQueryItem("subject", subject)
-url.addQueryItem("body", body)
 QDesktopServices.openUrl(url)
 def checkForErrorLog(self):
 """
 Public method to check for the presence of an error log and ask the
 self.profiles[self.currentProfile][2][4] = state
 state = self.rightSidebar.saveState()
 self.profiles[self.currentProfile][2][5] = state
 # step 2: save the visibility of the windows of the active profile
 if self.__layoutType == "Toolboxes":
-self.profiles[self.currentProfile][1][0] = \
+self.profiles[self.currentProfile][1][0] = (
 self.lToolboxDock.isVisible()
-self.profiles[self.currentProfile][1][1] = \
+)
+self.profiles[self.currentProfile][1][1] = (
 self.hToolboxDock.isVisible()
-self.profiles[self.currentProfile][1][2] = \
+)
+self.profiles[self.currentProfile][1][2] = (
 self.rToolboxDock.isVisible()
+)
 elif self.__layoutType == "Sidebars":
-self.profiles[self.currentProfile][1][0] = \
+self.profiles[self.currentProfile][1][0] = (
 self.leftSidebar.isVisible()
-self.profiles[self.currentProfile][1][1] = \
+)
+self.profiles[self.currentProfile][1][1] = (
 self.bottomSidebar.isVisible()
-self.profiles[self.currentProfile][1][2] = \
+)
+self.profiles[self.currentProfile][1][2] = (
 self.rightSidebar.isVisible()
+)
 Preferences.setUI("ViewProfiles2", self.profiles)
 def __activateViewProfile(self, name, save=True):
 """
 Private slot to activate a view profile.
 def __toolGroupsConfiguration(self):
 """
 Private slot to handle the tool groups configuration menu entry.
 """
-from Preferences.ToolGroupConfigurationDialog import \
+from Preferences.ToolGroupConfigurationDialog import (
 ToolGroupConfigurationDialog
+)
 dlg = ToolGroupConfigurationDialog(
 self.toolGroups, self.currentToolGroup, self)
 if dlg.exec_() == QDialog.Accepted:
 self.toolGroups, self.currentToolGroup = dlg.getToolGroups()
 args = []
 if fn is not None:
 fn = fn.replace('.qm', '.ts')
 try:
-if os.path.isfile(fn) and os.path.getsize(fn) and \
+if (
-fn not in args:
+os.path.isfile(fn) and
+os.path.getsize(fn) and
+fn not in args
+):
 args.append(fn)
 else:
 E5MessageBox.critical(
 self,
 self.tr('Problem'),
 '<p>The file <b>{0}</b> does not exist or'
 ' is zero length.</p>')
 .format(fn))
 return
-if not os.path.isfile(viewer) or \
+if (
-not proc.startDetached(sys.executable, args):
+not os.path.isfile(viewer) or
+not proc.startDetached(sys.executable, args)
+):
 E5MessageBox.critical(
 self,
 self.tr('Process Generation Error'),
 self.tr(
 '<p>Could not start UI Previewer.<br>'
 '<p>The file <b>{0}</b> does not exist or'
 ' is zero length.</p>')
 .format(fn))
 return
-if not os.path.isfile(viewer) or \
+if (
-not proc.startDetached(sys.executable, args):
+not os.path.isfile(viewer) or
+not proc.startDetached(sys.executable, args)
+):
 E5MessageBox.critical(
 self,
 self.tr('Process Generation Error'),
 self.tr(
 '<p>Could not start Translation Previewer.<br>'
 browser = os.path.join(getConfig("ericDir"), "eric6_sqlbrowser.py")
 args = []
 args.append(browser)
-if not os.path.isfile(browser) or \
+if (
-not proc.startDetached(sys.executable, args):
+not os.path.isfile(browser) or
+not proc.startDetached(sys.executable, args)
+):
 E5MessageBox.critical(
 self,
 self.tr('Process Generation Error'),
 self.tr(
 '<p>Could not start SQL Browser.<br>'
 snap = os.path.join(getConfig("ericDir"), "eric6_snap.py")
 args = []
 args.append(snap)
-if not os.path.isfile(snap) or \
+if (
-not proc.startDetached(sys.executable, args):
+not os.path.isfile(snap) or
+not proc.startDetached(sys.executable, args)
+):
 E5MessageBox.critical(
 self,
 self.tr('Process Generation Error'),
 self.tr(
 '<p>Could not start Snapshot tool.<br>'
 procData = (None,)
 program = tool['executable']
 args = []
 argv = Utilities.parseOptionString(tool['arguments'])
 args.extend(argv)
-t = self.tr("Starting process '{0} {1}'.\n")\
+t = self.tr("Starting process '{0} {1}'.\n"
-.format(program, tool['arguments'])
+).format(program, tool['arguments'])
 self.appendToStdout(t)
 proc.finished.connect(self.__toolFinished)
 if tool['redirect'] != 'no':
 proc.readyReadStandardOutput.connect(self.__processToolStdout)
 # loop through all running tool processes
 for program, toolProc, toolProcData in self.toolProcs:
 toolProc.setReadChannel(QProcess.StandardOutput)
-if toolProcData[0] is None or \
+if (
-toolProcData[1] not in ["insert", "replaceSelection"]:
+toolProcData[0] is None or
+toolProcData[1] not in ["insert", "replaceSelection"]
+):
 # not connected to an editor or wrong mode
 while toolProc.canReadLine():
 output = str(toolProc.readLine(), ioEncoding, 'replace')
 s = "{0} - {1}".format(program, output)
 self.appendToStdout(s)
 """
 pythonDocDir = Preferences.getHelp("PythonDocDir")
 if not pythonDocDir:
 if Utilities.isWindowsPlatform():
 venvName = Preferences.getDebugger("Python3VirtualEnv")
-interpreter = e5App().getObject("VirtualEnvManager")\
+interpreter = (
+e5App().getObject("VirtualEnvManager")
 .getVirtualenvInterpreter(venvName)
+)
 if interpreter:
 default = os.path.join(os.path.dirname(interpreter), "doc")
 else:
 default = ""
-pythonDocDir = \
+pythonDocDir = Utilities.getEnvironmentEntry(
-Utilities.getEnvironmentEntry("PYTHON3DOCDIR", default)
+"PYTHON3DOCDIR", default)
 else:
 pythonDocDir = Utilities.getEnvironmentEntry(
 "PYTHON3DOCDIR",
 '/usr/share/doc/packages/python3/html')
 if not pythonDocDir.startswith(("http://", "https://", "qthelp://")):
 """
 pythonDocDir = Preferences.getHelp("Python2DocDir")
 if not pythonDocDir:
 if Utilities.isWindowsPlatform():
 venvName = Preferences.getDebugger("Python2VirtualEnv")
-interpreter = e5App().getObject("VirtualEnvManager")\
+interpreter = (
+e5App().getObject("VirtualEnvManager")
 .getVirtualenvInterpreter(venvName)
+)
 if interpreter:
 default = os.path.join(os.path.dirname(interpreter), "doc")
 else:
 default = ""
-pythonDocDir = \
+pythonDocDir = Utilities.getEnvironmentEntry(
-Utilities.getEnvironmentEntry("PYTHON2DOCDIR", default)
+"PYTHON2DOCDIR", default)
 else:
 pythonDocDir = Utilities.getEnvironmentEntry(
 "PYTHON2DOCDIR",
 '/usr/share/doc/packages/python/html')
 if not pythonDocDir.startswith(("http://", "https://", "qthelp://")):
 if self.__webBrowserProcess is None:
 webBrowsers = [
 os.path.join(
 os.path.dirname(__file__), "..", "eric6_browser.py"),
 # QtWebEngine based web browser
-os.path.join(
-os.path.dirname(__file__), "..", "eric6_webbrowser.py"),
-# QtWebKit based web browser
 ]
 process = QProcess()
 for browser in webBrowsers:
 args = [
 browser,
 @type QProcess
 @return error indication (1 = connection not possible, 0 = ok,
 -1 = server exited with an error code)
 @rtype int
 """
-from WebBrowser.WebBrowserSingleApplication import \
+from WebBrowser.WebBrowserSingleApplication import (
 WebBrowserSingleApplicationClient
+)
 webBrowserClient = WebBrowserSingleApplicationClient(
 self.__webBrowserSAName)
 connectCount = 30
 while connectCount:
 break
 else:
 connectCount -= 1
 QThread.msleep(1000)
 QApplication.processEvents()
-if process.state() == QProcess.NotRunning and \
+if (
-process.exitStatus() == QProcess.NormalExit and \
+process.state() == QProcess.NotRunning and
-process.exitCode() == 100:
+process.exitStatus() == QProcess.NormalExit and
+process.exitCode() == 100
+):
 # Process exited prematurely due to missing pre-requisites
 return -1
 if res <= 0:
 E5MessageBox.warning(
 self,
 QApplication.processEvents()
 if self.__configurationDialog.result() == QDialog.Accepted:
 self.__configurationDialog.setPreferences()
 Preferences.syncPreferences()
 self.__preferencesChanged()
-self.__lastConfigurationPageName = \
+self.__lastConfigurationPageName = (
 self.__configurationDialog.getConfigurationPageName()
-self.__expandedConfigurationEntries = \
+)
+self.__expandedConfigurationEntries = (
 self.__configurationDialog.getExpandedEntries()
+)
 self.__configurationDialog.deleteLater()
 self.__configurationDialog = None
 def __exportPreferences(self):
 self.masterPasswordChanged.emit(oldPassword, newPassword)
 Preferences.convertPasswords(oldPassword, newPassword)
 variant = Globals.getWebBrowserSupport()
 if variant == "QtWebEngine":
-from WebBrowser.Passwords.PasswordManager import \
+from WebBrowser.Passwords.PasswordManager import (
 PasswordManager
-pwManager = PasswordManager()
+)
-pwManager.masterPasswordChanged(oldPassword, newPassword)
-elif variant == "QtWebKit":
-from Helpviewer.Passwords.PasswordManager import \
-PasswordManager
 pwManager = PasswordManager()
 pwManager.masterPasswordChanged(oldPassword, newPassword)
 Utilities.crypto.changeRememberedMaster(newPassword)
 def __reloadAPIs(self):
 from .ClearPrivateDataDialog import ClearPrivateDataDialog
 dlg = ClearPrivateDataDialog(self)
 if dlg.exec_() == QDialog.Accepted:
 # recent files, recent projects, recent multi  projects,
 # debug histories, shell histories
-(files, projects, multiProjects, debug, shell, vcs, plugins) = \
+(files, projects, multiProjects, debug, shell, vcs, plugins) = (
 dlg.getData()
+)
 if files:
 # clear list of recently opened files
 self.viewmanager.clearRecent()
 if projects:
 # clear list of recently opened projects and other histories
 """
 Private slot to handle the projectOpened signal.
 """
 from Debugger.DebugClientCapabilities import HasUnittest
 self.__setWindowCaption(project=self.project.name)
-cap = e5App().getObject("DebugServer")\
+cap = e5App().getObject("DebugServer").getClientCapabilities(
-.getClientCapabilities(self.project.getProjectLanguage())
+self.project.getProjectLanguage())
 self.utProjectAct.setEnabled(cap & HasUnittest)
 self.utProjectOpen = cap & HasUnittest
 def __projectClosed(self):
 """
 def __writeCrashSession(self):
 """
 Private slot to write a crash session file.
 """
-if not self.__readingSession and \
+if (
-not self.__disableCrashSession and \
+not self.__readingSession and
-Preferences.getUI("CrashSessionEnabled"):
+not self.__disableCrashSession and
+Preferences.getUI("CrashSessionEnabled")
+):
 self.__writeSession(crashSession=True)
 def __readCrashSession(self):
 """
 Private method to check for and read a crash session.
 @return flag indicating a crash session file was found and read
 @rtype bool
 """
 res = False
-if not self.__disableCrashSession and \
+if (
-not self.__noCrashOpenAtStartup and \
+not self.__disableCrashSession and
-Preferences.getUI("OpenCrashSessionOnStartup"):
+not self.__noCrashOpenAtStartup and
+Preferences.getUI("OpenCrashSessionOnStartup")
+):
 fn = os.path.join(Utilities.getConfigDir(),
 "eric6_crash_session.e5s")
 if os.path.exists(fn):
 yes = E5MessageBox.yesNo(
 self,
 @keyparam searchDir directory to search in (string)
 @keyparam openFiles flag indicating to operate on open files (boolean)
 """
 if self.replaceFilesDialog is None:
 from .FindFileDialog import FindFileDialog
-self.replaceFilesDialog = \
+self.replaceFilesDialog = FindFileDialog(
-FindFileDialog(self.project, replaceMode=True)
+self.project, replaceMode=True)
 self.replaceFilesDialog.sourceFile.connect(
 self.viewmanager.openSourceFile)
 self.replaceFilesDialog.designerFile.connect(self.__designer)
 if searchDir:
 self.replaceFilesDialog.setSearchDirectory(searchDir)
 self.__replies.remove(reply)
 if reply.error() == QNetworkReply.NoError:
 ioEncoding = Preferences.getSystem("IOEncoding")
 versions = str(reply.readAll(), ioEncoding, 'replace').splitlines()
 reply.close()
-if reply.error() != QNetworkReply.NoError or \
+if (
-len(versions) == 0 or \
+reply.error() != QNetworkReply.NoError or
-versions[0].startswith("<"):
+len(versions) == 0 or
+versions[0].startswith("<")
+):
 # network error or an error page
 self.httpAlternative += 1
 if self.httpAlternative >= len(self.__httpAlternatives):
 self.__inVersionCheck = False
 if self.__versionCheckProgress is not None:
 line = 0
 while line < len(versions):
 if versions[line] == "---":
 break
-versionText += """<tr><td>{0}</td><td><a href="{1}">{2}</a>""" \
+versionText += (
-"""</td></tr>""".format(
+"""<tr><td>{0}</td><td><a href="{1}">{2}</a></td></tr>"""
-versions[line], versions[line + 1],
+).format(
-'sourceforge' in versions[line + 1] and
+versions[line], versions[line + 1],
-"SourceForge" or versions[line + 1])
+'sourceforge' in versions[line + 1] and
+"SourceForge" or versions[line + 1])
 line += 2
 versionText += self.tr("""</table>""")
 self.__versionsDialog = E5MessageBox.E5MessageBox(
 E5MessageBox.NoIcon,

Mercurial Repositories > eric / file comparison

comparison: eric6/UI/UserInterface.py

eric6/UI/UserInterface.py