eric: comparison eric6/UI/UserInterface.py

-:866adc8c315b
+:0acf98cd089a
 QNetworkProxyFactory, QNetworkAccessManager, QNetworkRequest, QNetworkReply
 )
 from .Info import Version, VersionOnly, BugAddress, Program, FeatureAddress
 from . import Config
+from .NotificationWidget import NotificationTypes
 from E5Gui.E5SingleApplication import E5SingleApplicationServer
 from E5Gui.E5Action import E5Action, createActionGroup
 from E5Gui.E5ToolBarManager import E5ToolBarManager
 from E5Gui import E5MessageBox, E5FileDialog, E5ErrorMessage
 import Utilities
 import Globals
 import UI.PixmapCache
-from E5Network.E5NetworkIcon import E5NetworkIcon
 from E5Network.E5NetworkProxyFactory import (
 E5NetworkProxyFactory, proxyAuthenticationRequired
 )
 try:
 from E5Network.E5SslErrorHandler import E5SslErrorHandler
 @signal reloadAPIs() emitted to reload the api information
 @signal showMenu(str, QMenu) emitted when a menu is about to be shown. The
 name of the menu and a reference to the menu are given.
 @signal masterPasswordChanged(str, str) emitted after the master
 password has been changed with the old and the new password
-@signal onlineStateChanged(online) emitted to indicate a change of the
-network state
 """
 appendStderr = pyqtSignal(str)
 appendStdout = pyqtSignal(str)
 preferencesChanged = pyqtSignal()
 reloadAPIs = pyqtSignal()
 showMenu = pyqtSignal(str, QMenu)
 masterPasswordChanged = pyqtSignal(str, str)
-onlineStateChanged = pyqtSignal(bool)
 maxFilePathLen = 100
 maxMenuFilePathLen = 75
 LeftSide = 1
 self.__writeCrashSession)
 self.debuggerUI.resetUI.connect(self.viewmanager.handleResetUI)
 self.debuggerUI.resetUI.connect(self.debugViewer.handleResetUI)
 self.debuggerUI.resetUI.connect(self.__debuggingDone)
-self.debuggerUI.debuggingStarted.connect(
-self.debugViewer.exceptionLogger.debuggingStarted)
-self.debuggerUI.debuggingStarted.connect(
-self.debugViewer.handleDebuggingStarted)
 self.debuggerUI.debuggingStarted.connect(self.__programChange)
 self.debuggerUI.debuggingStarted.connect(self.__debuggingStarted)
 self.debuggerUI.compileForms.connect(
 self.projectBrowser.pfBrowser.compileChangedForms)
 self.debuggerUI.compileResources.connect(
 self.projectBrowser.prBrowser.compileChangedResources)
 self.debuggerUI.executeMake.connect(self.project.executeMake)
 self.debuggerUI.appendStdout.connect(self.appendToStdout)
-debugServer.passiveDebugStarted.connect(
-self.debugViewer.exceptionLogger.debuggingStarted)
-debugServer.passiveDebugStarted.connect(
-self.debugViewer.handleDebuggingStarted)
-debugServer.clientException.connect(
-self.debugViewer.exceptionLogger.addException)
-debugServer.clientLine.connect(
-self.debugViewer.breakpointViewer.highlightBreakpoint)
 debugServer.clientDisassembly.connect(
 self.debugViewer.disassemblyViewer.showDisassembly)
 debugServer.clientProcessStdout.connect(self.appendToStdout)
 debugServer.clientProcessStderr.connect(self.appendToStderr)
 debugServer.appendStdout.connect(self.appendToStdout)
 UI.PixmapCache.getIcon("newWindow"),
 self.tr('New &Window'),
 QKeySequence(self.tr("Ctrl+Shift+N", "File|New Window")),
 0, self, 'new_window')
 self.newWindowAct.setStatusTip(self.tr(
-'Open a new eric6 instance'))
+'Open a new eric instance'))
 self.newWindowAct.setWhatsThis(self.tr(
 """<b>New Window</b>"""
-"""<p>This opens a new instance of the eric6 IDE.</p>"""
+"""<p>This opens a new instance of the eric IDE.</p>"""
 ))
 self.newWindowAct.triggered.connect(self.__newWindow)
 self.actions.append(self.newWindowAct)
 self.newWindowAct.setEnabled(
 not Preferences.getUI("SingleApplicationMode"))
 0, self, 'helpviewer')
 self.helpviewerAct.setStatusTip(self.tr(
 'Open the helpviewer window'))
 self.helpviewerAct.setWhatsThis(self.tr(
 """<b>Helpviewer</b>"""
-"""<p>Display the eric6 web browser. This window will show"""
+"""<p>Display the eric web browser. This window will show"""
 """ HTML help files and help from Qt help collections. It"""
 """ has the capability to navigate to links, set bookmarks,"""
 """ print the displayed help and some more features. You may"""
 """ use it to browse the internet as well</p><p>If called"""
 """ with a word selected, this word is search in the Qt help"""
 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 eric6.</p>"""
+"""<p>Checks the internet for updates of eric.</p>"""
 ))
 self.checkUpdateAct.triggered.connect(self.performVersionCheck)
 self.actions.append(self.checkUpdateAct)
 self.showVersionsAct = E5Action(
 0, 0, self, 'show_downloadable_versions')
 self.showVersionsAct.setStatusTip(
 self.tr('Show the versions available for download'))
 self.showVersionsAct.setWhatsThis(self.tr(
 """<b>Show downloadable versions...</b>"""
-"""<p>Shows the eric6 versions available for download """
+"""<p>Shows the eric versions available for download """
 """from the internet.</p>"""
 ))
 self.showVersionsAct.triggered.connect(
 self.showAvailableVersionsInfo)
 self.actions.append(self.showVersionsAct)
 self.tr('Hex Editor'),
 UI.PixmapCache.getIcon("hexEditor"),
 self.tr('&Hex Editor...'),
 0, 0, self, 'hex_editor')
 self.hexEditorAct.setStatusTip(self.tr(
-'Start the eric6 Hex Editor'))
+'Start the eric Hex Editor'))
 self.hexEditorAct.setWhatsThis(self.tr(
 """<b>Hex Editor</b>"""
-"""<p>Starts the eric6 Hex Editor for viewing or editing"""
+"""<p>Starts the eric Hex Editor for viewing or editing"""
 """ binary files.</p>"""
 ))
 self.hexEditorAct.triggered.connect(self.__openHexEditor)
 self.actions.append(self.hexEditorAct)
 self.webBrowserAct = E5Action(
-self.tr('eric6 Web Browser'),
+self.tr('eric Web Browser'),
 UI.PixmapCache.getIcon("ericWeb"),
-self.tr('eric6 &Web Browser...'),
+self.tr('eric &Web Browser...'),
 0, 0, self, 'web_browser')
 self.webBrowserAct.setStatusTip(self.tr(
-'Start the eric6 Web Browser'))
+'Start the eric Web Browser'))
 self.webBrowserAct.setWhatsThis(self.tr(
-"""<b>eric6 Web Browser</b>"""
+"""<b>eric Web Browser</b>"""
-"""<p>Browse the Internet with the eric6 Web Browser.</p>"""
+"""<p>Browse the Internet with the eric Web Browser.</p>"""
 ))
 self.webBrowserAct.triggered.connect(self.__startWebBrowser)
 self.actions.append(self.webBrowserAct)
-##        else:
-##            self.webBrowserAct = None
 self.iconEditorAct = E5Action(
 self.tr('Icon Editor'),
 UI.PixmapCache.getIcon("iconEditor"),
 self.tr('&Icon Editor...'),
 0, 0, self, 'icon_editor')
 self.iconEditorAct.setStatusTip(self.tr(
-'Start the eric6 Icon Editor'))
+'Start the eric Icon Editor'))
 self.iconEditorAct.setWhatsThis(self.tr(
 """<b>Icon Editor</b>"""
-"""<p>Starts the eric6 Icon Editor for editing simple icons.</p>"""
+"""<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.showExternalToolsAct.setStatusTip(self.tr(
 'Show external tools'))
 self.showExternalToolsAct.setWhatsThis(self.tr(
 """<b>Show external tools</b>"""
 """<p>Opens a dialog to show the path and versions of all"""
-""" extenal tools used by eric6.</p>"""
+""" extenal tools used by eric.</p>"""
 ))
 self.showExternalToolsAct.triggered.connect(
 self.__showExternalTools)
 self.actions.append(self.showExternalToolsAct)
 """
 Private slot to initialize the action to show the Qt documentation.
 """
 self.qt5DocAct = E5Action(
 self.tr('Qt5 Documentation'),
-self.tr('Qt&5 Documentation'),
+self.tr('Qt5 Documentation'),
 0, 0, self, 'qt5_documentation')
 self.qt5DocAct.setStatusTip(self.tr('Open Qt5 Documentation'))
 self.qt5DocAct.setWhatsThis(self.tr(
 """<b>Qt5 Documentation</b>"""
 """<p>Display the Qt5 Documentation. Dependent upon your"""
 """ settings, this will either show the help in Eric's internal"""
 """ help viewer/web browser, or execute a web browser or Qt"""
 """ Assistant. </p>"""
 ))
-self.qt5DocAct.triggered.connect(self.__showQt5Doc)
+self.qt5DocAct.triggered.connect(lambda: self.__showQtDoc(5))
 self.actions.append(self.qt5DocAct)
+self.qt6DocAct = E5Action(
+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(
+"""<b>Qt6 Documentation</b>"""
+"""<p>Display the Qt6 Documentation. Dependent upon your"""
+""" settings, this will either show the help in Eric's internal"""
+""" help viewer/web browser, or execute a web browser or Qt"""
+""" Assistant. </p>"""
+))
+self.qt6DocAct.triggered.connect(lambda: self.__showQtDoc(6))
+self.actions.append(self.qt6DocAct)
 self.pyqt5DocAct = E5Action(
 self.tr('PyQt5 Documentation'),
-self.tr('PyQt&5 Documentation'),
+self.tr('PyQt5 Documentation'),
 0, 0, self, 'pyqt5_documentation')
 self.pyqt5DocAct.setStatusTip(self.tr(
 'Open PyQt5 Documentation'))
 self.pyqt5DocAct.setWhatsThis(self.tr(
 """<b>PyQt5 Documentation</b>"""
 """<p>Display the PyQt5 Documentation. Dependent upon your"""
 """ settings, this will either show the help in Eric's"""
 """ internal help viewer/web browser, or execute a web"""
 """ browser or Qt Assistant. </p>"""
 ))
-self.pyqt5DocAct.triggered.connect(self.__showPyQt5Doc)
+self.pyqt5DocAct.triggered.connect(
+lambda: self.__showPyQtDoc(variant=5))
 self.actions.append(self.pyqt5DocAct)
+self.pyqt6DocAct = E5Action(
+self.tr('PyQt6 Documentation'),
+self.tr('PyQt6 Documentation'),
+0, 0, self, 'pyqt6_documentation')
+self.pyqt6DocAct.setStatusTip(self.tr(
+'Open PyQt6 Documentation'))
+self.pyqt6DocAct.setWhatsThis(self.tr(
+"""<b>PyQt6 Documentation</b>"""
+"""<p>Display the PyQt6 Documentation. Dependent upon your"""
+""" settings, this will either show the help in Eric's"""
+""" internal help viewer/web browser, or execute a web"""
+""" browser or Qt Assistant. </p>"""
+))
+self.pyqt6DocAct.triggered.connect(
+lambda: self.__showPyQtDoc(variant=6))
+self.actions.append(self.pyqt6DocAct)
 def __initPythonDocActions(self):
 """
 Private slot to initialize the actions to show the Python
 documentation.
 """
 self.pythonDocAct = E5Action(
 self.tr('Python 3 Documentation'),
-self.tr('Python &3 Documentation'),
+self.tr('Python 3 Documentation'),
 0, 0, self, 'python3_documentation')
 self.pythonDocAct.setStatusTip(self.tr(
 'Open Python 3 Documentation'))
 self.pythonDocAct.setWhatsThis(self.tr(
 """<b>Python 3 Documentation</b>"""
 self.pythonDocAct.triggered.connect(self.__showPythonDoc)
 self.actions.append(self.pythonDocAct)
 def __initEricDocAction(self):
 """
-Private slot to initialize the action to show the eric6 documentation.
+Private slot to initialize the action to show the eric documentation.
 """
 self.ericDocAct = E5Action(
 self.tr("Eric API Documentation"),
-self.tr('&Eric API Documentation'),
+self.tr('Eric API Documentation'),
 0, 0, self, 'eric_documentation')
 self.ericDocAct.setStatusTip(self.tr(
 "Open Eric API Documentation"))
 self.ericDocAct.setWhatsThis(self.tr(
 """<b>Eric API Documentation</b>"""
 """<p>Display the Eric API documentation. The location for the"""
 """ documentation is the Documentation/Source subdirectory of"""
-""" the eric6 installation directory.</p>"""
+""" the eric installation directory.</p>"""
 ))
 self.ericDocAct.triggered.connect(self.__showEricDoc)
 self.actions.append(self.ericDocAct)
 def __initPySideDocActions(self):
 """
 Private slot to initialize the actions to show the PySide
 documentation.
 """
-if Utilities.checkPyside():
+if Utilities.checkPyside(variant=2):
 self.pyside2DocAct = E5Action(
 self.tr('PySide2 Documentation'),
-self.tr('PySide&2 Documentation'),
+self.tr('PySide2 Documentation'),
 0, 0, self, 'pyside2_documentation')
 self.pyside2DocAct.setStatusTip(self.tr(
 'Open PySide2 Documentation'))
 self.pyside2DocAct.setWhatsThis(self.tr(
 """<b>PySide2 Documentation</b>"""
 """ settings, this will either show the help in Eric's"""
 """ internal help viewer/web browser, or execute a web"""
 """ browser or Qt Assistant. </p>"""
 ))
 self.pyside2DocAct.triggered.connect(
-lambda: self.__showPySideDoc("2"))
+lambda: self.__showPySideDoc(variant=2))
 self.actions.append(self.pyside2DocAct)
 else:
 self.pyside2DocAct = None
+if Utilities.checkPyside(variant=6):
+self.pyside6DocAct = E5Action(
+self.tr('PySide6 Documentation'),
+self.tr('PySide6 Documentation'),
+0, 0, self, 'pyside6_documentation')
+self.pyside6DocAct.setStatusTip(self.tr(
+'Open PySide6 Documentation'))
+self.pyside6DocAct.setWhatsThis(self.tr(
+"""<b>PySide6 Documentation</b>"""
+"""<p>Display the PySide6 Documentation. Dependent upon your"""
+""" settings, this will either show the help in Eric's"""
+""" internal help viewer/web browser, or execute a web"""
+""" browser or Qt Assistant. </p>"""
+))
+self.pyside6DocAct.triggered.connect(
+lambda: self.__showPySideDoc(variant=6))
+self.actions.append(self.pyside6DocAct)
+else:
+self.pyside6DocAct = None
 def __initMenus(self):
 """
 Private slot to create the menus.
 """
 self.__menus["help"].addAction(self.helpviewerAct)
 self.__menus["help"].addSeparator()
 self.__menus["help"].addAction(self.ericDocAct)
 self.__menus["help"].addAction(self.pythonDocAct)
 self.__menus["help"].addAction(self.qt5DocAct)
-if self.pyqt5DocAct is not None:
+self.__menus["help"].addAction(self.qt6DocAct)
 self.__menus["help"].addAction(self.pyqt5DocAct)
+self.__menus["help"].addAction(self.pyqt6DocAct)
 if self.pyside2DocAct is not None:
 self.__menus["help"].addAction(self.pyside2DocAct)
+if self.pyside6DocAct is not None:
+self.__menus["help"].addAction(self.pyside6DocAct)
 self.__menus["help"].addSeparator()
 self.__menus["help"].addAction(self.versionAct)
 self.__menus["help"].addSeparator()
 self.__menus["help"].addAction(self.checkUpdateAct)
 self.__menus["help"].addAction(self.showVersionsAct)
 from VCS.StatusMonitorLed import StatusMonitorLedWidget
 self.sbVcsMonitorLed = StatusMonitorLedWidget(
 self.project, self.__statusBar)
 self.__statusBar.addPermanentWidget(self.sbVcsMonitorLed)
-self.networkIcon = E5NetworkIcon(self.__statusBar)
-self.__statusBar.addPermanentWidget(self.networkIcon)
-self.networkIcon.onlineStateChanged.connect(self.onlineStateChanged)
-self.networkIcon.onlineStateChanged.connect(self.__onlineStateChanged)
 def __initExternalToolsActions(self):
 """
 Private slot to create actions for the configured external tools.
 """
 """
 if mode == "feature":
 address = FeatureAddress
 else:
 address = BugAddress
-subject = "[eric6] "
+subject = "[eric] "
 if attachFile is not None:
 with open(attachFile, "r", encoding="utf-8") as f:
 body = f.read()
 if deleteAttachFile:
 os.remove(attachFile)
 args.extend(self.__restartArgs)
 QProcess.startDetached(program, args)
 def __newWindow(self):
 """
-Private slot to start a new instance of eric6.
+Private slot to start a new instance of eric.
 """
 if not Preferences.getUI("SingleApplicationMode"):
-# start eric6 without any arguments
+# start eric without any arguments
 program = sys.executable
 eric6 = os.path.join(getConfig("ericDir"), "eric6.py")
 args = [eric6]
 QProcess.startDetached(program, args)
 )
 )
 def __startWebBrowser(self):
 """
-Private slot to start the eric6 web browser.
+Private slot to start the eric web browser.
 """
 self.launchHelpViewer("")
 def __customViewer(self, home=None):
 """
 elif hvType == 3:
 self.__webBrowser(home)
 else:
 self.__customViewer(home)
-def __showQt5Doc(self):
-"""
-Private slot to show the Qt5 documentation.
-"""
-self.__showQtDoc(5)
 def __showQtDoc(self, version):
 """
 Private method to show the Qt documentation.
-@param version Qt version to show documentation for (integer)
+@param version Qt version to show documentation for
-"""
+@type int
-if version == 5:
+"""
-qtDocDir = Preferences.getQt5DocDir()
+if version in [5, 6]:
+qtDocDir = Preferences.getQtDocDir(version)
+else:
+return
 if qtDocDir.startswith("qthelp://"):
 if not os.path.splitext(qtDocDir)[1]:
 home = qtDocDir + "/index.html"
 else:
 elif hvType == 3:
 self.__webBrowser(home)
 else:
 self.__customViewer(home)
-def __showPyQt5Doc(self):
+def __showPyQtDoc(self, variant=5):
 """
-Private slot to show the PyQt5 documentation.
+Private slot to show the PyQt5/6 documentation.
-"""
-pyqt5DocDir = Preferences.getHelp("PyQt5DocDir")
+@param variant PyQt variant to show documentation for (5 or 6)
-if not pyqt5DocDir:
+@type int or str
-pyqt5DocDir = Utilities.getEnvironmentEntry("PYQT5DOCDIR", None)
+"""
+pyqtDocDir = Preferences.getHelp("PyQt{0}DocDir".format(variant))
-if not pyqt5DocDir:
+if not pyqtDocDir:
+pyqtDocDir = Utilities.getEnvironmentEntry(
+"PYQT{0}DOCDIR".format(variant), None)
+if not pyqtDocDir:
 E5MessageBox.warning(
 self,
 self.tr("Documentation"),
-self.tr("""<p>The PyQt5 documentation starting point"""
+self.tr("""<p>The PyQt{0} documentation starting point"""
-""" has not been configured.</p>"""))
+""" has not been configured.</p>""").format(variant))
 return
-if not pyqt5DocDir.startswith(("http://", "https://", "qthelp://")):
+if not pyqtDocDir.startswith(("http://", "https://", "qthelp://")):
 home = ""
-if pyqt5DocDir:
+if pyqtDocDir:
-if pyqt5DocDir.startswith("file://"):
+if pyqtDocDir.startswith("file://"):
-pyqt5DocDir = pyqt5DocDir[7:]
+pyqtDocDir = pyqtDocDir[7:]
-if not os.path.splitext(pyqt5DocDir)[1]:
+if not os.path.splitext(pyqtDocDir)[1]:
 possibleHomes = [
 Utilities.normjoinpath(
-pyqt5DocDir, 'index.html'),
+pyqtDocDir, 'index.html'),
 Utilities.normjoinpath(
-pyqt5DocDir, 'class_reference.html'),
+pyqtDocDir, 'class_reference.html'),
 ]
 for possibleHome in possibleHomes:
 if os.path.exists(possibleHome):
 home = possibleHome
 break
 else:
-home = pyqt5DocDir
+home = pyqtDocDir
 if not home or not os.path.exists(home):
 E5MessageBox.warning(
 self,
 self.tr("Documentation Missing"),
 if Utilities.isWindowsPlatform():
 home = "file:///" + Utilities.fromNativeSeparators(home)
 else:
 home = "file://" + home
 else:
-home = pyqt5DocDir
+home = pyqtDocDir
 hvType = Preferences.getWebBrowser("HelpViewerType")
 if hvType == 1:
 self.launchHelpViewer(home)
 elif hvType == 2:
 elif hvType == 3:
 self.__webBrowser(home)
 else:
 self.__customViewer(home)
-def __showPySideDoc(self, variant="2"):
+def __showPySideDoc(self, variant=2):
 """
-Private slot to show the PySide2 documentation.
+Private slot to show the PySide2/PySide6 documentation.
-@param variant PySide variant (2)
+@param variant PySide variant (2 or 6)
-@type str
+@type int or str
 """
-pysideDocDir = Preferences.getHelp("PySide2DocDir")
+pysideDocDir = Preferences.getHelp("PySide{0}DocDir".format(variant))
 if not pysideDocDir:
 pysideDocDir = Utilities.getEnvironmentEntry(
-"PYSIDE2DOCDIR", None)
+"PYSIDE{0}DOCDIR".format(variant), None)
 if not pysideDocDir:
 E5MessageBox.warning(
 self,
 self.tr("Documentation"),
 """
 Public slot to start the help viewer/web browser.
 @param home filename of file to be shown or URL to be opened
 @type str or QUrl
-@keyparam searchWord word to search for
+@param searchWord word to search for
 @type str
-@keyparam useSingle flag indicating to use a single browser window
+@param useSingle flag indicating to use a single browser window
 @type bool
 """
 if isinstance(home, QUrl):
 home = home.toString(QUrl.None_)
 Private method to start an external web browser and communicate with
 it.
 @param home filename of file to be shown or URL to be opened
 @type str
-@keyparam searchWord word to search for
+@param searchWord word to search for
 @type str
 @return flag indicating a successful launch
 @rtype bool
 """
 clientArgs = []
 process.start(sys.executable, args)
 if not process.waitForStarted():
 E5MessageBox.warning(
 self,
 self.tr("Start Web Browser"),
-self.tr("""The eric6 web browser could not be"""
+self.tr("""The eric web browser could not be"""
 """ started."""))
 return False
 res = self.__connectToWebBrowser(process)
 if res == 1:
 return -1
 if res <= 0:
 E5MessageBox.warning(
 self,
 self.tr("Start Web Browser"),
-self.tr("""<p>The eric6 web browser is not started.</p>"""
+self.tr("""<p>The eric web browser is not started.</p>"""
 """<p>Reason: {0}</p>""").format(
 webBrowserClient.errstr())
 )
 return 1
 self.launchHelpViewer("", searchWord=searchWord)
 def __webBrowser(self, home=""):
 """
-Private slot to start the eric6 web browser.
+Private slot to start the eric web browser.
 @param home full pathname of a file to display (string)
 """
 started = QDesktopServices.openUrl(QUrl(home))
 if not started:
 self.reloadAPIs.emit()
 def __showExternalTools(self):
 """
 Private slot to display a dialog show a list of external tools used
-by eric6.
+by eric.
 """
 if self.programsDialog is None:
 from Preferences.ProgramsDialog import ProgramsDialog
 self.programsDialog = ProgramsDialog(self)
 self.programsDialog.show()
 """
 sessionFile, selectedFilter = E5FileDialog.getSaveFileNameAndFilter(
 self,
 self.tr("Save session"),
 Utilities.getHomeDir(),
-self.tr("eric6 Session Files (*.e5s)"),
+self.tr("eric Session Files (*.e5s)"),
 "")
 if not sessionFile:
 return
 """
 sessionFile = E5FileDialog.getOpenFileName(
 self,
 self.tr("Load session"),
 Utilities.getHomeDir(),
-self.tr("eric6 Session Files (*.e5s)"))
+self.tr("eric Session Files (*.e5s)"))
 if not sessionFile:
 return
 self.__readSession(filename=sessionFile)
 def showFindFilesDialog(self, txt="", searchDir="", openFiles=False):
 """
 Public slot to show the Find In Files dialog.
-@keyparam txt text to search for (string)
+@param txt text to search for (string)
-@keyparam searchDir directory to search in (string)
+@param searchDir directory to search in (string)
-@keyparam openFiles flag indicating to operate on open files (boolean)
+@param openFiles flag indicating to operate on open files (boolean)
 """
 if self.findFilesDialog is None:
 from .FindFileDialog import FindFileDialog
 self.findFilesDialog = FindFileDialog(self.project)
 self.findFilesDialog.sourceFile.connect(
 def showReplaceFilesDialog(self, txt="", searchDir="", openFiles=False):
 """
 Public slot to show the Find & Replace In Files dialog.
-@keyparam txt text to search for (string)
+@param txt text to search for (string)
-@keyparam searchDir directory to search in (string)
+@param searchDir directory to search in (string)
-@keyparam openFiles flag indicating to operate on open files (boolean)
+@param openFiles flag indicating to operate on open files (boolean)
 """
 if self.replaceFilesDialog is None:
 from .FindFileDialog import FindFileDialog
 self.replaceFilesDialog = FindFileDialog(
 self.project, replaceMode=True)
 def checkPluginUpdatesAvailable(self):
 """
 Public method to check the availability of updates of plug-ins.
 """
-if self.isOnline():
+self.pluginManager.checkPluginUpdatesAvailable()
-self.pluginManager.checkPluginUpdatesAvailable()
 #################################################################
 ## Drag and Drop Support
 #################################################################
 self.__saveCurrentViewProfile(True)
 Preferences.saveToolGroups(self.toolGroups, self.currentToolGroup)
 Preferences.syncPreferences()
 self.shutdownCalled = True
 return True
-def isOnline(self):
-"""
-Public method to get the online state.
-@return online state
-@rtype bool
-"""
-return self.networkIcon.isOnline()
-def __onlineStateChanged(self, online):
-"""
-Private slot handling changes in online state.
-@param online flag indicating the online state
-@type bool
-"""
-if online:
-self.performVersionCheck(False)
 ##############################################
 ## Below are methods to check for new versions
 ##############################################
 def showAvailableVersionsInfo(self):
 """
-Public method to show the eric6 versions available for download.
+Public method to show the eric versions available for download.
 """
 self.performVersionCheck(manual=True, showVersions=True)
 @pyqtSlot()
 def performVersionCheck(self, manual=True, alternative=0,
 showVersions=False):
 """
-Public method to check the internet for an eric6 update.
+Public method to check the internet for an eric update.
 @param manual flag indicating an invocation via the menu (boolean)
 @param alternative index of server to download from (integer)
-@keyparam showVersions flag indicating the show versions mode (boolean)
+@param showVersions flag indicating the show versions mode (boolean)
 """
-if self.isOnline():
+if not manual:
-if not manual:
+if VersionOnly.startswith("@@"):
-if VersionOnly.startswith("@@"):
+return
+else:
+period = Preferences.getUI("PerformVersionCheck")
+if period == 0:
 return
-else:
+elif period in [2, 3, 4]:
-period = Preferences.getUI("PerformVersionCheck")
+lastCheck = Preferences.Prefs.settings.value(
-if period == 0:
+"Updates/LastCheckDate", QDate(1970, 1, 1))
-return
+if lastCheck.isValid():
-elif period in [2, 3, 4]:
+now = QDate.currentDate()
-lastCheck = Preferences.Prefs.settings.value(
+if period == 2 and lastCheck.day() == now.day():
-"Updates/LastCheckDate", QDate(1970, 1, 1))
+# daily
-if lastCheck.isValid():
+return
-now = QDate.currentDate()
+elif period == 3 and lastCheck.daysTo(now) < 7:
-if period == 2 and lastCheck.day() == now.day():
+# weekly
-# daily
+return
-return
+elif period == 4 and (lastCheck.daysTo(now) <
-elif period == 3 and lastCheck.daysTo(now) < 7:
+lastCheck.daysInMonth()):
-# weekly
+# monthly
 return
-elif period == 4 and (lastCheck.daysTo(now) <
-lastCheck.daysInMonth()):
+self.__inVersionCheck = True
-# monthly
+self.manualUpdatesCheck = manual
-return
+self.showAvailableVersions = showVersions
+self.httpAlternative = alternative
-self.__inVersionCheck = True
+url = QUrl(self.__httpAlternatives[alternative])
-self.manualUpdatesCheck = manual
+self.__versionCheckCanceled = False
-self.showAvailableVersions = showVersions
+if manual:
-self.httpAlternative = alternative
+if self.__versionCheckProgress is None:
-url = QUrl(self.__httpAlternatives[alternative])
+self.__versionCheckProgress = E5ProgressDialog(
-self.__versionCheckCanceled = False
+"", self.tr("&Cancel"),
-if manual:
+0, len(self.__httpAlternatives),
-if self.__versionCheckProgress is None:
+self.tr("%v/%m"), self)
-self.__versionCheckProgress = E5ProgressDialog(
+self.__versionCheckProgress.setWindowTitle(
-"", self.tr("&Cancel"),
+self.tr("Version Check"))
-0, len(self.__httpAlternatives),
+self.__versionCheckProgress.setMinimumDuration(0)
-self.tr("%v/%m"), self)
+self.__versionCheckProgress.canceled.connect(
-self.__versionCheckProgress.setWindowTitle(
+self.__versionsDownloadCanceled)
-self.tr("Version Check"))
+self.__versionCheckProgress.setLabelText(
-self.__versionCheckProgress.setMinimumDuration(0)
+self.tr("Trying host {0}").format(url.host()))
-self.__versionCheckProgress.canceled.connect(
+self.__versionCheckProgress.setValue(alternative)
-self.__versionsDownloadCanceled)
+request = QNetworkRequest(url)
-self.__versionCheckProgress.setLabelText(
+request.setAttribute(QNetworkRequest.CacheLoadControlAttribute,
-self.tr("Trying host {0}").format(url.host()))
+QNetworkRequest.AlwaysNetwork)
-self.__versionCheckProgress.setValue(alternative)
+reply = self.__networkManager.get(request)
-request = QNetworkRequest(url)
+reply.finished.connect(lambda: self.__versionsDownloadDone(reply))
-request.setAttribute(QNetworkRequest.CacheLoadControlAttribute,
+self.__replies.append(reply)
-QNetworkRequest.AlwaysNetwork)
-reply = self.__networkManager.get(request)
-reply.finished.connect(lambda: self.__versionsDownloadDone(reply))
-self.__replies.append(reply)
-else:
-if manual:
-E5MessageBox.warning(
-self,
-self.tr("Error getting versions information"),
-self.tr("""The versions information cannot not be"""
-""" downloaded because you are <b>offline</b>."""
-""" Please go online and try again."""))
 @pyqtSlot()
 def __versionsDownloadDone(self, reply):
 """
 Private slot called, after the versions file has been downloaded
 from the internet.
 if availableSnapshotDate > installedSnapshotDate:
 res = E5MessageBox.yesNo(
 self,
 self.tr("Update available"),
 self.tr(
-"""The update to <b>{0}</b> of eric6 is"""
+"""The update to <b>{0}</b> of eric is"""
 """ available at <b>{1}</b>. Would you like"""
 """ to get it?""")
 .format(versions[2], versions[3]),
 yesDefault=True)
 url = res and versions[3] or ''
 E5MessageBox.information(
 self,
 self.tr("Update Check"),
 self.tr(
 """You are using a snapshot release of"""
-""" eric6. A more up-to-date stable release"""
+""" eric. A more up-to-date stable release"""
 """ might be available."""))
 elif VersionOnly.startswith(("rev_", "@@")):
 # check installation from source
 if self.manualUpdatesCheck:
 E5MessageBox.information(
 if availableVersionTuple > installedVersionTuple:
 res = E5MessageBox.yesNo(
 self,
 self.tr("Update available"),
 self.tr(
-"""The update to <b>{0}</b> of eric6 is"""
+"""The update to <b>{0}</b> of eric is"""
 """ available at <b>{1}</b>. Would you like"""
 """ to get it?""")
 .format(versions[0], versions[1]),
 yesDefault=True)
 url = res and versions[1] or ''
 else:
 if self.manualUpdatesCheck:
 E5MessageBox.information(
 self,
-self.tr("Eric6 is up to date"),
+self.tr("eric is up to date"),
 self.tr(
 """You are using the latest version of"""
-""" eric6"""))
+""" eric"""))
 except (IndexError, TypeError):
 E5MessageBox.warning(
 self,
 self.tr("Error during updates check"),
 self.tr("""Could not perform updates check."""))
 ## Below are methods for various checks
 #######################################
 def checkConfigurationStatus(self):
 """
-Public method to check, if eric6 has been configured. If it is not,
+Public method to check, if eric has been configured. If it is not,
 the configuration dialog is shown.
 """
 if not Preferences.isConfigured():
 self.__initDebugToolbarsLayout()
 E5MessageBox.information(
 self,
 self.tr("First time usage"),
-self.tr("""eric6 has not been configured yet. """
+self.tr("""eric has not been configured yet. """
 """The configuration dialog will be started."""))
 self.showPreferences()
 def checkProjectsWorkspace(self):
 """
 E5FileDialog.Options(E5FileDialog.Option(0)))
 Preferences.setMultiProject("Workspace", workspace)
 def versionIsNewer(self, required, snapshot=None):
 """
-Public method to check, if the eric6 version is good compared to
+Public method to check, if the eric version is good compared to
 the required version.
 @param required required version (string)
 @param snapshot required snapshot version (string)
 @return flag indicating, that the version is newer than the required
 return [p.x(), p.y(), s.width(), s.height(), not w.isHidden()]
 def getOriginalPathString(self):
 """
 Public method to get the original PATH environment variable
-(i.e. before modifications by eric6 and PyQt5).
+(i.e. before modifications by eric and PyQt5).
 @return original PATH environment variable
 @rtype str
 """
 return self.__originalPathString
 ##########################################
 ## Support for desktop notifications below
 ##########################################
-def showNotification(self, icon, heading, text, timeout=None):
+def showNotification(self, icon, heading, text,
+kind=NotificationTypes.Information, timeout=None):
 """
 Public method to show a desktop notification.
 @param icon icon to be shown in the notification
 @type QPixmap
 @param heading heading of the notification
 @type str
 @param text text of the notification
 @type str
+@param kind kind of notification to be shown
+@type NotificationTypes
 @param timeout time in seconds the notification should be shown
 (None = use configured timeout, 0 = indefinitely)
 @type int
 """
-if Preferences.getUI("NotificationsEnabled"):
+if self.__notification is None:
-if self.__notification is None:
+from .NotificationWidget import NotificationWidget
-from .NotificationWidget import NotificationWidget
+self.__notification = NotificationWidget(parent=self)
-self.__notification = NotificationWidget(parent=self)
+if timeout is None:
-self.__notification.setPixmap(icon)
+timeout = Preferences.getUI("NotificationTimeout")
-self.__notification.setHeading(heading)
+self.__notification.showNotification(icon, heading, text, kind=kind,
-self.__notification.setText(text)
+timeout=timeout)
-if timeout is None:
-timeout = Preferences.getUI("NotificationTimeout")
-self.__notification.setTimeout(timeout)
-self.__notification.move(Preferences.getUI("NotificationPosition"))
-self.__notification.show()
-def notificationsEnabled(self):
-"""
-Public method to check, if notifications are enabled.
-@return flag indicating, if notifications are enabled (boolean)
-"""
-return Preferences.getUI("NotificationsEnabled")
 #########################
 ## Support for IRC  below
 #########################

Mercurial Repositories > eric / file comparison

comparison: eric6/UI/UserInterface.py

eric6/UI/UserInterface.py