eric: comparison src/eric7/Toolbox/Startup.py

-:e9e7eca7efee
+:bf71ee032bb4
 def usage(appinfo, optlen=12):
 """
 Module function to show the usage information.
 @param appinfo dictionary describing the application
 @param optlen length of the field for the commandline option (integer)
 """
 options = [
 ("--version", "show the program's version number and exit"),
-("-h, --help", "show this help message and exit")
+("-h, --help", "show this help message and exit"),
 ]
 options.extend(appinfo["options"])
-print("""\n"""
+print(
-"""Usage: {bin} [OPTIONS] {arg}\n"""
+"""\n"""
-"""\n"""
+"""Usage: {bin} [OPTIONS] {arg}\n"""
-"""{name} - {description}\n"""
+"""\n"""
-"""\n"""
+"""{name} - {description}\n"""
-"""Options:""".format(**appinfo))
+"""\n"""
+"""Options:""".format(**appinfo)
+)
 for opt in options:
 print("  {0}  {1}".format(opt[0].ljust(optlen), opt[1]))
 sys.exit(0)
 def version(appinfo):
 """
 Module function to show the version information.
 @param appinfo dictionary describing the application
 """
-print("""\n"""
+print(
-"""{name} {version}\n"""
+"""\n"""
-"""\n"""
+"""{name} {version}\n"""
-"""{description}\n"""
+"""\n"""
-"""\n"""
+"""{description}\n"""
-"""Copyright (c) 2002 - 2022 Detlev Offenbach"""
+"""\n"""
-""" <detlev@die-offenbachs.de>\n"""
+"""Copyright (c) 2002 - 2022 Detlev Offenbach"""
-"""This is free software; see LICENSE.GPL3 for copying"""
+""" <detlev@die-offenbachs.de>\n"""
-""" conditions.\n"""
+"""This is free software; see LICENSE.GPL3 for copying"""
-"""There is NO warranty; not even for MERCHANTABILITY or FITNESS"""
+""" conditions.\n"""
-""" FOR A\n"""
+"""There is NO warranty; not even for MERCHANTABILITY or FITNESS"""
-"""PARTICULAR PURPOSE.""".format(**appinfo))
+""" FOR A\n"""
+"""PARTICULAR PURPOSE.""".format(**appinfo)
+)
 sys.exit(0)
 def handleArgs(argv, appinfo):
 """
 Module function to handle the always present commandline options.
 @param argv list of commandline parameters (list of strings)
 @param appinfo dictionary describing the application
 @return index of the '--' option (integer). This is used to tell
 the application, that all additional options don't belong to
 the application.
 """
-ddindex = 30000     # arbitrarily large number
+ddindex = 30000  # arbitrarily large number
-args = {
+args = {"--version": version, "--help": usage, "-h": usage}
-"--version": version,
+if "--" in argv:
-"--help": usage,
-"-h": usage
-}
-if '--' in argv:
 ddindex = argv.index("--")
 for a in args:
 if a in argv and argv.index(a) < ddindex:
 args[a](appinfo)
 return ddindex
 trans = QTranslator(None)
 for directory in dirs:
 loaded = trans.load(tn, directory)
 if loaded:
 return (trans, True)
 print("Warning: translation file '" + tn + "'could not be loaded.")
 print("Using default.")
 return (None, False)
 def initializeResourceSearchPath(application):
 """
 Module function to initialize the default mime source factory.
 @param application reference to the application object
 @type EricApplication
 """
 import Preferences
 defaultIconPaths = getDefaultIconPaths(application)
 iconPaths = Preferences.getIcons("Path")
 for iconPath in iconPaths:
 if iconPath:
 UI.PixmapCache.addSearchPath(iconPath)
 def getDefaultIconPaths(application):
 """
 Module function to determine the default icon paths.
 @param application reference to the application object
 @type EricApplication
 @return list of default icon paths
 @rtype list of str
 """
 import Preferences
 defaultIconsPath = Preferences.getIcons("DefaultIconsPath")
 if defaultIconsPath == "automatic":
 if application.usesDarkPalette():
 # dark desktop
 defaultIconsPath = "breeze-dark"
 else:
 # light desktop
 defaultIconsPath = "breeze-light"
 return [
-os.path.join(getConfig('ericIconDir'), defaultIconsPath),
+os.path.join(getConfig("ericIconDir"), defaultIconsPath),
-os.path.join(getConfig('ericIconDir'), defaultIconsPath, "languages"),
+os.path.join(getConfig("ericIconDir"), defaultIconsPath, "languages"),
 ]
 def setLibraryPaths():
 """
 """
 libPaths = (
 os.path.join(Globals.getPyQt6ModulesDirectory(), "plugins"),
 os.path.join(Globals.getPyQt6ModulesDirectory(), "Qt6", "plugins"),
 )
 libraryPaths = QApplication.libraryPaths()
 for libPath in libPaths:
 if os.path.exists(libPath):
 libPath = QDir.fromNativeSeparators(libPath)
 if libPath not in libraryPaths:
 libraryPaths.insert(0, libPath)
 QApplication.setLibraryPaths(libraryPaths)
 # the translator must not be deleted, therefore we save them here
 loaded_translators = {}
 def loadTranslators(qtTransDir, app, translationFiles=()):
 """
 Module function to load all required translations.
 @param qtTransDir directory of the Qt translations files (string)
 @param app reference to the application object (QApplication)
 @param translationFiles tuple of additional translations to
 be loaded (tuple of strings)
 @return the requested locale (string)
 """
 import Preferences
 global loaded_translators
 translations = (
-"qt", "qt_help", "qtbase", "qtmultimedia", "qtserialport",
+"qt",
-"qtwebengine", "qtwebsockets", "eric7"
+"qt_help",
+"qtbase",
+"qtmultimedia",
+"qtserialport",
+"qtwebengine",
+"qtwebsockets",
+"eric7",
 ) + translationFiles
 loc = Preferences.getUILanguage()
 if loc is None:
 return ""
 if loc == "System":
 loc = QLocale.system().name()
 if loc != "C":
-dirs = [getConfig('ericTranslationsDir'), Globals.getConfigDir()]
+dirs = [getConfig("ericTranslationsDir"), Globals.getConfigDir()]
 if qtTransDir is not None:
 dirs.append(qtTransDir)
 loca = loc
 for tf in ["{0}_{1}".format(tr, loc) for tr in translations]:
 else:
 loc = None
 return loc
-def simpleAppStartup(argv, appinfo, mwFactory, quitOnLastWindowClosed=True,
+def simpleAppStartup(
-app=None, raiseIt=True, installErrorHandler=False):
+argv,
+appinfo,
+mwFactory,
+quitOnLastWindowClosed=True,
+app=None,
+raiseIt=True,
+installErrorHandler=False,
+):
 """
 Module function to start up an application that doesn't need a specialized
 start up.
 This function is used by all of eric's helper programs.
 @param argv list of commandline parameters (list of strings)
 @param appinfo dictionary describing the application
 @param mwFactory factory function generating the main widget. This
 function must accept the following parameter.
 <dl>
 @param installErrorHandler flag indicating to install an error
 handler dialog (boolean)
 @return exit result (integer)
 """
 global application
 if "__PYVENV_LAUNCHER__" in os.environ:
 del os.environ["__PYVENV_LAUNCHER__"]
 handleArgs(argv, appinfo)
 if app is None:
 # set the library paths for plugins
 setLibraryPaths()
 app = EricApplication(argv)
 application = app
 app.setQuitOnLastWindowClosed(quitOnLastWindowClosed)
 # the following code depends upon a valid application object
 import Preferences
 # set the application style sheet
 app.setStyleSheetFile(Preferences.getUI("StyleSheet"))
 initializeResourceSearchPath(app)
 QApplication.setWindowIcon(UI.PixmapCache.getIcon("eric"))
 qtTransDir = Preferences.getQtTranslationsDir()
 if not qtTransDir:
-qtTransDir = QLibraryInfo.path(
+qtTransDir = QLibraryInfo.path(QLibraryInfo.LibraryPath.TranslationsPath)
-QLibraryInfo.LibraryPath.TranslationsPath)
 loadTranslators(qtTransDir, app, ("qscintilla",))
 # qscintilla needed for web browser
 w = mwFactory(argv)
 if w is None:
 return 100
 if quitOnLastWindowClosed:
 app.lastWindowClosed.connect(app.quit)
 w.show()
 if raiseIt:
 w.raise_()
 if installErrorHandler:
 # generate a graphical error handler
 from EricWidgets import EricErrorMessage
 eMsg = EricErrorMessage.qtHandler()
 eMsg.setMinimumSize(600, 400)
 return app.exec()
 #
 # eflag: noqa = M801

Mercurial Repositories > eric / file comparison

comparison: src/eric7/Toolbox/Startup.py

src/eric7/Toolbox/Startup.py