eric: comparison UI/UserInterface.py

-:092aa8fafa4e
+:f6ccc31d6e72
 from E4XML.SessionWriter import SessionWriter
 from E4XML.SessionHandler import SessionHandler
 from IconEditor.IconEditorWindow import IconEditorWindow
-from eric4config import getConfig
+from eric5config import getConfig
 class Redirector(QObject):
 """
 Helper class used to redirect stdout and stderr to the log window
 @param args list of files to open<br />
 The args are processed one at a time. All arguments after a
 '--' option are considered debug arguments to the program
 for the debugger. All files named before the '--' option
 are opened in a text editor, unless the argument ends in
-.e3p, .e3pz, .e4p or .e4pz, then it is opened as a project file.
+.e4p or .e4pz, then it is opened as a project file.
 If it ends in .e4m or .e4mz, it is opened as a multiproject.
 """
 # no args, return
 if args is None:
 if not self.__noOpenAtStartup:
 continue
 ext = os.path.splitext(arg)[1]
 ext = os.path.normcase(ext)
-if ext in ['.e4p', '.e4pz', '.e3p', '.e3pz']:
+if ext in ['.e4p', '.e4pz']:
 self.project.openProject(arg)
 opens += 1
 elif ext in ['.e4m', '.e4mz']:
 self.multiProject.openMultiProject(arg)
 opens += 1
 QKeySequence(self.trUtf8("F1")),
 0, self, 'helpviewer')
 self.helpviewerAct.setStatusTip(self.trUtf8('Open the helpviewer window'))
 self.helpviewerAct.setWhatsThis(self.trUtf8(
 """<b>Helpviewer</b>"""
-"""<p>Display the eric4 web browser. This window will show"""
+"""<p>Display the eric5 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 collection.</p>"""
 self.checkUpdateAct = E4Action(self.trUtf8('Check for Updates'),
 self.trUtf8('Check for &Updates...'), 0, 0, self, 'check_updates')
 self.checkUpdateAct.setStatusTip(self.trUtf8('Check for Updates'))
 self.checkUpdateAct.setWhatsThis(self.trUtf8(
 """<b>Check for Updates...</b>"""
-"""<p>Checks the internet for updates of eric4.</p>"""
+"""<p>Checks the internet for updates of eric5.</p>"""
 ))
 self.connect(self.checkUpdateAct, SIGNAL('triggered()'), self.performVersionCheck)
 self.actions.append(self.checkUpdateAct)
 self.showVersionsAct = E4Action(self.trUtf8('Show downloadable versions'),
 0, 0, self, 'show_downloadable_versions')
 self.showVersionsAct.setStatusTip(\
 self.trUtf8('Show the versions available for download'))
 self.showVersionsAct.setWhatsThis(self.trUtf8(
 """<b>Show downloadable versions...</b>"""
-"""<p>Shows the eric4 versions available for download """
+"""<p>Shows the eric5 versions available for download """
 """from the internet.</p>"""
 ))
 self.connect(self.showVersionsAct, SIGNAL('triggered()'),
 self.showAvailableVersionsInfo)
 self.actions.append(self.showVersionsAct)
 self.webBrowserAct = E4Action(self.trUtf8('Web Browser'),
 UI.PixmapCache.getIcon("ericWeb.png"),
 self.trUtf8('&Web Browser...'),
 0, 0, self, 'web_browser')
-self.webBrowserAct.setStatusTip(self.trUtf8('Start the eric4 Web Browser'))
+self.webBrowserAct.setStatusTip(self.trUtf8('Start the eric5 Web Browser'))
 self.webBrowserAct.setWhatsThis(self.trUtf8(
 """<b>Web Browser</b>"""
-"""<p>Browse the Internet with the eric4 Web Browser.</p>"""
+"""<p>Browse the Internet with the eric5 Web Browser.</p>"""
 ))
 self.connect(self.webBrowserAct, SIGNAL('triggered()'), self.__webBrowser)
 self.actions.append(self.webBrowserAct)
 self.iconEditorAct = E4Action(self.trUtf8('Icon Editor'),
 UI.PixmapCache.getIcon("iconEditor.png"),
 self.trUtf8('&Icon Editor...'),
 0, 0, self, 'icon_editor')
-self.iconEditorAct.setStatusTip(self.trUtf8('Start the eric4 Icon Editor'))
+self.iconEditorAct.setStatusTip(self.trUtf8('Start the eric5 Icon Editor'))
 self.iconEditorAct.setWhatsThis(self.trUtf8(
 """<b>Icon Editor</b>"""
-"""<p>Starts the eric4 Icon Editor for editing simple icons.</p>"""
+"""<p>Starts the eric5 Icon Editor for editing simple icons.</p>"""
 ))
 self.connect(self.iconEditorAct, SIGNAL('triggered()'), self.__editPixmap)
 self.actions.append(self.iconEditorAct)
 self.prefAct = E4Action(self.trUtf8('Preferences'),
 self.trUtf8('Show external &tools'), 0, 0, self, 'show_external_tools')
 self.showExternalToolsAct.setStatusTip(self.trUtf8('Reload the API information'))
 self.showExternalToolsAct.setWhatsThis(self.trUtf8(
 """<b>Show external tools</b>"""
 """<p>Opens a dialog to show the path and versions of all"""
-""" extenal tools used by eric4.</p>"""
+""" extenal tools used by eric5.</p>"""
 ))
 self.connect(self.showExternalToolsAct, SIGNAL('triggered()'),
 self.__showExternalTools)
 self.actions.append(self.showExternalToolsAct)
 self.connect(self.pythonDocAct, SIGNAL('triggered()'), self.__showPythonDoc)
 self.actions.append(self.pythonDocAct)
 def __initEricDocAction(self):
 """
-Private slot to initialize the action to show the eric4 documentation.
+Private slot to initialize the action to show the eric5 documentation.
 """
 self.ericDocAct = E4Action(self.trUtf8("Eric API Documentation"),
 self.trUtf8('&Eric API Documentation'), 0, 0, self, 'eric_documentation')
 self.ericDocAct.setStatusTip(self.trUtf8("Open Eric API Documentation"))
 self.ericDocAct.setWhatsThis(self.trUtf8(
 """<b>Eric API Documentation</b>"""
 """<p>Display the Eric API documentation."""
 """ The location for the documentation is the Documentation/Source"""
-""" subdirectory of the eric4 installation directory.</p>"""
+""" subdirectory of the eric5 installation directory.</p>"""
 ))
 self.connect(self.ericDocAct, SIGNAL('triggered()'), self.__showEricDoc)
 self.actions.append(self.ericDocAct)
 def __initPySideDocActions(self):
 """
 Public method to check for the presence of an error log and ask the user,
 what to do with it.
 """
 if Preferences.getUI("CheckErrorLog"):
-logFile = os.path.join(Utilities.getConfigDir(), "eric4_error.log")
+logFile = os.path.join(Utilities.getConfigDir(), "eric5_error.log")
 if os.path.exists(logFile):
 dlg = QMessageBox(QMessageBox.Question, self.trUtf8("Error log found"),
 self.trUtf8("An error log file was found. "
 "What should be done with it?"))
 try:
 QMessageBox.Yes)
 if res == QMessageBox.Yes and self.__shutdown():
 e4App().closeAllWindows()
 program = sys.executable
-eric4 = os.path.join(getConfig("ericDir"), "eric4.py")
+eric5 = os.path.join(getConfig("ericDir"), "eric5.py")
-args = [eric4]
+args = [eric5]
 args.append("--start-session")
 args.extend(self.__restartArgs)
 QProcess.startDetached(program, args)
 def __showToolsMenu(self):
 pass
 if version == 3:
 QMessageBox.information(None,
 self.trUtf8("Qt 3 support"),
-self.trUtf8("""Qt v.3 is not supported by eric4."""))
+self.trUtf8("""Qt v.3 is not supported by eric5."""))
 return
 args = []
 if fn is not None:
 try:
 @param version indication for the requested version (Qt 4) (integer)
 """
 if version < 4:
 QMessageBox.information(None,
 self.trUtf8("Qt 3 support"),
-self.trUtf8("""Qt v.3 is not supported by eric4."""))
+self.trUtf8("""Qt v.3 is not supported by eric5."""))
 return
 args = []
 if fn is not None:
 fn = fn.replace('.qm', '.ts')
 @param version indication for the requested version (Qt 4) (integer)
 """
 if version < 4:
 QMessageBox.information(None,
 self.trUtf8("Qt 3 support"),
-self.trUtf8("""Qt v.3 is not supported by eric4."""))
+self.trUtf8("""Qt v.3 is not supported by eric5."""))
 return
 args = []
 if home:
 if version == 4:
 @param fn filename of the form to be previewed (string)
 """
 proc = QProcess()
-viewer = os.path.join(getConfig("ericDir"), "eric4-uipreviewer.py")
+viewer = os.path.join(getConfig("ericDir"), "eric5-uipreviewer.py")
 args = []
 args.append(viewer)
 if fn is not None:
 (list of strings)
 @param ignore flag indicating non existing files should be ignored (boolean)
 """
 proc = QProcess()
-viewer = os.path.join(getConfig("ericDir"), "eric4-trpreviewer.py")
+viewer = os.path.join(getConfig("ericDir"), "eric5-trpreviewer.py")
 args = []
 args.append(viewer)
 if fileNames is not None:
 """
 Private slot to start the SQL browser tool.
 """
 proc = QProcess()
-browser = os.path.join(getConfig("ericDir"), "eric4-sqlbrowser.py")
+browser = os.path.join(getConfig("ericDir"), "eric5-sqlbrowser.py")
 args = []
 args.append(browser)
 if not os.path.isfile(browser) or not proc.startDetached(sys.executable, args):
 self.launchHelpViewer("", searchWord = searchWord)
 def __webBrowser(self):
 """
-Private slot to start the eric4 web browser.
+Private slot to start the eric5 web browser.
 """
 self.launchHelpViewer("")
 def showPreferences(self, pageName = None):
 """
 """
 self.emit(SIGNAL('reloadAPIs'))
 def __showExternalTools(self):
 """
-Private slot to display a dialog show a list of external tools used by eric4.
+Private slot to display a dialog show a list of external tools used by eric5.
 """
 self.programsDialog.show()
 def __configViewProfiles(self):
 """
 """
 fn, selectedFilter = QFileDialog.getSaveFileNameAndFilter(\
 None,
 self.trUtf8("Export Keyboard Shortcuts"),
 "",
-self.trUtf8("eric4 keyboard shortcut file (*.e4k);;"
+self.trUtf8("Keyboard shortcut file (*.e4k);;"
-"Compressed eric4 keyboard shortcut file (*.e4kz)"),
+"Compressed keyboard shortcut file (*.e4kz)"),
 "",
 QFileDialog.Options(QFileDialog.DontConfirmOverwrite))
 if not fn:
 return
 """
 fn = QFileDialog.getOpenFileName(\
 None,
 self.trUtf8("Import Keyboard Shortcuts"),
 "",
-self.trUtf8("eric4 keyboard shortcut file (*.e4k *.e4kz);;"
+self.trUtf8("Keyboard shortcut file (*.e4k *.e4kz)"))
-"eric3 keyboard shortcut file (*.e3k *.e3kz)"))
 if fn:
 Shortcuts.importShortcuts(fn)
 def __newProject(self):
 def __writeTasks(self):
 """
 Private slot to write the tasks data to an XML file (.e4t).
 """
 try:
-fn = os.path.join(Utilities.getConfigDir(), "eric4tasks.e4t")
+fn = os.path.join(Utilities.getConfigDir(), "eric5tasks.e4t")
 f = open(fn, "w")
 TasksWriter(f, False).writeXML()
 f.close()
 def __readTasks(self):
 """
 Private slot to read in the tasks file (.e4t)
 """
 try:
-fn = os.path.join(Utilities.getConfigDir(), "eric4tasks.e4t")
+fn = os.path.join(Utilities.getConfigDir(), "eric5tasks.e4t")
 if not os.path.exists(fn):
 return
 f = open(fn, "r")
 line = f.readline()
 dtdLine = f.readline()
 def __writeSession(self):
 """
 Private slot to write the session data to an XML file (.e4s).
 """
 try:
-fn = os.path.join(Utilities.getConfigDir(), "eric4session.e4s")
+fn = os.path.join(Utilities.getConfigDir(), "eric5session.e4s")
 f = open(fn, "w")
 SessionWriter(f, None).writeXML()
 f.close()
 def __readSession(self):
 """
 Private slot to read in the session file (.e4s)
 """
 try:
-fn = os.path.join(Utilities.getConfigDir(), "eric4session.e4s")
+fn = os.path.join(Utilities.getConfigDir(), "eric5session.e4s")
 if not os.path.exists(fn):
 QMessageBox.critical(None,
 self.trUtf8("Read session"),
 self.trUtf8("<p>The session file <b>{0}</b> could not be read.</p>")\
 .format(fn))
 ## Below are methods to check for new versions
 ##############################################
 def showAvailableVersionsInfo(self):
 """
-Public method to show the eric4 versions available for download.
+Public method to show the eric5 versions available for download.
 """
 self.performVersionCheck(manual = True, showVersions = True)
 def performVersionCheck(self, manual = True,  alternative = 0, showVersions = False):
 """
-Public method to check the internet for an eric4 update.
+Public method to check the internet for an eric5 update.
 @param manual flag indicating an invocation via the menu (boolean)
 @param alternative index of server to download from (integer)
 @keyparam showVersion flag indicating the show versions mode (boolean)
 """
 if "-snapshot-" in Version:
 # check snapshot version
 if versions[2] > Version:
 res = QMessageBox.information(None,
 self.trUtf8("Update available"),
-self.trUtf8("""The update to <b>{0}</b> of eric4 is available"""
+self.trUtf8("""The update to <b>{0}</b> of eric5 is available"""
 """ at <b>{1}</b>. Would you like to get it?""")\
 .format(versions[2], versions[3]),
 QMessageBox.StandardButtons(\
 QMessageBox.No | \
 QMessageBox.Yes),
 QMessageBox.Yes)
 url = res == QMessageBox.Yes and versions[3] or ''
 elif versions[0] > Version:
 res = QMessageBox.information(None,
 self.trUtf8("Update available"),
-self.trUtf8("""The update to <b>{0}</b> of eric4 is available"""
+self.trUtf8("""The update to <b>{0}</b> of eric5 is available"""
 """ at <b>{1}</b>. Would you like to get it?""")\
 .format(versions[0], versions[1]),
 QMessageBox.StandardButtons(\
 QMessageBox.No | \
 QMessageBox.Yes),
 url = res == QMessageBox.Yes and versions[1] or ''
 else:
 if self.manualUpdatesCheck:
 QMessageBox.information(None,
 self.trUtf8("Eric4 is up to date"),
-self.trUtf8("""You are using the latest version of eric4"""))
+self.trUtf8("""You are using the latest version of eric5"""))
 else:
 # check release version
 if versions[0] > Version:
 res = QMessageBox.information(None,
 self.trUtf8("Update available"),
-self.trUtf8("""The update to <b>{0}</b> of eric4 is available"""
+self.trUtf8("""The update to <b>{0}</b> of eric5 is available"""
 """ at <b>{1}</b>. Would you like to get it?""")\
 .format(versions[0], versions[1]),
 QMessageBox.StandardButtons(\
 QMessageBox.No | \
 QMessageBox.Yes),
 url = res == QMessageBox.Yes and versions[1] or ''
 else:
 if self.manualUpdatesCheck:
 QMessageBox.information(None,
 self.trUtf8("Eric4 is up to date"),
-self.trUtf8("""You are using the latest version of eric4"""))
+self.trUtf8("""You are using the latest version of eric5"""))
 except IndexError:
 QMessageBox.warning(None,
 self.trUtf8("Error during updates check"),
 self.trUtf8("""Could not perform updates check."""))
 ## Below are methods for various checks
 #######################################
 def checkConfigurationStatus(self):
 """
-Public method to check, if eric4 has been configured. If it is not,
+Public method to check, if eric5 has been configured. If it is not,
 the configuration dialog is shown.
 """
 if not Preferences.isConfigured():
 QMessageBox.information(None,
 self.trUtf8("First time usage"),
-self.trUtf8("""eric4 has not been configured yet. """
+self.trUtf8("""eric5 has not been configured yet. """
 """The configuration dialog will be started."""),
 QMessageBox.StandardButtons(\
 QMessageBox.Ok))
 self.showPreferences()
 def versionIsNewer(self, required, snapshot = None):
 """
-Public method to check, if the eric4 version is good compared to
+Public method to check, if the eric5 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 one

Mercurial Repositories > eric / file comparison

comparison: UI/UserInterface.py

UI/UserInterface.py