eric: comparison src/eric7/UI/UserInterface.py

-:88f10deec960
+:7328efba128b
 # -*- coding: utf-8 -*-
-# Copyright (c) 2002 - 2022 Detlev Offenbach <detlev@die-offenbachs.de>
+# Copyright (c) 2002 - 2023 Detlev Offenbach <detlev@die-offenbachs.de>
 #
 """
 Module implementing the main user interface.
 """
 from eric7.PluginManager.PluginRepositoryDialog import PluginRepositoryDownloadCleanup
 from eric7.Preferences import Shortcuts
 from eric7.Project.Project import Project
 from eric7.QScintilla.SpellChecker import SpellChecker
 from eric7.Sessions.SessionFile import SessionFile
+from eric7.SystemUtilities import (
+DesktopUtilities,
+FileSystemUtilities,
+OSUtilities,
+PythonUtilities,
+QtUtilities,
+)
 from eric7.Tasks.TasksFile import TasksFile
 from eric7.Testing.TestingWidget import clearSavedHistories
 from eric7.Utilities.BackgroundService import BackgroundService
 from eric7.VirtualEnv.VirtualenvManager import VirtualenvManager
 self.pluginManager.initPluginToolbars(self.toolbarManager)
 if Preferences.getPluginManager("StartupCleanup"):
 splash.showMessage(self.tr("Cleaning Plugins Download Area..."))
 PluginRepositoryDownloadCleanup(quiet=True)
+if self.__findFileWidget:
+self.__findFileWidget.populateFileCategories()
 # now read the keyboard shortcuts for all the actions
 Shortcuts.readShortcuts()
 # restore toolbar manager state
 splash.showMessage(self.tr("Restoring Toolbarmanager..."))
 # now start the debug client with the most recently used virtual
 # environment
 splash.showMessage(self.tr("Starting Debugger..."))
 if Preferences.getShell("StartWithMostRecentlyUsedEnvironment"):
-venvName=Preferences.getShell("LastVirtualEnvironment")
+venvName = Preferences.getShell("LastVirtualEnvironment")
 if venvName == "embedded environment":
 venvName = ""
 self.__debugServer.startClient(False, venvName=venvName)
 else:
 self.__debugServer.startClient(False)
 # holds space delimited list of command args, if any
 argsStr = None
 # flag indicating '--' options was found
 ddseen = False
-argChars = ["-", "/"] if Utilities.isWindowsPlatform() else ["-"]
+argChars = ["-", "/"] if OSUtilities.isWindowsPlatform() else ["-"]
 for arg in args:
 # handle a request to start with last session
 if arg == "--start-file":
 self.__openOnStartup("File")
 @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 = Utilities.compactPath(editor, self.maxFilePathLen)
+self.capEditor = FileSystemUtilities.compactPath(
+editor, self.maxFilePathLen
+)
 if project is not None:
 self.capProject = project
 if self.passiveMode:
 if not self.capProject and not self.capEditor:
 self,
 "code_documentation_viewer_activate",
 )
 self.codeDocumentationViewerActivateAct.setStatusTip(
 self.tr(
-"Switch the input focus to the Code Documentation Viewer" " window."
+"Switch the input focus to the Code Documentation Viewer window."
 )
 )
 self.codeDocumentationViewerActivateAct.setWhatsThis(
 self.tr(
 """<b>Code Documentation Viewer</b>"""
 self,
 "virtualenv_manager_activate",
 )
 self.virtualenvManagerActivateAct.setStatusTip(
 self.tr(
-"Switch the input focus to the Virtual Environments Manager" " window."
+"Switch the input focus to the Virtual Environments Manager window."
 )
 )
 self.virtualenvManagerActivateAct.setWhatsThis(
 self.tr(
 """<b>Virtual Environments</b>"""
 self,
 "show_versions",
 )
 self.versionAct.setStatusTip(self.tr("Display version information"))
 self.versionAct.setWhatsThis(
-self.tr(
+self.tr("""<b>Show Versions</b><p>Display version information.</p>""")
-"""<b>Show Versions</b>""" """<p>Display version information.</p>"""
-)
 )
 self.versionAct.triggered.connect(self.__showVersions)
 self.actions.append(self.versionAct)
 self.showErrorLogAct = EricAction(
 self.reportBugAct = EricAction(
 self.tr("Report Bug"), self.tr("Report &Bug..."), 0, 0, self, "report_bug"
 )
 self.reportBugAct.setStatusTip(self.tr("Report a bug"))
 self.reportBugAct.setWhatsThis(
-self.tr(
+self.tr("""<b>Report Bug...</b><p>Opens a dialog to report a bug.</p>""")
-"""<b>Report Bug...</b>""" """<p>Opens a dialog to report a bug.</p>"""
-)
 )
 self.reportBugAct.triggered.connect(self.__reportBug)
 self.actions.append(self.reportBugAct)
 self.requestFeatureAct = EricAction(
 self.testingActGrp,
 "unittest_script",
 )
 self.testScriptAct.setStatusTip(self.tr("Run tests of the current script"))
 self.testScriptAct.setWhatsThis(
-self.tr(
+self.tr("""<b>Test Script</b><p>Run tests with the current script.</p>""")
-"""<b>Test Script</b>""" """<p>Run tests with the current script.</p>"""
-)
 )
 self.testScriptAct.triggered.connect(self.__startTestScript)
 self.testScriptAct.setEnabled(False)
 self.actions.append(self.testScriptAct)
 self.testingActGrp,
 "unittest_project",
 )
 self.testProjectAct.setStatusTip(self.tr("Run tests of the current project"))
 self.testProjectAct.setWhatsThis(
-self.tr(
+self.tr("""<b>Test Project</b><p>Run test of the current project.</p>""")
-"""<b>Test Project</b>""" """<p>Run test of the current project.</p>"""
-)
 )
 self.testProjectAct.triggered.connect(self.__startTestProject)
 self.testProjectAct.setEnabled(False)
 self.actions.append(self.testProjectAct)
 # check for Qt5 designer and linguist
-if Utilities.isWindowsPlatform():
+if OSUtilities.isWindowsPlatform():
 designerExe = os.path.join(
-Utilities.getQtBinariesPath(),
+QtUtilities.getQtBinariesPath(),
-"{0}.exe".format(Utilities.generateQtToolName("designer")),
+"{0}.exe".format(QtUtilities.generateQtToolName("designer")),
 )
-elif Utilities.isMacPlatform():
+elif OSUtilities.isMacPlatform():
-designerExe = Utilities.getQtMacBundle("designer")
+designerExe = QtUtilities.getQtMacBundle("designer")
 else:
 designerExe = os.path.join(
-Utilities.getQtBinariesPath(), Utilities.generateQtToolName("designer")
+QtUtilities.getQtBinariesPath(),
+QtUtilities.generateQtToolName("designer"),
 )
 if os.path.exists(designerExe):
 self.designer4Act = EricAction(
 self.tr("Qt-Designer"),
 EricPixmapCache.getIcon("designer4"),
 self,
 "qt_designer4",
 )
 self.designer4Act.setStatusTip(self.tr("Start Qt-Designer"))
 self.designer4Act.setWhatsThis(
-self.tr("""<b>Qt-Designer</b>""" """<p>Start Qt-Designer.</p>""")
+self.tr("""<b>Qt-Designer</b><p>Start Qt-Designer.</p>""")
 )
 self.designer4Act.triggered.connect(self.__designer)
 self.actions.append(self.designer4Act)
 else:
 self.designer4Act = None
-if Utilities.isWindowsPlatform():
+if OSUtilities.isWindowsPlatform():
 linguistExe = os.path.join(
-Utilities.getQtBinariesPath(),
+QtUtilities.getQtBinariesPath(),
-"{0}.exe".format(Utilities.generateQtToolName("linguist")),
+"{0}.exe".format(QtUtilities.generateQtToolName("linguist")),
 )
-elif Utilities.isMacPlatform():
+elif OSUtilities.isMacPlatform():
-linguistExe = Utilities.getQtMacBundle("linguist")
+linguistExe = QtUtilities.getQtMacBundle("linguist")
 else:
 linguistExe = os.path.join(
-Utilities.getQtBinariesPath(), Utilities.generateQtToolName("linguist")
+QtUtilities.getQtBinariesPath(),
+QtUtilities.generateQtToolName("linguist"),
 )
 if os.path.exists(linguistExe):
 self.linguist4Act = EricAction(
 self.tr("Qt-Linguist"),
 EricPixmapCache.getIcon("linguist4"),
 self,
 "qt_linguist4",
 )
 self.linguist4Act.setStatusTip(self.tr("Start Qt-Linguist"))
 self.linguist4Act.setWhatsThis(
-self.tr("""<b>Qt-Linguist</b>""" """<p>Start Qt-Linguist.</p>""")
+self.tr("""<b>Qt-Linguist</b><p>Start Qt-Linguist.</p>""")
 )
 self.linguist4Act.triggered.connect(self.__linguist)
 self.actions.append(self.linguist4Act)
 else:
 self.linguist4Act = None
 self,
 "ui_previewer",
 )
 self.uipreviewerAct.setStatusTip(self.tr("Start the UI Previewer"))
 self.uipreviewerAct.setWhatsThis(
-self.tr("""<b>UI Previewer</b>""" """<p>Start the UI Previewer.</p>""")
+self.tr("""<b>UI Previewer</b><p>Start the UI Previewer.</p>""")
 )
 self.uipreviewerAct.triggered.connect(self.__UIPreviewer)
 self.actions.append(self.uipreviewerAct)
 self.trpreviewerAct = EricAction(
 self,
 "sql_browser",
 )
 self.sqlBrowserAct.setStatusTip(self.tr("Browse a SQL database"))
 self.sqlBrowserAct.setWhatsThis(
-self.tr("""<b>SQL Browser</b>""" """<p>Browse a SQL database.</p>""")
+self.tr("""<b>SQL Browser</b><p>Browse a SQL database.</p>""")
 )
 self.sqlBrowserAct.triggered.connect(self.__sqlBrowser)
 self.actions.append(self.sqlBrowserAct)
 self.miniEditorAct = EricAction(
 self.reloadAPIsAct = EricAction(
 self.tr("Reload APIs"), self.tr("Reload &APIs"), 0, 0, self, "reload_apis"
 )
 self.reloadAPIsAct.setStatusTip(self.tr("Reload the API information"))
 self.reloadAPIsAct.setWhatsThis(
-self.tr("""<b>Reload APIs</b>""" """<p>Reload the API information.</p>""")
+self.tr("""<b>Reload APIs</b><p>Reload the API information.</p>""")
 )
 self.reloadAPIsAct.triggered.connect(self.__reloadAPIs)
 self.actions.append(self.reloadAPIsAct)
 self.showExternalToolsAct = EricAction(
 def __initPySideDocActions(self):
 """
 Private slot to initialize the actions to show the PySide
 documentation.
 """
-if Utilities.checkPyside(variant=2):
+if QtUtilities.checkPyside(variant=2):
 self.pyside2DocAct = EricAction(
 self.tr("PySide2 Documentation"),
 self.tr("PySide2 Documentation"),
 0,
 0,
 )
 self.actions.append(self.pyside2DocAct)
 else:
 self.pyside2DocAct = None
-if Utilities.checkPyside(variant=6):
+if QtUtilities.checkPyside(variant=6):
 self.pyside6DocAct = EricAction(
 self.tr("PySide6 Documentation"),
 self.tr("PySide6 Documentation"),
 0,
 0,
 """
 Private slot to create the menus.
 """
 self.__menus = {}
 mb = self.menuBar()
-if Utilities.isLinuxPlatform() and not Preferences.getUI("UseNativeMenuBar"):
+if OSUtilities.isLinuxPlatform() and not Preferences.getUI("UseNativeMenuBar"):
 mb.setNativeMenuBar(False)
 ##############################################################
 ## File menu
 ##############################################################
 except AttributeError:
 sip_version_str = "sip version not available"
 sizeStr = "64-Bit" if sys.maxsize > 2**32 else "32-Bit"
-versionText = self.tr("""<h2>Version Numbers</h2>""" """<table>""")
+versionText = self.tr("""<h2>Version Numbers</h2><table>""")
 # Python version
 versionText += ("""<tr><td><b>Python</b></td><td>{0}, {1}</td></tr>""").format(
 sys.version.split()[0], sizeStr
 )
 versionText += ("""<tr><td><b>{0}</b></td><td>{1}</td></tr>""").format(
 Program, Version
 )
 # desktop and session type
-desktop = Globals.desktopName()
+desktop = DesktopUtilities.desktopName()
-session = Globals.sessionType()
+session = DesktopUtilities.sessionType()
 if desktop or session:
 versionText += "<tr><td></td><td></td></tr>"
 if desktop:
 versionText += ("<tr><td><b>{0}</b></td><td>{1}</td></tr>").format(
 self.tr("Desktop"), desktop
 user, what to do with it.
 """
 from .ErrorLogDialog import ErrorLogDialog
 if Preferences.getUI("CheckErrorLog"):
-logFile = os.path.join(Utilities.getConfigDir(), self.ErrorLogFileName)
+logFile = os.path.join(Globals.getConfigDir(), self.ErrorLogFileName)
 if os.path.exists(logFile):
 dlg = ErrorLogDialog(logFile, False, self)
 dlg.exec()
 def __hasErrorLog(self):
 """
 Private method to check, if an error log file exists.
 @return flag indicating the existence of an error log file (boolean)
 """
-logFile = os.path.join(Utilities.getConfigDir(), self.ErrorLogFileName)
+logFile = os.path.join(Globals.getConfigDir(), self.ErrorLogFileName)
 return os.path.exists(logFile)
 def __showErrorLog(self):
 """
 Private slot to show the most recent error log message.
 """
 from .ErrorLogDialog import ErrorLogDialog
-logFile = os.path.join(Utilities.getConfigDir(), self.ErrorLogFileName)
+logFile = os.path.join(Globals.getConfigDir(), self.ErrorLogFileName)
 if os.path.exists(logFile):
 dlg = ErrorLogDialog(logFile, True, self)
 dlg.show()
 def __showInstallInfo(self):
 else True
 )
 if res and self.__shutdown():
 ericApp().closeAllWindows()
-program = Globals.getPythonExecutable()
+program = PythonUtilities.getPythonExecutable()
 args = ["-m", "eric7", "--start-session"]
 args.extend(self.__restartArgs)
 QProcess.startDetached(program, args)
 @pyqtSlot()
 @param upgradeType upgrade operation (one of 'eric', 'ericpyqt',
 'pyqt')
 @type str
 """
 ericApp().closeAllWindows()
-program = Globals.getPythonExecutable()
+program = PythonUtilities.getPythonExecutable()
 ericStartArgs = ["-m", "eric7", "--start-session"]
 ericStartArgs.extend(self.__restartArgs)
 upgrader = os.path.join(os.path.dirname(__file__), "upgrader.py")
 upgraderArgs = [
 """
 Private slot to start a new instance of eric.
 """
 if not Preferences.getUI("SingleApplicationMode"):
 # start eric without loading anything and without crash session
-program = Globals.getPythonExecutable()
+program = PythonUtilities.getPythonExecutable()
 eric7 = os.path.join(os.path.dirname(__file__), "..", "eric7_ide.py")
 args = [eric7, "--no-open", "--disable-crash"]
 QProcess.startDetached(program, args)
 def __initToolsMenus(self, menu):
 " is zero length.</p>"
 ).format(fn),
 )
 return
-if Utilities.isMacPlatform():
+if OSUtilities.isMacPlatform():
-designer, args = Utilities.prepareQtMacBundle("designer", args)
+designer, args = QtUtilities.prepareQtMacBundle("designer", args)
 else:
 designer = os.path.join(
-Utilities.getQtBinariesPath(), Utilities.generateQtToolName("designer")
+QtUtilities.getQtBinariesPath(),
-)
+QtUtilities.generateQtToolName("designer"),
-if Utilities.isWindowsPlatform():
+)
+if OSUtilities.isWindowsPlatform():
 designer += ".exe"
 if designer:
 proc = QProcess()
 if not proc.startDetached(designer, args):
 " is zero length.</p>"
 ).format(fn),
 )
 return
-if Utilities.isMacPlatform():
+if OSUtilities.isMacPlatform():
-linguist, args = Utilities.prepareQtMacBundle("linguist", args)
+linguist, args = QtUtilities.prepareQtMacBundle("linguist", args)
 else:
 linguist = os.path.join(
-Utilities.getQtBinariesPath(), Utilities.generateQtToolName("linguist")
+QtUtilities.getQtBinariesPath(),
-)
+QtUtilities.generateQtToolName("linguist"),
-if Utilities.isWindowsPlatform():
+)
+if OSUtilities.isWindowsPlatform():
 linguist += ".exe"
 if linguist:
 proc = QProcess()
 if not proc.startDetached(linguist, args):
 args = []
 if home:
 args.append("-showUrl")
 args.append(home)
-if Utilities.isMacPlatform():
+if OSUtilities.isMacPlatform():
-assistant, args = Utilities.prepareQtMacBundle("assistant", args)
+assistant, args = QtUtilities.prepareQtMacBundle("assistant", args)
 else:
 assistant = os.path.join(
-Utilities.getQtBinariesPath(), Utilities.generateQtToolName("assistant")
+QtUtilities.getQtBinariesPath(),
-)
+QtUtilities.generateQtToolName("assistant"),
-if Utilities.isWindowsPlatform():
+)
+if OSUtilities.isWindowsPlatform():
 assistant += ".exe"
 if assistant:
 proc = QProcess()
 if not proc.startDetached(assistant, args):
 ).format(fn),
 )
 return
 if not os.path.isfile(viewer) or not proc.startDetached(
-Globals.getPythonExecutable(), args
+PythonUtilities.getPythonExecutable(), args
 ):
 EricMessageBox.critical(
 self,
 self.tr("Process Generation Error"),
 self.tr(
 ).format(fn),
 )
 return
 if not os.path.isfile(viewer) or not proc.startDetached(
-Globals.getPythonExecutable(), args
+PythonUtilities.getPythonExecutable(), args
 ):
 EricMessageBox.critical(
 self,
 self.tr("Process Generation Error"),
 self.tr(
 args = []
 args.append(browser)
 if not os.path.isfile(browser) or not proc.startDetached(
-Globals.getPythonExecutable(), args
+PythonUtilities.getPythonExecutable(), args
 ):
 EricMessageBox.critical(
 self,
 self.tr("Process Generation Error"),
 self.tr(
 args = []
 args.append(snap)
 if not os.path.isfile(snap) or not proc.startDetached(
-Globals.getPythonExecutable(), args
+PythonUtilities.getPythonExecutable(), args
 ):
 EricMessageBox.critical(
 self,
 self.tr("Process Generation Error"),
 self.tr(
 """
 Private slot to show the Python 3 documentation.
 """
 pythonDocDir = Preferences.getHelp("PythonDocDir")
 if not pythonDocDir:
-if Utilities.isWindowsPlatform():
+if OSUtilities.isWindowsPlatform():
 venvName = Preferences.getDebugger("Python3VirtualEnv")
 interpreter = (
 ericApp()
 .getObject("VirtualEnvManager")
 .getVirtualenvInterpreter(venvName)
 )
 if interpreter:
 default = os.path.join(os.path.dirname(interpreter), "doc")
 else:
 default = ""
-pythonDocDir = Utilities.getEnvironmentEntry("PYTHON3DOCDIR", default)
+pythonDocDir = OSUtilities.getEnvironmentEntry("PYTHON3DOCDIR", default)
 else:
-pythonDocDir = Utilities.getEnvironmentEntry(
+pythonDocDir = OSUtilities.getEnvironmentEntry(
 "PYTHON3DOCDIR", "/usr/share/doc/packages/python3/html"
 )
 if not pythonDocDir.startswith(("http://", "https://", "qthelp://")):
 if pythonDocDir.startswith("file://"):
 pythonDocDir = pythonDocDir[7:]
 if not os.path.splitext(pythonDocDir)[1]:
-home = Utilities.normjoinpath(pythonDocDir, "index.html")
+home = FileSystemUtilities.normjoinpath(pythonDocDir, "index.html")
-if Utilities.isWindowsPlatform() and not os.path.exists(home):
+if OSUtilities.isWindowsPlatform() and not os.path.exists(home):
 pyversion = sys.hexversion >> 16
 vers = "{0:d}{1:d}".format(
 (pyversion >> 8) & 0xFF, pyversion & 0xFF
 )
 home = os.path.join(pythonDocDir, "python{0}.chm".format(vers))
 ).format(home),
 )
 return
 if not home.endswith(".chm"):
-if Utilities.isWindowsPlatform():
+if OSUtilities.isWindowsPlatform():
-home = "file:///" + Utilities.fromNativeSeparators(home)
+home = "file:///" + FileSystemUtilities.fromNativeSeparators(home)
 else:
 home = "file://" + home
 else:
 home = pythonDocDir
 home = qtDocDir
 else:
 if qtDocDir.startswith("file://"):
 qtDocDir = qtDocDir[7:]
 if not os.path.splitext(qtDocDir)[1]:
-home = Utilities.normjoinpath(qtDocDir, "index.html")
+home = FileSystemUtilities.normjoinpath(qtDocDir, "index.html")
 else:
 home = qtDocDir
 if not os.path.exists(home):
 EricMessageBox.warning(
 """ "<b>{0}</b>" could not be found.</p>"""
 ).format(home),
 )
 return
-if Utilities.isWindowsPlatform():
+if OSUtilities.isWindowsPlatform():
-home = "file:///" + Utilities.fromNativeSeparators(home)
+home = "file:///" + FileSystemUtilities.fromNativeSeparators(home)
 else:
 home = "file://" + home
 hvType = Preferences.getHelp("HelpViewerType")
 if hvType == 0:
 @param variant PyQt variant to show documentation for (5 or 6)
 @type int or str
 """
 pyqtDocDir = Preferences.getHelp("PyQt{0}DocDir".format(variant))
 if not pyqtDocDir:
-pyqtDocDir = Utilities.getEnvironmentEntry(
+pyqtDocDir = OSUtilities.getEnvironmentEntry(
 "PYQT{0}DOCDIR".format(variant), None
 )
 if not pyqtDocDir:
 EricMessageBox.warning(
 if pyqtDocDir:
 if pyqtDocDir.startswith("file://"):
 pyqtDocDir = pyqtDocDir[7:]
 if not os.path.splitext(pyqtDocDir)[1]:
 possibleHomes = [
-Utilities.normjoinpath(pyqtDocDir, "index.html"),
+FileSystemUtilities.normjoinpath(pyqtDocDir, "index.html"),
-Utilities.normjoinpath(pyqtDocDir, "class_reference.html"),
+FileSystemUtilities.normjoinpath(
+pyqtDocDir, "class_reference.html"
+),
 ]
 for possibleHome in possibleHomes:
 if os.path.exists(possibleHome):
 home = possibleHome
 break
 """ "<b>{0}</b>" could not be found.</p>"""
 ).format(home),
 )
 return
-if Utilities.isWindowsPlatform():
+if OSUtilities.isWindowsPlatform():
-home = "file:///" + Utilities.fromNativeSeparators(home)
+home = "file:///" + FileSystemUtilities.fromNativeSeparators(home)
 else:
 home = "file://" + home
 else:
 home = pyqtDocDir
 """
 Private slot to show the Eric documentation.
 """
 home = Preferences.getHelp("EricDocDir")
 if not home:
-home = Utilities.normjoinpath(
+home = FileSystemUtilities.normjoinpath(
 getConfig("ericDocDir"), "Source", "index.html"
 )
 if not home.startswith(("http://", "https://", "qthelp://")):
 if not os.path.exists(home):
 """ "<b>{0}</b>" could not be found.</p>"""
 ).format(home),
 )
 return
-if Utilities.isWindowsPlatform():
+if OSUtilities.isWindowsPlatform():
-home = "file:///" + Utilities.fromNativeSeparators(home)
+home = "file:///" + FileSystemUtilities.fromNativeSeparators(home)
 else:
 home = "file://" + home
 hvType = Preferences.getHelp("HelpViewerType")
 if hvType == 0:
 @param variant PySide variant (2 or 6)
 @type int or str
 """
 pysideDocDir = Preferences.getHelp("PySide{0}DocDir".format(variant))
 if not pysideDocDir:
-pysideDocDir = Utilities.getEnvironmentEntry(
+pysideDocDir = OSUtilities.getEnvironmentEntry(
 "PYSIDE{0}DOCDIR".format(variant), None
 )
 if not pysideDocDir:
 EricMessageBox.warning(
 if not pysideDocDir.startswith(("http://", "https://", "qthelp://")):
 if pysideDocDir.startswith("file://"):
 pysideDocDir = pysideDocDir[7:]
 if not os.path.splitext(pysideDocDir)[1]:
-home = Utilities.normjoinpath(pysideDocDir, "index.html")
+home = FileSystemUtilities.normjoinpath(pysideDocDir, "index.html")
 else:
 home = pysideDocDir
 if not os.path.exists(home):
 EricMessageBox.warning(
 self,
 """ "<b>{0}</b>" could not be found.</p>"""
 ).format(home),
 )
 return
-if Utilities.isWindowsPlatform():
+if OSUtilities.isWindowsPlatform():
-home = "file:///" + Utilities.fromNativeSeparators(home)
+home = "file:///" + FileSystemUtilities.fromNativeSeparators(home)
 else:
 home = "file://" + home
 else:
 home = pysideDocDir
 "--qthelp",
 "--single",
 "--name={0}".format(self.__webBrowserSAName),
 home,
 ]
-process.start(Globals.getPythonExecutable(), args)
+process.start(PythonUtilities.getPythonExecutable(), args)
 if not process.waitForStarted():
 EricMessageBox.warning(
 self,
 self.tr("Start Web Browser"),
-self.tr(
+self.tr("""The eric web browser could not be started."""),
-"""The eric web browser could not be""" """ started."""
-),
 )
 return False
 res = self.__connectToWebBrowser(process)
 if res == 1:
 fn = EricFileDialog.getOpenFileName(
 None,
 self.tr("Import Keyboard Shortcuts"),
 "",
 self.tr(
-"Keyboard Shortcuts File (*.ekj);;" "XML Keyboard shortcut file (*.e4k)"
+"Keyboard Shortcuts File (*.ekj);;XML Keyboard shortcut file (*.e4k)"
 ),
 )
 if fn:
 Shortcuts.importShortcuts(fn)
 def __writeTasks(self):
 """
 Private slot to write the tasks data to a JSON file (.etj).
 """
-fn = os.path.join(Utilities.getConfigDir(), "eric7tasks.etj")
+fn = os.path.join(Globals.getConfigDir(), "eric7tasks.etj")
 self.__tasksFile.writeFile(fn)
 def __readTasks(self):
 """
 Private slot to read in the tasks file (.etj or .e6t).
 """
-fn = os.path.join(Utilities.getConfigDir(), "eric7tasks.etj")
+fn = os.path.join(Globals.getConfigDir(), "eric7tasks.etj")
 if os.path.exists(fn):
 # try new style JSON file first
 self.__tasksFile.readFile(fn)
 else:
 # try old style XML file second
-fn = os.path.join(Utilities.getConfigDir(), "eric7tasks.e6t")
+fn = os.path.join(Globals.getConfigDir(), "eric7tasks.e6t")
 if os.path.exists(fn):
 f = QFile(fn)
 if f.open(QIODevice.OpenModeFlag.ReadOnly):
 reader = TasksReader(f, viewer=self.taskViewer)
 reader.readXML()
 else:
 EricMessageBox.critical(
 self,
 self.tr("Read Tasks"),
 self.tr(
-"<p>The tasks file <b>{0}</b> could not be" " read.</p>"
+"<p>The tasks file <b>{0}</b> could not be read.</p>"
 ).format(fn),
 )
 def __writeSession(self, filename="", crashSession=False):
 """
 @rtype bool
 """
 if filename:
 fn = filename
 elif crashSession:
-fn = os.path.join(Utilities.getConfigDir(), "eric7_crash_session.esj")
+fn = os.path.join(Globals.getConfigDir(), "eric7_crash_session.esj")
 else:
-fn = os.path.join(Utilities.getConfigDir(), "eric7session.esj")
+fn = os.path.join(Globals.getConfigDir(), "eric7session.esj")
 return self.__sessionFile.writeFile(fn)
 def __readSession(self, filename=""):
 """
 @rtype bool
 """
 if filename:
 fn = filename
 else:
-fn = os.path.join(Utilities.getConfigDir(), "eric7session.esj")
+fn = os.path.join(Globals.getConfigDir(), "eric7session.esj")
 if not os.path.exists(fn):
-fn = os.path.join(Utilities.getConfigDir(), "eric7session.e5s")
+fn = os.path.join(Globals.getConfigDir(), "eric7session.e5s")
 if not os.path.exists(fn):
 EricMessageBox.critical(
 self,
 self.tr("Read Session"),
 self.tr(
-"<p>The session file <b>{0}</b> could not" " be read.</p>"
+"<p>The session file <b>{0}</b> could not be read.</p>"
 ).format(fn),
 )
 fn = ""
 res = False
 else:
 EricMessageBox.critical(
 self,
 self.tr("Read session"),
 self.tr(
-"<p>The session file <b>{0}</b> could not be" " read.</p>"
+"<p>The session file <b>{0}</b> could not be read.</p>"
 ).format(fn),
 )
 # Write a crash session after a session was read.
 self.__writeCrashSession()
 Private slot to save a session to disk.
 """
 sessionFile, selectedFilter = EricFileDialog.getSaveFileNameAndFilter(
 self,
 self.tr("Save Session"),
-Utilities.getHomeDir(),
+OSUtilities.getHomeDir(),
 self.tr("eric Session Files (*.esj)"),
 "",
 )
 if not sessionFile:
 Private slot to load a session from disk.
 """
 sessionFile = EricFileDialog.getOpenFileName(
 self,
 self.tr("Load session"),
-Utilities.getHomeDir(),
+OSUtilities.getHomeDir(),
-self.tr("eric Session Files (*.esj);;" "eric XML Session Files (*.e5s)"),
+self.tr("eric Session Files (*.esj);;eric XML Session Files (*.e5s)"),
 )
 if not sessionFile:
 return
 def __deleteCrashSession(self):
 """
 Private slot to delete the crash session file.
 """
 for ext in (".esj", ".e5s"):
-fn = os.path.join(Utilities.getConfigDir(), f"eric7_crash_session{ext}")
+fn = os.path.join(Globals.getConfigDir(), f"eric7_crash_session{ext}")
 if os.path.exists(fn):
 with contextlib.suppress(OSError):
 os.remove(fn)
 def __writeCrashSession(self):
 if (
 not self.__disableCrashSession
 and not self.__noCrashOpenAtStartup
 and Preferences.getUI("OpenCrashSessionOnStartup")
 ):
-fn = os.path.join(Utilities.getConfigDir(), "eric7_crash_session.esj")
+fn = os.path.join(Globals.getConfigDir(), "eric7_crash_session.esj")
 if os.path.exists(fn):
 yes = EricMessageBox.yesNo(
 self,
 self.tr("Crash Session found!"),
 self.tr(
 del self.__pluginInstallDialog
 self.__restart(ask=True)
 self.pluginRepositoryViewer.reloadList()
+if self.__findFileWidget:
+self.__findFileWidget.populateFileCategories()
+if self.__findFileDialog:
+self.__findFileDialog.populateFileCategories()
 def __deinstallPlugin(self):
 """
 Private slot to show a dialog to uninstall a plugin.
 """
 from eric7.PluginManager.PluginUninstallDialog import PluginUninstallDialog
 dlg = PluginUninstallDialog(self.pluginManager, self)
 dlg.exec()
+if self.__findFileWidget:
+self.__findFileWidget.populateFileCategories()
+if self.__findFileDialog:
+self.__findFileDialog.populateFileCategories()
 @pyqtSlot()
 def __showPluginsAvailable(self):
 """
 Private slot to show the plugins available for download.
 # eric hasn't been configured at all
 self.checkConfigurationStatus()
 workspace = Preferences.getMultiProject("Workspace")
 if workspace == "":
-default = Utilities.getHomeDir()
+default = OSUtilities.getHomeDir()
 workspace = EricFileDialog.getExistingDirectory(
 None,
 self.tr("Select Workspace Directory"),
 default,
 EricFileDialog.Option(0),
 return True
 else:
 vers = VersionOnly.split("snapshot-")[1]
 return vers > snapshot
-versionTuple = self.__versionToTuple(VersionOnly)
+versionTuple = Globals.versionToTuple(VersionOnly)
 if isinstance(required, str):
-required = self.__versionToTuple(required)
+required = Globals.versionToTuple(required)
 try:
 res = versionTuple > required
 except TypeError:
 # some mismatching types, assume newer
 res = True
 return res
-def __versionToTuple(self, version):
-"""
-Private method to convert a version string into a tuple.
-@param version version string
-@type str
-@return version tuple
-@rtype tuple of int
-"""
-versionParts = []
-for part in version.split("."):
-part = part.strip()
-if part:
-try:
-part = int(part)
-except ValueError:
-# not an integer, ignore
-continue
-versionParts.append(part)
-return tuple(versionParts)
 #################################
 ## Below are some utility methods
 #################################
 if self.viewmanager.hasDirtyEditor():
 if manager.allowsInteraction():
 res = EricMessageBox.warning(
 self,
 self.tr("Unsaved Data Detected"),
-self.tr(
+self.tr("Some editors contain unsaved data. Shall these be saved?"),
-"Some editors contain unsaved data. Shall these" " be saved?"
-),
 EricMessageBox.Abort
 | EricMessageBox.Discard
 | EricMessageBox.Save
 | EricMessageBox.SaveAll,
 EricMessageBox.SaveAll,

Mercurial Repositories > eric / file comparison

comparison: src/eric7/UI/UserInterface.py

src/eric7/UI/UserInterface.py