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

-:9c1f429cb56b
+:b47dfa7a137d
 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
 # 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.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.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"),
 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
 ##############################################################
 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("""The eric web browser could not be started."""),
 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()
 @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(
 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)"),
 )
 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(
 # 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),

Mercurial Repositories > eric / file comparison

comparison: src/eric7/UI/UserInterface.py

src/eric7/UI/UserInterface.py