eric: comparison eric6/Project/Project.py

-:59d1c0f80286
+:c4110b8b5931
 from E5Gui.E5Action import E5Action, createActionGroup
 import Preferences
 import Utilities
+from .ProjectFile import ProjectFile
+from .UserProjectFile import UserProjectFile
+from .DebuggerPropertiesFile import DebuggerPropertiesFile
 class Project(QObject):
 """
 Class implementing the project management functionality.
 self.__initProjectTypes()
 self.__initData()
+self.__projectFile = ProjectFile(self)
+self.__userProjectFile = UserProjectFile(self)
+self.__debuggerPropertiesFile = DebuggerPropertiesFile(self)
 self.recent = []
 self.__loadRecent()
 if filename is not None:
 self.openProject(filename)
 "*.md": "OTHERS",
 "*.rst": "OTHERS",
 "README": "OTHERS",
 "README.*": "OTHERS",
 "*.e4p": "OTHERS",
+"*.epj": "OTHERS",
 "GNUmakefile": "OTHERS",
 "makefile": "OTHERS",
 "Makefile": "OTHERS",
 }
 self.pdata[index].remove(file)
 self.setDirty(True)
 def __readProject(self, fn):
 """
-Private method to read in a project (.e4p) file.
+Private method to read in a project (.epj or .e4p) file.
 @param fn filename of the project file to be read (string)
 @return flag indicating success
 """
-f = QFile(fn)
+if os.path.splitext(fn)[1] == ".epj":
-if f.open(QIODevice.ReadOnly):
+# new JSON based format
-from E5XML.ProjectReader import ProjectReader
+with E5OverrideCursor():
-reader = ProjectReader(f, self)
+res = self.__projectFile.readFile(fn)
-reader.readXML()
-res = not reader.hasError()
-f.close()
 else:
-E5MessageBox.critical(
+# old XML based format
-self.ui,
+f = QFile(fn)
-self.tr("Read project file"),
+if f.open(QIODevice.ReadOnly):
-self.tr(
+from E5XML.ProjectReader import ProjectReader
-"<p>The project file <b>{0}</b> could not be read.</p>")
+reader = ProjectReader(f, self)
-.format(fn))
+reader.readXML()
-return False
+res = not reader.hasError()
+f.close()
-self.pfile = os.path.abspath(fn)
-self.ppath = os.path.abspath(os.path.dirname(fn))
+# create hash value, if it doesn't have one
+if reader.version.startswith("5.") and not self.pdata["HASH"]:
-# insert filename into list of recently opened projects
+hashStr = str(QCryptographicHash.hash(
-self.__syncRecent()
+QByteArray(self.ppath.encode("utf-8")),
+QCryptographicHash.Sha1).toHex(),
+encoding="utf-8")
+self.pdata["HASH"] = hashStr
+self.setDirty(True)
+else:
+E5MessageBox.critical(
+self.ui,
+self.tr("Read Project File"),
+self.tr(
+"<p>The project file <b>{0}</b> could not be read."
+"</p>")
+.format(fn))
+res = False
 if res:
+self.pfile = os.path.abspath(fn)
+self.ppath = os.path.abspath(os.path.dirname(fn))
+# insert filename into list of recently opened projects
+self.__syncRecent()
 if self.pdata["TRANSLATIONPATTERN"]:
 self.translationsRoot = self.pdata["TRANSLATIONPATTERN"].split(
 "%language%")[0]
 elif self.pdata["MAINSCRIPT"]:
 self.translationsRoot = os.path.splitext(
 for fn in self.pdata["OTHERS"]:
 dn = os.path.dirname(fn)
 if dn not in self.otherssubdirs:
 self.otherssubdirs.append(dn)
-# create hash value, if it doesn't have one
-if reader.version.startswith("5.") and not self.pdata["HASH"]:
-hashStr = str(QCryptographicHash.hash(
-QByteArray(self.ppath.encode("utf-8")),
-QCryptographicHash.Sha1).toHex(),
-encoding="utf-8")
-self.pdata["HASH"] = hashStr
-self.setDirty(True)
 return res
 def __writeProject(self, fn=None):
 """
 Private method to save the project infos to a project file.
 self.pdata["HASH"] = hashStr
 if fn is None:
 fn = self.pfile
-f = QFile(fn)
+if os.path.splitext(fn)[1] == ".epj":
-if f.open(QIODevice.WriteOnly):
+# new JSON based format
-from E5XML.ProjectWriter import ProjectWriter
+with E5OverrideCursor():
-ProjectWriter(f, os.path.splitext(
+res = self.__projectFile.writeFile(fn)
-os.path.basename(fn))[0]).writeXML()
-res = True
 else:
-E5MessageBox.critical(
+# old XML based format
-self.ui,
+f = QFile(fn)
-self.tr("Save project file"),
+if f.open(QIODevice.WriteOnly):
-self.tr(
+from E5XML.ProjectWriter import ProjectWriter
-"<p>The project file <b>{0}</b> could not be"
+ProjectWriter(f, os.path.splitext(
-" written.</p>").format(fn))
+os.path.basename(fn))[0]).writeXML()
-res = False
+res = True
+else:
+E5MessageBox.critical(
+self.ui,
+self.tr("Save Project File"),
+self.tr(
+"<p>The project file <b>{0}</b> could not be"
+" written.</p>").format(fn))
+res = False
 if res:
 self.pfile = os.path.abspath(fn)
 self.ppath = os.path.abspath(os.path.dirname(fn))
 self.name = os.path.splitext(os.path.basename(fn))[0]
 return res
 def __readUserProperties(self):
 """
-Private method to read in the user specific project file (.e4q).
+Private method to read in the user specific project file (.eqj or
+.e4q).
 """
 if self.pfile is None:
 return
 fn, ext = os.path.splitext(os.path.basename(self.pfile))
-fn = os.path.join(self.getProjectManagementDir(), '{0}.e4q'.format(fn))
+fn = os.path.join(self.getProjectManagementDir(), '{0}.eqj'.format(fn))
 if os.path.exists(fn):
-f = QFile(fn)
+# try the new JSON based format first
-if f.open(QIODevice.ReadOnly):
+self.__userProjectFile.readFile(fn)
-from E5XML.UserProjectReader import UserProjectReader
+else:
-reader = UserProjectReader(f, self)
+# try the old XML based format second
-reader.readXML()
+fn = os.path.join(self.getProjectManagementDir(),
-f.close()
+'{0}.e4q'.format(fn))
-else:
+if os.path.exists(fn):
-E5MessageBox.critical(
+f = QFile(fn)
-self.ui,
+if f.open(QIODevice.ReadOnly):
-self.tr("Read user project properties"),
+from E5XML.UserProjectReader import UserProjectReader
-self.tr(
+reader = UserProjectReader(f, self)
-"<p>The user specific project properties file"
+reader.readXML()
-" <b>{0}</b> could not be read.</p>").format(fn))
+f.close()
+else:
+E5MessageBox.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))
 def __writeUserProperties(self):
 """
-Private method to write the project data to an XML file.
+Private method to write the user specific project data to a JSON file.
 """
 if self.pfile is None:
 return
 fn, ext = os.path.splitext(os.path.basename(self.pfile))
-fn = os.path.join(self.getProjectManagementDir(), '{0}.e4q'.format(fn))
+fn = os.path.join(self.getProjectManagementDir(), '{0}.eqj'.format(fn))
-f = QFile(fn)
+with E5OverrideCursor():
-if f.open(QIODevice.WriteOnly):
+self.__userProjectFile.writeFile(fn)
-from E5XML.UserProjectWriter import UserProjectWriter
-UserProjectWriter(
-f, os.path.splitext(os.path.basename(fn))[0]).writeXML()
-f.close()
-else:
-E5MessageBox.critical(
-self.ui,
-self.tr("Save user project properties"),
-self.tr(
-"<p>The user specific project properties file <b>{0}</b>"
-" could not be written.</p>").format(fn))
 def __showContextMenuSession(self):
 """
 Private slot called before the Session menu is shown.
 """
 enable = True
 @param quiet flag indicating quiet operations.
 If this flag is true, no errors are reported.
 @param indicator indicator string (string)
 """
+# TODO: read project session
 if self.pfile is None:
 if not quiet:
 E5MessageBox.critical(
 self.ui,
 self.tr("Read project session"),
 @param quiet flag indicating quiet operations.
 If this flag is true, no errors are reported.
 @param indicator indicator string (string)
 """
+# TODO: write project session
 if self.pfile is None:
 if not quiet:
 E5MessageBox.critical(
 self.ui,
 self.tr("Save project session"),
 Private method to delete the session file.
 """
 if self.pfile is None:
 E5MessageBox.critical(
 self.ui,
-self.tr("Delete project session"),
+self.tr("Delete Project Session"),
 self.tr("Please save the project first."))
 return
 fname, ext = os.path.splitext(os.path.basename(self.pfile))
-for fn in [
+for ext in (".esj", ".e5s", ".e4s"):
-os.path.join(
+fn = os.path.join(
-self.getProjectManagementDir(), "{0}.e5s".format(fname)),
+self.getProjectManagementDir(), "{0}{1}".format(fname, ext)),
-os.path.join(
-self.getProjectManagementDir(), "{0}.e4s".format(fname))]:
 if os.path.exists(fn):
 try:
 os.remove(fn)
 except OSError:
 E5MessageBox.critical(
 self.ui,
-self.tr("Delete project session"),
+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 (.e6t).
 """
 if self.pfile is None:
 E5MessageBox.critical(
 self.ui,
-self.tr("Read tasks"),
+self.tr("Read Tasks"),
 self.tr("Please save the project first."))
 return
+# TODO: read project tasks
 base, ext = os.path.splitext(os.path.basename(self.pfile))
 fn = os.path.join(self.getProjectManagementDir(),
 '{0}.e6t'.format(base))
 if not os.path.exists(fn):
 # try again with the old extension
 reader.readXML()
 f.close()
 else:
 E5MessageBox.critical(
 self.ui,
-self.tr("Read tasks"),
+self.tr("Read Tasks"),
 self.tr(
 "<p>The tasks file <b>{0}</b> could not be read.</p>")
 .format(fn))
 def writeTasks(self):
 if self.pfile is None:
 return
 fn, ext = os.path.splitext(os.path.basename(self.pfile))
+# TODO: write project tasks
 fn = os.path.join(self.getProjectManagementDir(), '{0}.e6t'.format(fn))
 f = QFile(fn)
 ok = f.open(QIODevice.WriteOnly)
 if not ok:
 E5MessageBox.critical(
 self.ui,
-self.tr("Save tasks"),
+self.tr("Save Tasks"),
 self.tr(
 "<p>The tasks file <b>{0}</b> could not be written.</p>")
 .format(fn))
 return
 QAction, "project_debugger_properties_delete").setEnabled(enable)
 @pyqtSlot()
 def __readDebugProperties(self, quiet=False):
 """
-Private method to read in the project debugger properties file (.e4d).
+Private method to read in the project debugger properties file
+(.edj or .e4d).
 @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(
 self.ui,
-self.tr("Read debugger properties"),
+self.tr("Read 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))
+if os.path.exists(fn):
+# try the new JSON based format first
+self.__debuggerPropertiesFile.readFile(fn)
+else:
+# try the old XML based format second
+fn, ext = os.path.splitext(os.path.basename(self.pfile))
+fn = os.path.join(self.getProjectManagementDir(),
+'{0}.e4d'.format(fn))
-fn, ext = os.path.splitext(os.path.basename(self.pfile))
+f = QFile(fn)
-fn = os.path.join(self.getProjectManagementDir(), '{0}.e4d'.format(fn))
+if f.open(QIODevice.ReadOnly):
+from E5XML.DebuggerPropertiesReader import (
-f = QFile(fn)
+DebuggerPropertiesReader
-if f.open(QIODevice.ReadOnly):
+)
-from E5XML.DebuggerPropertiesReader import DebuggerPropertiesReader
+reader = DebuggerPropertiesReader(f, self)
-reader = DebuggerPropertiesReader(f, self)
+reader.readXML(quiet=quiet)
-reader.readXML(quiet=quiet)
+f.close()
-f.close()
+self.debugPropertiesLoaded = True
-self.debugPropertiesLoaded = True
+self.debugPropertiesChanged = False
-self.debugPropertiesChanged = False
+else:
-else:
+if not quiet:
-if not quiet:
+E5MessageBox.critical(
-E5MessageBox.critical(
+self.ui,
-self.ui,
+self.tr("Read Debugger Properties"),
-self.tr("Read debugger properties"),
+self.tr(
-self.tr(
+"<p>The project debugger properties file"
-"<p>The project debugger properties file <b>{0}</b>"
+" <b>{0}</b> could not be read.</p>").format(fn))
-" could not be read.</p>").format(fn))
 @pyqtSlot()
 def __writeDebugProperties(self, quiet=False):
 """
-Private method to write the project debugger properties file (.e4d).
+Private method to write the project debugger properties file (.edj).
 @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(
 self.ui,
-self.tr("Save debugger properties"),
+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}.e4d'.format(fn))
+fn = os.path.join(self.getProjectManagementDir(), '{0}.edj'.format(fn))
-f = QFile(fn)
+with E5OverrideCursor():
-if f.open(QIODevice.WriteOnly):
+self.__debuggerPropertiesFile.writeFile(fn)
-from E5XML.DebuggerPropertiesWriter import DebuggerPropertiesWriter
-DebuggerPropertiesWriter(
-f, os.path.splitext(os.path.basename(fn))[0]).writeXML()
-f.close()
-self.debugPropertiesChanged = False
-else:
-if not quiet:
-E5MessageBox.critical(
-self.ui,
-self.tr("Save debugger properties"),
-self.tr(
-"<p>The project debugger properties file <b>{0}</b>"
-" could not be written.</p>").format(fn))
 def __deleteDebugProperties(self):
 """
-Private method to delete the project debugger properties file (.e4d).
+Private method to delete the project debugger properties file
+(.edj or .e4d).
 """
 if self.pfile is None:
 E5MessageBox.critical(
 self.ui,
-self.tr("Delete debugger properties"),
+self.tr("Delete Debugger Properties"),
 self.tr("Please save the project first."))
 return
 fname, ext = os.path.splitext(os.path.basename(self.pfile))
-for fn in [os.path.join(self.getProjectManagementDir(),
+for ext in (".edj", ".e4d"):
-"{0}.e4d".format(fname))]:
+fn = os.path.join(self.getProjectManagementDir(),
+"{0}{1}".format(fname, ext))
 if os.path.exists(fn):
 try:
 os.remove(fn)
 except OSError:
 E5MessageBox.critical(
 self.ui,
-self.tr("Delete debugger properties"),
+self.tr("Delete Debugger Properties"),
 self.tr(
 "<p>The project debugger properties file"
 " <b>{0}</b> could not be deleted.</p>")
 .format(fn))
 fn = E5FileDialog.getOpenFileName(
 self.parent(),
 self.tr("Open project"),
 Preferences.getMultiProject("Workspace") or
 Utilities.getHomeDir(),
-self.tr("Project Files (*.e4p)"))
+self.tr("Project Files (*.epj);;XML Project Files (*.e4p)"))
 QApplication.processEvents()
 if fn:
 if self.closeProject():
 @return flag indicating success
 """
 if self.isDirty():
 if len(self.pfile) > 0:
+if self.pfile.endswith(".e4p"):
+self.pfile = self.pfile.replace(".e4p", ".epj")
+self.__syncRecent()
 ok = self.__writeProject()
 else:
 ok = self.saveProjectAs()
 else:
 ok = True
 """
 Public slot to save the current project to a different file.
 @return flag indicating success (boolean)
 """
-defaultFilter = self.tr("Project Files (*.e4p)")
+defaultFilter = self.tr("Project Files (*.epj)")
 if self.ppath:
 defaultPath = self.ppath
 else:
 defaultPath = (
 Preferences.getMultiProject("Workspace") or
 )
 fn, selectedFilter = E5FileDialog.getSaveFileNameAndFilter(
 self.parent(),
 self.tr("Save project as"),
 defaultPath,
-self.tr("Project Files (*.e4p)"),
+self.tr("Project Files (*.epj);;"
+"XML Project Files (*.e4p)"),
 defaultFilter,
 E5FileDialog.Options(E5FileDialog.DontConfirmOverwrite))
 if fn:
 ext = QFileInfo(fn).suffix()

Mercurial Repositories > eric / file comparison

comparison: eric6/Project/Project.py

eric6/Project/Project.py