eric: comparison eric7/Project/Project.py

-:8a7677a63c8d
+:68ec9c3d4de5
 from PyQt6.QtWidgets import (
 QLineEdit, QToolBar, QDialog, QInputDialog, QApplication, QMenu
 )
 from PyQt6.Qsci import QsciScintilla
-from E5Gui.E5Application import e5App
+from E5Gui.EricApplication import ericApp
-from E5Gui import E5FileDialog, E5MessageBox
+from E5Gui import EricFileDialog, EricMessageBox
-from E5Gui.E5ListSelectionDialog import E5ListSelectionDialog
+from E5Gui.EricListSelectionDialog import EricListSelectionDialog
-from E5Gui.E5ProgressDialog import E5ProgressDialog
+from E5Gui.EricProgressDialog import EricProgressDialog
-from E5Gui.E5OverrideCursor import E5OverrideCursor, E5OverridenCursor
+from E5Gui.EricOverrideCursor import EricOverrideCursor, EricOverridenCursor
 from Globals import recentNameProject
 import UI.PixmapCache
 from UI.NotificationWidget import NotificationTypes
-from E5Gui.E5Action import E5Action, createActionGroup
+from E5Gui.EricAction import EricAction, createActionGroup
 import Preferences
 import Utilities
 from .ProjectFile import ProjectFile
 project type (list of string)
 """
 if progLanguages:
 for progLanguage in progLanguages:
 if progLanguage not in self.__projectProgLanguages:
-E5MessageBox.critical(
+EricMessageBox.critical(
 self.ui,
 self.tr("Registering Project Type"),
 self.tr(
 """<p>The Programming Language <b>{0}</b> is not"""
 """ supported (project type: {1}).</p>""")
 .format(progLanguage, type_)
 )
 return
 if type_ in self.__projectProgLanguages[progLanguage]:
-E5MessageBox.critical(
+EricMessageBox.critical(
 self.ui,
 self.tr("Registering Project Type"),
 self.tr(
 """<p>The Project type <b>{0}</b> is already"""
 """ registered with Programming Language"""
 .format(type_, progLanguage)
 )
 return
 if type_ in self.__projectTypes:
-E5MessageBox.critical(
+EricMessageBox.critical(
 self.ui,
 self.tr("Registering Project Type"),
 self.tr("""<p>The Project type <b>{0}</b> is already"""
 """ registered.</p>""").format(type_)
 )
 @param fn filename of the project file to be read (string)
 @return flag indicating success
 """
 if os.path.splitext(fn)[1] == ".epj":
 # new JSON based format
-with E5OverrideCursor():
+with EricOverrideCursor():
 res = self.__projectFile.readFile(fn)
 else:
 # old XML based format
 f = QFile(fn)
 if f.open(QIODevice.OpenModeFlag.ReadOnly):
 QCryptographicHash.Algorithm.Sha1).toHex(),
 encoding="utf-8")
 self.pdata["HASH"] = hashStr
 self.setDirty(True)
 else:
-E5MessageBox.critical(
+EricMessageBox.critical(
 self.ui,
 self.tr("Read Project File"),
 self.tr(
 "<p>The project file <b>{0}</b> could not be read."
 "</p>")
 self.pdata["HASH"] = hashStr
 if fn is None:
 fn = self.pfile
-with E5OverrideCursor():
+with EricOverrideCursor():
 res = self.__projectFile.writeFile(fn)
 if res:
 self.pfile = os.path.abspath(fn)
 self.ppath = os.path.abspath(os.path.dirname(fn))
 from EricXML.UserProjectReader import UserProjectReader
 reader = UserProjectReader(f, self)
 reader.readXML()
 f.close()
 else:
-E5MessageBox.critical(
+EricMessageBox.critical(
 self.ui,
 self.tr("Read User Project Properties"),
 self.tr(
 "<p>The user specific project properties file"
 " <b>{0}</b> could not be read.</p>").format(fn))
 return
 fn, ext = os.path.splitext(os.path.basename(self.pfile))
 fn = os.path.join(self.getProjectManagementDir(), '{0}.eqj'.format(fn))
-with E5OverrideCursor():
+with EricOverrideCursor():
 self.__userProjectFile.writeFile(fn)
 def __showContextMenuSession(self):
 """
 Private slot called before the Session menu is shown.
 If this flag is true, no errors are reported.
 @param indicator indicator string (string)
 """
 if self.pfile is None:
 if not quiet:
-E5MessageBox.critical(
+EricMessageBox.critical(
 self.ui,
 self.tr("Read Project Session"),
 self.tr("Please save the project first."))
 return
 reader = SessionReader(f, False)
 reader.readXML(quiet=quiet)
 f.close()
 else:
 if not quiet:
-E5MessageBox.critical(
+EricMessageBox.critical(
 self.ui,
 self.tr("Read project session"),
 self.tr(
 "<p>The project session file <b>{0}</b> could"
 " not be read.</p>").format(fn))
 If this flag is true, no errors are reported.
 @param indicator indicator string (string)
 """
 if self.pfile is None:
 if not quiet:
-E5MessageBox.critical(
+EricMessageBox.critical(
 self.ui,
 self.tr("Save Project Session"),
 self.tr("Please save the project first."))
 return
 def __deleteSession(self):
 """
 Private method to delete the session file.
 """
 if self.pfile is None:
-E5MessageBox.critical(
+EricMessageBox.critical(
 self.ui,
 self.tr("Delete Project Session"),
 self.tr("Please save the project first."))
 return
 self.getProjectManagementDir(), "{0}{1}".format(fname, ext)),
 if os.path.exists(fn):
 try:
 os.remove(fn)
 except OSError:
-E5MessageBox.critical(
+EricMessageBox.critical(
 self.ui,
 self.tr("Delete Project Session"),
 self.tr(
 "<p>The project session file <b>{0}</b> could"
 " not be deleted.</p>").format(fn))
 def __readTasks(self):
 """
 Private method to read in the project tasks file (.etj or .e6t).
 """
 if self.pfile is None:
-E5MessageBox.critical(
+EricMessageBox.critical(
 self.ui,
 self.tr("Read Tasks"),
 self.tr("Please save the project first."))
 return
 from EricXML.TasksReader import TasksReader
 reader = TasksReader(f, True)
 reader.readXML()
 f.close()
 else:
-E5MessageBox.critical(
+EricMessageBox.critical(
 self.ui,
 self.tr("Read Tasks"),
 self.tr(
 "<p>The tasks file <b>{0}</b> could not be read."
 "</p>")
 @param quiet flag indicating quiet operations.
 If this flag is true, no errors are reported.
 """
 if self.pfile is None:
 if not quiet:
-E5MessageBox.critical(
+EricMessageBox.critical(
 self.ui,
 self.tr("Read Debugger Properties"),
 self.tr("Please save the project first."))
 return
 f.close()
 self.debugPropertiesLoaded = True
 self.debugPropertiesChanged = False
 else:
 if not quiet:
-E5MessageBox.critical(
+EricMessageBox.critical(
 self.ui,
 self.tr("Read Debugger Properties"),
 self.tr(
 "<p>The project debugger properties file"
 " <b>{0}</b> could not be read.</p>").format(fn))
 @param quiet flag indicating quiet operations.
 If this flag is true, no errors are reported.
 """
 if self.pfile is None:
 if not quiet:
-E5MessageBox.critical(
+EricMessageBox.critical(
 self.ui,
 self.tr("Save Debugger Properties"),
 self.tr("Please save the project first."))
 return
 fn, ext = os.path.splitext(os.path.basename(self.pfile))
 fn = os.path.join(self.getProjectManagementDir(), '{0}.edj'.format(fn))
-with E5OverrideCursor():
+with EricOverrideCursor():
 self.__debuggerPropertiesFile.writeFile(fn)
 def __deleteDebugProperties(self):
 """
 Private method to delete the project debugger properties file
 (.edj or .e4d).
 """
 if self.pfile is None:
-E5MessageBox.critical(
+EricMessageBox.critical(
 self.ui,
 self.tr("Delete Debugger Properties"),
 self.tr("Please save the project first."))
 return
 "{0}{1}".format(fname, ext))
 if os.path.exists(fn):
 try:
 os.remove(fn)
 except OSError:
-E5MessageBox.critical(
+EricMessageBox.critical(
 self.ui,
 self.tr("Delete Debugger Properties"),
 self.tr(
 "<p>The project debugger properties file"
 " <b>{0}</b> could not be deleted.</p>")
 @param key key of the property (string)
 @return value of the property
 """
 if key == "INTERPRETER":
 return (
-e5App().getObject("VirtualEnvManager")
+ericApp().getObject("VirtualEnvManager")
 .getVirtualenvInterpreter(self.debugProperties["VIRTUALENV"])
 )
 else:
 return self.debugProperties[key]
 def addLanguage(self):
 """
 Public slot used to add a language to the project.
 """
 if not self.pdata["TRANSLATIONPATTERN"]:
-E5MessageBox.critical(
+EricMessageBox.critical(
 self.ui,
 self.tr("Add Language"),
 self.tr(
 "You have to specify a translation pattern first."))
 return
 try:
 fn = os.path.join(self.ppath, langFile)
 if os.path.exists(fn):
 s2t(fn)
 except OSError as err:
-E5MessageBox.critical(
+EricMessageBox.critical(
 self.ui,
 self.tr("Delete translation"),
 self.tr(
 "<p>The selected translation file <b>{0}</b> could not be"
 " deleted.</p><p>Reason: {1}</p>").format(
 os.path.basename(qmFile)))
 fn = os.path.join(self.ppath, qmFile)
 if os.path.exists(fn):
 s2t(fn)
 except OSError as err:
-E5MessageBox.critical(
+EricMessageBox.critical(
 self.ui,
 self.tr("Delete translation"),
 self.tr(
 "<p>The selected translation file <b>{0}</b> could"
 " not be deleted.</p><p>Reason: {1}</p>").format(
 try:
 if not os.path.isdir(target):
 os.makedirs(target)
 if os.path.exists(targetfile):
-res = E5MessageBox.yesNo(
+res = EricMessageBox.yesNo(
 self.ui,
 self.tr("Add file"),
 self.tr(
 "<p>The file <b>{0}</b> already"
 " exists.</p><p>Overwrite it?</p>")
 .format(targetfile),
-icon=E5MessageBox.Warning)
+icon=EricMessageBox.Warning)
 if not res:
 return  # don't overwrite
 shutil.copy(fn, target)
 except OSError as why:
-E5MessageBox.critical(
+EricMessageBox.critical(
 self.ui,
 self.tr("Add file"),
 self.tr(
 "<p>The selected file <b>{0}</b> could"
 " not be added to <b>{1}</b>.</p>"
 continue
 self.appendFile(targetfile,
 isSource or fileTypeFilter == 'source')
 else:
-E5MessageBox.critical(
+EricMessageBox.critical(
 self.ui,
 self.tr("Add file"),
 self.tr("The target directory must not be empty."))
 def __addSingleDirectory(self, filetype, source, target, quiet=False):
 sstring = "{0}{1}{2}".format(source, os.sep, pattern)
 files.extend(glob.glob(sstring))
 if len(files) == 0:
 if not quiet:
-E5MessageBox.information(
+EricMessageBox.information(
 self.ui,
 self.tr("Add directory"),
 self.tr(
 "<p>The source directory doesn't contain"
 " any files belonging to the selected category.</p>"))
 not os.path.isdir(target)
 ):
 try:
 os.makedirs(target)
 except OSError as why:
-E5MessageBox.critical(
+EricMessageBox.critical(
 self.ui,
 self.tr("Add directory"),
 self.tr(
 "<p>The target directory <b>{0}</b> could not be"
 " created.</p><p>Reason: {1}</p>")
 targetfile = os.path.join(target, os.path.basename(file))
 if not Utilities.samepath(target, source):
 try:
 if os.path.exists(targetfile):
-res = E5MessageBox.yesNo(
+res = EricMessageBox.yesNo(
 self.ui,
 self.tr("Add directory"),
 self.tr(
 "<p>The file <b>{0}</b> already exists.</p>"
 "<p>Overwrite it?</p>")
 .format(targetfile),
-icon=E5MessageBox.Warning)
+icon=EricMessageBox.Warning)
 if not res:
 continue
 # don't overwrite, carry on with next file
 shutil.copy(file, target)
 dlg = AddDirectoryDialog(
 self, fileTypeFilter, self.parent(), startdir=startdir)
 if dlg.exec() == QDialog.DialogCode.Accepted:
 filetype, source, target, recursive = dlg.getData()
 if target == '':
-E5MessageBox.critical(
+EricMessageBox.critical(
 self.ui,
 self.tr("Add directory"),
 self.tr("The target directory must not be empty."))
 return
 if filetype == 'OTHERS':
 self.addToOthers(source)
 return
 if source == '':
-E5MessageBox.critical(
+EricMessageBox.critical(
 self.ui,
 self.tr("Add directory"),
 self.tr("The source directory must not be empty."))
 return
 """
 fn = self.getRelativePath(oldfn)
 isSourceFile = fn in self.pdata["SOURCES"]
 if newfn is None:
-newfn = E5FileDialog.getSaveFileName(
+newfn = EricFileDialog.getSaveFileName(
 None,
 self.tr("Rename file"),
 oldfn,
 "",
-E5FileDialog.DontConfirmOverwrite)
+EricFileDialog.DontConfirmOverwrite)
 if not newfn:
 return False
 newfn = Utilities.toNativeSeparators(newfn)
 if os.path.exists(newfn):
-res = E5MessageBox.yesNo(
+res = EricMessageBox.yesNo(
 self.ui,
 self.tr("Rename File"),
 self.tr("""<p>The file <b>{0}</b> already exists."""
 """ Overwrite it?</p>""")
 .format(newfn),
-icon=E5MessageBox.Warning)
+icon=EricMessageBox.Warning)
 if not res:
 return False
 try:
 os.rename(oldfn, newfn)
 except OSError as msg:
-E5MessageBox.critical(
+EricMessageBox.critical(
 self.ui,
 self.tr("Rename File"),
 self.tr(
 """<p>The file <b>{0}</b> could not be renamed.<br />"""
 """Reason: {1}</p>""").format(oldfn, str(msg)))
 self.ppath, head,
 "__pycache__", "{0}.*{1}".format(tail, ext))
 for f in glob.glob(pat):
 s2t(f)
 except OSError as err:
-E5MessageBox.critical(
+EricMessageBox.critical(
 self.ui,
 self.tr("Delete file"),
 self.tr(
 "<p>The selected file <b>{0}</b> could not be"
 " deleted.</p><p>Reason: {1}</p>").format(
 from send2trash import send2trash
 send2trash(dn)
 except ImportError:
 shutil.rmtree(dn, True)
 except OSError as err:
-E5MessageBox.critical(
+EricMessageBox.critical(
 self.ui,
 self.tr("Delete directory"),
 self.tr(
 "<p>The selected directory <b>{0}</b> could not be"
 " deleted.</p><p>Reason: {1}</p>").format(dn, str(err)))
 # create the project directory if it doesn't exist already
 if not os.path.isdir(self.ppath):
 try:
 os.makedirs(self.ppath)
 except OSError:
-E5MessageBox.critical(
+EricMessageBox.critical(
 self.ui,
 self.tr("Create project directory"),
 self.tr(
 "<p>The project directory <b>{0}</b> could not"
 " be created.</p>")
 else:
 try:
 # create management directory if not present
 self.createProjectManagementDir()
 except OSError:
-E5MessageBox.critical(
+EricMessageBox.critical(
 self.ui,
 self.tr("Create project management directory"),
 self.tr(
 "<p>The project directory <b>{0}</b> is not"
 " writable.</p>")
 try:
 os.makedirs(os.path.dirname(ms))
 with open(ms, "w"):
 pass
 except OSError as err:
-E5MessageBox.critical(
+EricMessageBox.critical(
 self.ui,
 self.tr("Create main script"),
 self.tr(
 "<p>The mainscript <b>{0}</b> could not"
 " be created.<br/>Reason: {1}</p>")
 try:
 os.makedirs(os.path.dirname(mf))
 with open(mf, "w"):
 pass
 except OSError as err:
-E5MessageBox.critical(
+EricMessageBox.critical(
 self.ui,
 self.tr("Create Makefile"),
 self.tr(
 "<p>The makefile <b>{0}</b> could not"
 " be created.<br/>Reason: {1}</p>")
 .format(mf, str(err)))
 self.appendFile(mf)
 # add existing files to the project
-res = E5MessageBox.yesNo(
+res = EricMessageBox.yesNo(
 self.ui,
 self.tr("New Project"),
 self.tr("""Add existing files to the project?"""),
 yesDefault=True)
 if res:
 self.appendFile(fn, True)
 self.saveProject()
 # check, if the existing project directory is already under
 # VCS control
-pluginManager = e5App().getObject("PluginManager")
+pluginManager = ericApp().getObject("PluginManager")
 for indicator, vcsData in list(
 pluginManager.getVcsSystemIndicators().items()):
 if os.path.exists(os.path.join(self.ppath, indicator)):
 if len(vcsData) > 1:
 vcsList = []
 self.vcs = self.initVCS()
 self.setDirty(True)
 if self.vcs is not None:
 # edit VCS command options
 if self.vcs.vcsSupportCommandOptions():
-vcores = E5MessageBox.yesNo(
+vcores = EricMessageBox.yesNo(
 self.ui,
 self.tr("New Project"),
 self.tr(
 """Would you like to edit the VCS"""
 """ command options?"""))
 codlg = VcsCommandOptionsDialog(self.vcs)
 if codlg.exec() == QDialog.DialogCode.Accepted:
 self.vcs.vcsSetOptions(codlg.getOptions())
 # add project file to repository
 if res == 0:
-apres = E5MessageBox.yesNo(
+apres = EricMessageBox.yesNo(
 self.ui,
 self.tr("New project"),
 self.tr(
 "Shall the project file be added"
 " to the repository?"),
 self.vcs is None and
 self.vcsSoftwareAvailable() and
 self.vcsRequested
 ):
 vcsSystemsDict = (
-e5App().getObject("PluginManager")
+ericApp().getObject("PluginManager")
 .getPluginDisplayStrings("version_control")
 )
 vcsSystemsDisplay = [self.tr("None")]
 keys = sorted(vcsSystemsDict.keys())
 for key in keys:
 self.vcs = self.initVCS()
 self.setDirty(True)
 if self.vcs is not None:
 # edit VCS command options
 if self.vcs.vcsSupportCommandOptions():
-vcores = E5MessageBox.yesNo(
+vcores = EricMessageBox.yesNo(
 self.ui,
 self.tr("New Project"),
 self.tr(
 """Would you like to edit the VCS command"""
 """ options?"""))
 @param mainscript name of the mainscript (string)
 """
 # Show the file type associations for the user to change
 self.__showFiletypeAssociations()
-with E5OverrideCursor():
+with EricOverrideCursor():
 # search the project directory for files with known extensions
 filespecs = list(self.pdata["FILETYPES"].keys())
 for filespec in filespecs:
 files = Utilities.direntries(self.ppath, True, filespec)
 for file in files:
 if not os.path.exists(mf):
 try:
 with open(mf, "w"):
 pass
 except OSError as err:
-E5MessageBox.critical(
+EricMessageBox.critical(
 self.ui,
 self.tr("Create Makefile"),
 self.tr(
 "<p>The makefile <b>{0}</b> could not"
 " be created.<br/>Reason: {1}</p>")
 if self.vcs is not None:
 self.vcs.stopStatusMonitor()
 self.vcs.vcsShutdown()
 self.vcs.deleteLater()
 self.vcs = None
-e5App().getObject("PluginManager").deactivateVcsPlugins()
+ericApp().getObject("PluginManager").deactivateVcsPlugins()
 # reinit VCS
 self.vcs = self.initVCS()
 # start the VCS monitor thread
 if self.vcs is not None:
 self.vcs.startStatusMonitor(self)
 """
 if not self.checkDirty():
 return
 if fn is None:
-fn = E5FileDialog.getOpenFileName(
+fn = EricFileDialog.getOpenFileName(
 self.parent(),
 self.tr("Open project"),
 Preferences.getMultiProject("Workspace") or
 Utilities.getHomeDir(),
 self.tr("Project Files (*.epj);;XML Project Files (*.e4p)"))
 QApplication.processEvents()
 if fn and self.closeProject():
-with E5OverrideCursor():
+with EricOverrideCursor():
 ok = self.__readProject(fn)
 if ok:
 self.opened = True
 if not self.pdata["FILETYPES"]:
 self.initFileTypes()
 try:
 # create management directory if not present
 self.createProjectManagementDir()
 except OSError:
-E5MessageBox.critical(
+EricMessageBox.critical(
 self.ui,
 self.tr("Create project management directory"),
 self.tr(
 "<p>The project directory <b>{0}</b> is not"
 " writable.</p>")
 return
 # read a user specific project file
 self.__readUserProperties()
-with E5OverrideCursor():
+with EricOverrideCursor():
 oldState = self.isDirty()
 self.vcs = self.initVCS()
 if self.vcs is None and self.isDirty() == oldState:
 # check, if project is version controlled
-pluginManager = e5App().getObject("PluginManager")
+pluginManager = ericApp().getObject("PluginManager")
 for indicator, vcsData in (
 pluginManager.getVcsSystemIndicators().items()
 ):
 if os.path.exists(
 os.path.join(self.ppath, indicator)):
 vcsList = []
 for (
 _vcsSystemStr, vcsSystemDisplay
 ) in vcsData:
 vcsList.append(vcsSystemDisplay)
-with E5OverridenCursor():
+with EricOverridenCursor():
 res, vcs_ok = QInputDialog.getItem(
 None,
 self.tr("New Project"),
 self.tr(
 "Select Version Control"
 # read a project tasks file
 self.__readTasks()
 self.ui.taskViewer.setProjectOpen(True)
 # rescan project tasks
 if Preferences.getProject("TasksProjectRescanOnOpen"):
-e5App().getObject("TaskViewer"
+ericApp().getObject("TaskViewer"
 ).regenerateProjectTasks(quiet=True)
 if restoreSession:
 # open the main script
 if self.pdata["MAINSCRIPT"]:
 self.ppath
 if self.ppath else
 (Preferences.getMultiProject("Workspace") or
 Utilities.getHomeDir())
 )
-fn, selectedFilter = E5FileDialog.getSaveFileNameAndFilter(
+fn, selectedFilter = EricFileDialog.getSaveFileNameAndFilter(
 self.parent(),
 self.tr("Save Project"),
 defaultPath,
 self.tr("Project Files (*.epj)"),
 defaultFilter,
-E5FileDialog.DontConfirmOverwrite)
+EricFileDialog.DontConfirmOverwrite)
 if fn:
 ext = QFileInfo(fn).suffix()
 if not ext:
 ex = selectedFilter.split("(*")[1].split(")")[0]
 if ex:
 fn += ex
 if QFileInfo(fn).exists():
-res = E5MessageBox.yesNo(
+res = EricMessageBox.yesNo(
 self.ui,
 self.tr("Save File"),
 self.tr("""<p>The file <b>{0}</b> already exists."""
 """ Overwrite it?</p>""").format(fn),
-icon=E5MessageBox.Warning)
+icon=EricMessageBox.Warning)
 if not res:
 return False
 self.name = QFileInfo(fn).baseName()
 ok = self.__writeProject(fn)
 Public method to check dirty status and open a message window.
 @return flag indicating whether this operation was successful (boolean)
 """
 if self.isDirty():
-res = E5MessageBox.okToClearData(
+res = EricMessageBox.okToClearData(
 self.parent(),
 self.tr("Close Project"),
 self.tr("The current project has unsaved changes."),
 self.saveProject)
 if res:
 return True
 if not self.checkDirty():
 return False
-e5App().getObject("TaskViewer").stopProjectTaskExtraction()
+ericApp().getObject("TaskViewer").stopProjectTaskExtraction()
 # save the user project properties
 if not noSave:
 self.__writeUserProperties()
 self.isDebugPropertiesLoaded() and
 not noSave and self.debugPropertiesChanged
 ):
 self.__writeDebugProperties(True)
-vm = e5App().getObject("ViewManager")
+vm = ericApp().getObject("ViewManager")
 # check dirty status of all project files first
 for fn in vm.getOpenFilenames():
 if self.isProjectFile(fn):
 reset = vm.checkFileDirty(fn)
 # now shutdown the vcs interface
 if self.vcs:
 self.vcs.vcsShutdown()
 self.vcs.deleteLater()
 self.vcs = None
-e5App().getObject("PluginManager").deactivateVcsPlugins()
+ericApp().getObject("PluginManager").deactivateVcsPlugins()
 # now close all project related tool windows
 self.__closeAllWindows()
 self.__initData()
 @param reportSyntaxErrors flag indicating special reporting
 for syntax errors (boolean)
 @return flag indicating success (boolean)
 """
-vm = e5App().getObject("ViewManager")
+vm = ericApp().getObject("ViewManager")
 success = True
 filesWithSyntaxErrors = 0
 for fn in vm.getOpenFilenames():
 rfn = self.getRelativePath(fn)
 if rfn in self.pdata["SOURCES"] or rfn in self.pdata["OTHERS"]:
 success &= vm.saveEditorEd(editor)
 if reportSyntaxErrors and editor.hasSyntaxErrors():
 filesWithSyntaxErrors += 1
 if reportSyntaxErrors and filesWithSyntaxErrors > 0:
-E5MessageBox.critical(
+EricMessageBox.critical(
 self.ui,
 self.tr("Syntax errors detected"),
 self.tr(
 """The project contains %n file(s) with syntax errors.""",
 "", filesWithSyntaxErrors)
 @param reportSyntaxErrors flag indicating special reporting
 for syntax errors (boolean)
 @return flag indicating success (boolean)
 """
-vm = e5App().getObject("ViewManager")
+vm = ericApp().getObject("ViewManager")
 success = True
 filesWithSyntaxErrors = 0
 for fn in vm.getOpenFilenames():
 rfn = self.getRelativePath(fn)
 if rfn in self.pdata["SOURCES"] or rfn in self.pdata["OTHERS"]:
 success &= editor.checkDirty()
 if reportSyntaxErrors and editor.hasSyntaxErrors():
 filesWithSyntaxErrors += 1
 if reportSyntaxErrors and filesWithSyntaxErrors > 0:
-E5MessageBox.critical(
+EricMessageBox.critical(
 self.ui,
 self.tr("Syntax errors detected"),
 self.tr(
 """The project contains %n file(s) with syntax errors.""",
 "", filesWithSyntaxErrors)
 """
 self.actions = []
 self.actGrp1 = createActionGroup(self)
-act = E5Action(
+act = EricAction(
 self.tr('New project'),
 UI.PixmapCache.getIcon("projectNew"),
 self.tr('&New...'), 0, 0,
 self.actGrp1, 'project_new')
 act.setStatusTip(self.tr('Generate a new project'))
 """ new project.</p>"""
 ))
 act.triggered.connect(self.createNewProject)
 self.actions.append(act)
-act = E5Action(
+act = EricAction(
 self.tr('Open project'),
 UI.PixmapCache.getIcon("projectOpen"),
 self.tr('&Open...'), 0, 0,
 self.actGrp1, 'project_open')
 act.setStatusTip(self.tr('Open an existing project'))
 """<p>This opens an existing project.</p>"""
 ))
 act.triggered.connect(self.openProject)
 self.actions.append(act)
-self.closeAct = E5Action(
+self.closeAct = EricAction(
 self.tr('Close project'),
 UI.PixmapCache.getIcon("projectClose"),
 self.tr('&Close'), 0, 0, self, 'project_close')
 self.closeAct.setStatusTip(self.tr('Close the current project'))
 self.closeAct.setWhatsThis(self.tr(
 """<p>This closes the current project.</p>"""
 ))
 self.closeAct.triggered.connect(self.closeProject)
 self.actions.append(self.closeAct)
-self.saveAct = E5Action(
+self.saveAct = EricAction(
 self.tr('Save project'),
 UI.PixmapCache.getIcon("projectSave"),
 self.tr('&Save'), 0, 0, self, 'project_save')
 self.saveAct.setStatusTip(self.tr('Save the current project'))
 self.saveAct.setWhatsThis(self.tr(
 """<p>This saves the current project.</p>"""
 ))
 self.saveAct.triggered.connect(self.saveProject)
 self.actions.append(self.saveAct)
-self.saveasAct = E5Action(
+self.saveasAct = EricAction(
 self.tr('Save project as'),
 UI.PixmapCache.getIcon("projectSaveAs"),
 self.tr('Save &as...'), 0, 0, self, 'project_save_as')
 self.saveasAct.setStatusTip(self.tr(
 'Save the current project to a new file'))
 self.saveasAct.triggered.connect(self.saveProjectAs)
 self.actions.append(self.saveasAct)
 self.actGrp2 = createActionGroup(self)
-self.addFilesAct = E5Action(
+self.addFilesAct = EricAction(
 self.tr('Add files to project'),
 UI.PixmapCache.getIcon("fileMisc"),
 self.tr('Add &files...'), 0, 0,
 self.actGrp2, 'project_add_file')
 self.addFilesAct.setStatusTip(self.tr(
 """ determined by the file extension.</p>"""
 ))
 self.addFilesAct.triggered.connect(self.addFiles)
 self.actions.append(self.addFilesAct)
-self.addDirectoryAct = E5Action(
+self.addDirectoryAct = EricAction(
 self.tr('Add directory to project'),
 UI.PixmapCache.getIcon("dirOpen"),
 self.tr('Add directory...'), 0, 0,
 self.actGrp2, 'project_add_directory')
 self.addDirectoryAct.setStatusTip(
 """ to the current project.</p>"""
 ))
 self.addDirectoryAct.triggered.connect(self.addDirectory)
 self.actions.append(self.addDirectoryAct)
-self.addLanguageAct = E5Action(
+self.addLanguageAct = EricAction(
 self.tr('Add translation to project'),
 UI.PixmapCache.getIcon("linguist4"),
 self.tr('Add &translation...'), 0, 0,
 self.actGrp2, 'project_add_translation')
 self.addLanguageAct.setStatusTip(
 """ to the current project.</p>"""
 ))
 self.addLanguageAct.triggered.connect(self.addLanguage)
 self.actions.append(self.addLanguageAct)
-act = E5Action(
+act = EricAction(
 self.tr('Search new files'),
 self.tr('Searc&h new files...'), 0, 0,
 self.actGrp2, 'project_search_new_files')
 act.setStatusTip(self.tr(
 'Search new files in the project directory.'))
 """ subdirectories.</p>"""
 ))
 act.triggered.connect(self.__searchNewFiles)
 self.actions.append(act)
-act = E5Action(
+act = EricAction(
 self.tr('Search Project File'),
 self.tr('Search Project File...'),
 QKeySequence(self.tr("Alt+Ctrl+P", "Project|Search Project File")),
 0,
 self.actGrp2, 'project_search_project_file')
 """<p>This searches for a file in the project list of files.</p>"""
 ))
 act.triggered.connect(self.__searchProjectFile)
 self.actions.append(act)
-self.propsAct = E5Action(
+self.propsAct = EricAction(
 self.tr('Project properties'),
 UI.PixmapCache.getIcon("projectProps"),
 self.tr('&Properties...'), 0, 0, self,
 'project_properties')
 self.propsAct.setStatusTip(self.tr('Show the project properties'))
 """<p>This shows a dialog to edit the project properties.</p>"""
 ))
 self.propsAct.triggered.connect(self.__showProperties)
 self.actions.append(self.propsAct)
-self.userPropsAct = E5Action(
+self.userPropsAct = EricAction(
 self.tr('User project properties'),
 UI.PixmapCache.getIcon("projectUserProps"),
 self.tr('&User Properties...'), 0, 0, self,
 'project_user_properties')
 self.userPropsAct.setStatusTip(self.tr(
 """ properties.</p>"""
 ))
 self.userPropsAct.triggered.connect(self.__showUserProperties)
 self.actions.append(self.userPropsAct)
-self.filetypesAct = E5Action(
+self.filetypesAct = EricAction(
 self.tr('Filetype Associations'),
 self.tr('Filetype Associations...'), 0, 0,
 self, 'project_filetype_associations')
 self.filetypesAct.setStatusTip(
 self.tr('Show the project file type associations'))
 ))
 self.filetypesAct.triggered.connect(
 self.__showFiletypeAssociations)
 self.actions.append(self.filetypesAct)
-self.lexersAct = E5Action(
+self.lexersAct = EricAction(
 self.tr('Lexer Associations'),
 self.tr('Lexer Associations...'), 0, 0,
 self, 'project_lexer_associations')
 self.lexersAct.setStatusTip(self.tr(
 'Show the project lexer associations (overriding defaults)'))
 self.lexersAct.triggered.connect(self.__showLexerAssociations)
 self.actions.append(self.lexersAct)
 self.dbgActGrp = createActionGroup(self)
-act = E5Action(
+act = EricAction(
 self.tr('Debugger Properties'),
 self.tr('Debugger &Properties...'), 0, 0,
 self.dbgActGrp, 'project_debugger_properties')
 act.setStatusTip(self.tr('Show the debugger properties'))
 act.setWhatsThis(self.tr(
 """ settings.</p>"""
 ))
 act.triggered.connect(self.__showDebugProperties)
 self.actions.append(act)
-act = E5Action(
+act = EricAction(
 self.tr('Load'),
 self.tr('&Load'), 0, 0,
 self.dbgActGrp, 'project_debugger_properties_load')
 act.setStatusTip(self.tr('Load the debugger properties'))
 act.setWhatsThis(self.tr(
 """<p>This loads the project specific debugger settings.</p>"""
 ))
 act.triggered.connect(self.__readDebugProperties)
 self.actions.append(act)
-act = E5Action(
+act = EricAction(
 self.tr('Save'),
 self.tr('&Save'), 0, 0,
 self.dbgActGrp, 'project_debugger_properties_save')
 act.setStatusTip(self.tr('Save the debugger properties'))
 act.setWhatsThis(self.tr(
 """<p>This saves the project specific debugger settings.</p>"""
 ))
 act.triggered.connect(self.__writeDebugProperties)
 self.actions.append(act)
-act = E5Action(
+act = EricAction(
 self.tr('Delete'),
 self.tr('&Delete'), 0, 0,
 self.dbgActGrp, 'project_debugger_properties_delete')
 act.setStatusTip(self.tr('Delete the debugger properties'))
 act.setWhatsThis(self.tr(
 """ debugger settings.</p>"""
 ))
 act.triggered.connect(self.__deleteDebugProperties)
 self.actions.append(act)
-act = E5Action(
+act = EricAction(
 self.tr('Reset'),
 self.tr('&Reset'), 0, 0,
 self.dbgActGrp, 'project_debugger_properties_resets')
 act.setStatusTip(self.tr('Reset the debugger properties'))
 act.setWhatsThis(self.tr(
 act.triggered.connect(self.__initDebugProperties)
 self.actions.append(act)
 self.sessActGrp = createActionGroup(self)
-act = E5Action(
+act = EricAction(
 self.tr('Load session'),
 self.tr('Load session'), 0, 0,
 self.sessActGrp, 'project_load_session')
 act.setStatusTip(self.tr('Load the projects session file.'))
 act.setWhatsThis(self.tr(
 """- the exception reporting flag</p>"""
 ))
 act.triggered.connect(self.__readSession)
 self.actions.append(act)
-act = E5Action(
+act = EricAction(
 self.tr('Save session'),
 self.tr('Save session'), 0, 0,
 self.sessActGrp, 'project_save_session')
 act.setStatusTip(self.tr('Save the projects session file.'))
 act.setWhatsThis(self.tr(
 """- the exception reporting flag</p>"""
 ))
 act.triggered.connect(self.__writeSession)
 self.actions.append(act)
-act = E5Action(
+act = EricAction(
 self.tr('Delete session'),
 self.tr('Delete session'), 0, 0,
 self.sessActGrp, 'project_delete_session')
 act.setStatusTip(self.tr('Delete the projects session file.'))
 act.setWhatsThis(self.tr(
 act.triggered.connect(self.__deleteSession)
 self.actions.append(act)
 self.chkGrp = createActionGroup(self)
-self.codeMetricsAct = E5Action(
+self.codeMetricsAct = EricAction(
 self.tr('Code Metrics'),
 self.tr('&Code Metrics...'), 0, 0,
 self.chkGrp, 'project_code_metrics')
 self.codeMetricsAct.setStatusTip(
 self.tr('Show some code metrics for the project.'))
 """ the project.</p>"""
 ))
 self.codeMetricsAct.triggered.connect(self.__showCodeMetrics)
 self.actions.append(self.codeMetricsAct)
-self.codeCoverageAct = E5Action(
+self.codeCoverageAct = EricAction(
 self.tr('Python Code Coverage'),
 self.tr('Code Co&verage...'), 0, 0,
 self.chkGrp, 'project_code_coverage')
 self.codeCoverageAct.setStatusTip(
 self.tr('Show code coverage information for the project.'))
 """ files in the project.</p>"""
 ))
 self.codeCoverageAct.triggered.connect(self.__showCodeCoverage)
 self.actions.append(self.codeCoverageAct)
-self.codeProfileAct = E5Action(
+self.codeProfileAct = EricAction(
 self.tr('Profile Data'),
 self.tr('&Profile Data...'), 0, 0,
 self.chkGrp, 'project_profile_data')
 self.codeProfileAct.setStatusTip(
 self.tr('Show profiling data for the project.'))
 self.codeProfileAct.triggered.connect(self.__showProfileData)
 self.actions.append(self.codeProfileAct)
 self.graphicsGrp = createActionGroup(self)
-self.applicationDiagramAct = E5Action(
+self.applicationDiagramAct = EricAction(
 self.tr('Application Diagram'),
 self.tr('&Application Diagram...'), 0, 0,
 self.graphicsGrp, 'project_application_diagram')
 self.applicationDiagramAct.setStatusTip(
 self.tr('Show a diagram of the project.'))
 ))
 self.applicationDiagramAct.triggered.connect(
 self.handleApplicationDiagram)
 self.actions.append(self.applicationDiagramAct)
-self.loadDiagramAct = E5Action(
+self.loadDiagramAct = EricAction(
 self.tr('Load Diagram'),
 self.tr('&Load Diagram...'), 0, 0,
 self.graphicsGrp, 'project_load_diagram')
 self.loadDiagramAct.setStatusTip(
 self.tr('Load a diagram from file.'))
 self.loadDiagramAct.triggered.connect(self.__loadDiagram)
 self.actions.append(self.loadDiagramAct)
 self.pluginGrp = createActionGroup(self)
-self.pluginPkgListAct = E5Action(
+self.pluginPkgListAct = EricAction(
 self.tr('Create Package List'),
 UI.PixmapCache.getIcon("pluginArchiveList"),
 self.tr('Create &Package List'), 0, 0,
 self.pluginGrp, 'project_plugin_pkglist')
 self.pluginPkgListAct.setStatusTip(
 """ file.</p>"""
 ))
 self.pluginPkgListAct.triggered.connect(self.__pluginCreatePkgList)
 self.actions.append(self.pluginPkgListAct)
-self.pluginArchiveAct = E5Action(
+self.pluginArchiveAct = EricAction(
 self.tr('Create Plugin Archives'),
 UI.PixmapCache.getIcon("pluginArchive"),
 self.tr('Create Plugin &Archives'), 0, 0,
 self.pluginGrp, 'project_plugin_archive')
 self.pluginArchiveAct.setStatusTip(
 """ the package list file.</p>"""
 ))
 self.pluginArchiveAct.triggered.connect(self.__pluginCreateArchives)
 self.actions.append(self.pluginArchiveAct)
-self.pluginSArchiveAct = E5Action(
+self.pluginSArchiveAct = EricAction(
 self.tr('Create Plugin Archives (Snapshot)'),
 UI.PixmapCache.getIcon("pluginArchiveSnapshot"),
 self.tr('Create Plugin Archives (&Snapshot)'), 0, 0,
 self.pluginGrp, 'project_plugin_sarchive')
 self.pluginSArchiveAct.setStatusTip(self.tr(
 self.__pluginCreateSnapshotArchives)
 self.actions.append(self.pluginSArchiveAct)
 self.makeGrp = createActionGroup(self)
-self.makeExecuteAct = E5Action(
+self.makeExecuteAct = EricAction(
 self.tr('Execute Make'),
 self.tr('&Execute Make'), 0, 0,
 self.makeGrp, 'project_make_execute')
 self.makeExecuteAct.setStatusTip(
 self.tr("Perform a 'make' run."))
 """ target.</p>"""
 ))
 self.makeExecuteAct.triggered.connect(self.__executeMake)
 self.actions.append(self.makeExecuteAct)
-self.makeTestAct = E5Action(
+self.makeTestAct = EricAction(
 self.tr('Test for Changes'),
 self.tr('&Test for Changes'), 0, 0,
 self.makeGrp, 'project_make_test')
 self.makeTestAct.setStatusTip(
 self.tr("Question 'make', if a rebuild is needed."))
 """
 Public slot to initialize the project toolbar and the basic VCS
 toolbar.
 @param toolbarManager reference to a toolbar manager object
-(E5ToolBarManager)
+(EricToolBarManager)
 @return tuple of the generated toolbars (tuple of two QToolBar)
 """
 tb = QToolBar(self.tr("Project"), self.ui)
 tb.setIconSize(UI.Config.ToolBarIconSize)
 tb.setObjectName("ProjectToolbar")
 return
 # if newfiles is empty, put up message box informing user nothing found
 if not newFiles:
 if onUserDemand:
-E5MessageBox.information(
+EricMessageBox.information(
 self.ui,
 self.tr("Search New Files"),
 self.tr("There were no new files found to be added."))
 return
 def getActions(self):
 """
 Public method to get a list of all actions.
-@return list of all actions (list of E5Action)
+@return list of all actions (list of EricAction)
 """
 return self.actions[:]
-def addE5Actions(self, actions):
+def addEricActions(self, actions):
 """
 Public method to add actions to the list of actions.
-@param actions list of actions (list of E5Action)
+@param actions list of actions (list of EricAction)
 """
 self.actions.extend(actions)
-def removeE5Actions(self, actions):
+def removeEricActions(self, actions):
 """
 Public method to remove actions from the list of actions.
-@param actions list of actions (list of E5Action)
+@param actions list of actions (list of EricAction)
 """
 for act in actions:
 with contextlib.suppress(ValueError):
 self.actions.remove(act)
 @param fullname full name of the item to repopulate (string)
 """
 if not self.isOpen():
 return
-with E5OverrideCursor():
+with EricOverrideCursor():
 name = self.getRelativePath(fullname)
 self.prepareRepopulateItem.emit(name)
 self.__model.repopulateItem(name)
 self.completeRepopulateItem.emit(name)
 if vcs:
 vcsExists, msg = vcs.vcsExists()
 if not vcsExists:
 if override:
 # override failed, revert to original
-with E5OverridenCursor():
+with EricOverridenCursor():
-E5MessageBox.critical(
+EricMessageBox.critical(
 self.ui,
 self.tr("Version Control System"),
 self.tr(
 "<p>The selected VCS <b>{0}</b> could not be"
 " found. <br/>Reverting override.</p><p>{1}"
 "</p>")
 .format(vcsSystem, msg))
 self.pudata["VCSOVERRIDE"] = ""
 return self.initVCS(nooverride=True)
-with E5OverridenCursor():
+with EricOverridenCursor():
-E5MessageBox.critical(
+EricMessageBox.critical(
 self.ui,
 self.tr("Version Control System"),
 self.tr(
 "<p>The selected VCS <b>{0}</b> could not be"
 " found.<br/>Disabling version control.</p>"
 """
 Public method to reset the VCS.
 """
 self.pdata["VCS"] = 'None'
 self.vcs = self.initVCS()
-e5App().getObject("PluginManager").deactivateVcsPlugins()
+ericApp().getObject("PluginManager").deactivateVcsPlugins()
 def __showContextMenuVCS(self):
 """
 Private slot called before the vcs menu is shown.
 """
 to the IDE.
 @return flag indicating availability of VCS software (boolean)
 """
 vcsSystemsDict = (
-e5App().getObject("PluginManager")
+ericApp().getObject("PluginManager")
 .getPluginDisplayStrings("version_control")
 )
 return len(vcsSystemsDict) != 0
 def __vcsStatusChanged(self):
 Private slot used to show the code coverage information for the
 project files.
 """
 fn = self.getMainScript(True)
 if fn is None:
-E5MessageBox.critical(
+EricMessageBox.critical(
 self.ui,
 self.tr("Coverage Data"),
 self.tr(
 "There is no main script defined for the"
 " current project. Aborting"))
 """
 Private slot used to show the profiling information for the project.
 """
 fn = self.getMainScript(True)
 if fn is None:
-E5MessageBox.critical(
+EricMessageBox.critical(
 self.ui,
 self.tr("Profile Data"),
 self.tr(
 "There is no main script defined for the"
 " current project. Aborting"))
 def handleApplicationDiagram(self):
 """
 Public method to handle the application diagram context menu action.
 """
-res = E5MessageBox.yesNo(
+res = EricMessageBox.yesNo(
 self.ui,
 self.tr("Application Diagram"),
 self.tr("""Include module names?"""),
 yesDefault=True)
 """
 Private slot to create a PKGLIST file needed for archive file creation.
 """
 pkglist = os.path.join(self.ppath, "PKGLIST")
 if os.path.exists(pkglist):
-res = E5MessageBox.yesNo(
+res = EricMessageBox.yesNo(
 self.ui,
 self.tr("Create Package List"),
 self.tr(
 "<p>The file <b>PKGLIST</b> already"
 " exists.</p><p>Overwrite it?</p>"),
-icon=E5MessageBox.Warning)
+icon=EricMessageBox.Warning)
 if not res:
 return  # don't overwrite
 # build the list of entries
 lst_ = []
 "\n".join([Utilities.fromNativeSeparators(f)
 for f in lst]))
 pkglistFile.write("\n")
 # ensure the file ends with an empty line
 except OSError as why:
-E5MessageBox.critical(
+EricMessageBox.critical(
 self.ui,
 self.tr("Create Package List"),
 self.tr(
 """<p>The file <b>PKGLIST</b> could not be created.</p>"""
 """<p>Reason: {0}</p>""").format(str(why)))
 Private slot to create eric plugin archives.
 @param snapshot flag indicating snapshot archives (boolean)
 """
 if not self.pdata["MAINSCRIPT"]:
-E5MessageBox.critical(
+EricMessageBox.critical(
 self.ui,
 self.tr("Create Plugin Archive"),
 self.tr(
 """The project does not have a main script defined. """
 """Aborting..."""))
 pkglists = [os.path.basename(f) for f in
 glob.glob(os.path.join(self.ppath, "PKGLIST*"))]
 if len(pkglists) == 1:
 selectedLists = [os.path.join(self.ppath, pkglists[0])]
 elif len(pkglists) > 1:
-dlg = E5ListSelectionDialog(
+dlg = EricListSelectionDialog(
 sorted(pkglists), title=self.tr("Create Plugin Archive"),
 message=self.tr("Select package lists:"),
 checkBoxSelection=True)
 if dlg.exec() == QDialog.DialogCode.Accepted:
 selectedLists = [os.path.join(self.ppath, s)
 for s in dlg.getSelection()]
 else:
 return
 if not selectedLists:
-E5MessageBox.critical(
+EricMessageBox.critical(
 self.ui,
 self.tr("Create Plugin Archive"),
 self.tr("""<p>No package list files (PKGLIST*) available or"""
 """ selected. Aborting...</p>"""))
 return
-progress = E5ProgressDialog(
+progress = EricProgressDialog(
 self.tr("Creating plugin archives..."), self.tr("Abort"),
 0, len(selectedLists), self.tr("%v/%m Archives"))
 progress.setMinimumDuration(0)
 progress.setWindowTitle(self.tr("Create Plugin Archives"))
 errors = 0
 try:
 with open(pkglist, "r", encoding="utf-8") as pkglistFile:
 names = pkglistFile.read()
 except OSError as why:
-E5MessageBox.critical(
+EricMessageBox.critical(
 self.ui,
 self.tr("Create Plugin Archive"),
 self.tr(
 """<p>The file <b>{0}</b> could not be read.</p>"""
 """<p>Reason: {1}</p>""").format(
 if line.startswith("archive_name="):
 archiveName = line.split("=")[1]
 elif line.startswith("archive_version="):
 archiveVersion = line.split("=")[1]
 elif line.startswith("initial_list "):
-E5MessageBox.critical(
+EricMessageBox.critical(
 self.ui,
 self.tr("Create Plugin Archive"),
 self.tr(
 """<p>The file <b>{0}</b> is not ready yet."""
 """</p><p>Please rework it and delete the"""
 self.pdata["MAINSCRIPT"].replace(".py", ".zip"))
 )
 try:
 archiveFile = zipfile.ZipFile(archive, "w")
 except OSError as why:
-E5MessageBox.critical(
+EricMessageBox.critical(
 self.ui,
 self.tr("Create Plugin Archive"),
 self.tr(
 """<p>The eric plugin archive file <b>{0}</b>"""
 """ could not be created.</p>"""
 self.__pluginVersionToTuple(version) <
 self.__pluginVersionToTuple(archiveVersion)
 ):
 version = archiveVersion
 except OSError as why:
-E5MessageBox.critical(
+EricMessageBox.critical(
 self.ui,
 self.tr("Create Plugin Archive"),
 self.tr(
 """<p>The file <b>{0}</b> could not be"""
 """ stored in the archive. Ignoring it.</p>"""
 """
 try:
 sourcelines, encoding = Utilities.readEncodedFile(filename)
 sourcelines = sourcelines.splitlines(True)
 except (OSError, UnicodeError) as why:
-E5MessageBox.critical(
+EricMessageBox.critical(
 self.ui,
 self.tr("Create Plugin Archive"),
 self.tr("""<p>The plugin file <b>{0}</b> could """
 """not be read.</p>"""
 """<p>Reason: {1}</p>""")
 version = "0.0.0"
 try:
 sourcelines = Utilities.readEncodedFile(filename)[0]
 sourcelines = sourcelines.splitlines(True)
 except (OSError, UnicodeError) as why:
-E5MessageBox.critical(
+EricMessageBox.critical(
 self.ui,
 self.tr("Create Plugin Archive"),
 self.tr(
 """<p>The plugin file <b>{0}</b> could """
 """not be read.</p> <p>Reason: {1}</p>""")
 exitCode, exitStatus, questionOnly, interactive))
 self.__makeProcess.setWorkingDirectory(self.getProjectPath())
 self.__makeProcess.start(prog, args)
 if not self.__makeProcess.waitForStarted():
-E5MessageBox.critical(
+EricMessageBox.critical(
 self.ui,
 self.tr("Execute Make"),
 self.tr("""The make process did not start."""))
 self.__cleanupMake()
 @param interactive flag indicating an interactive invocation (i.e.
 through a menu action)
 @type bool
 """
 if exitStatus == QProcess.ExitStatus.CrashExit:
-E5MessageBox.critical(
+EricMessageBox.critical(
 self.ui,
 self.tr("Execute Make"),
 self.tr("""The make process crashed."""))
 else:
 if questionOnly and exitCode == 1:
 title,
 message,
 kind=NotificationTypes.WARNING,
 timeout=0)
 elif exitCode > 1:
-E5MessageBox.critical(
+EricMessageBox.critical(
 self.ui,
 self.tr("Execute Make"),
 self.tr("""The makefile contains errors."""))
 self.__cleanupMake()

Mercurial Repositories > eric / file comparison

comparison: eric7/Project/Project.py

eric7/Project/Project.py