eric: Project/Project.py@375e3c884874 (annotated)

 # -*- coding: utf-8 -*-
 # Copyright (c) 2002 - 2010 Detlev Offenbach <detlev@die-offenbachs.de>
 #
 """
 Module implementing the project management functionality.
 """
 import os
 import time
 import shutil
 import glob
 import fnmatch
 import copy
 import zipfile
 import io
 from PyQt4.QtCore import *
 from PyQt4.QtGui import *
 from E5Gui.E5Application import e5App
 from Globals import recentNameProject
 from .ProjectBrowserModel import ProjectBrowserModel
 from .AddLanguageDialog import AddLanguageDialog
 from .AddFileDialog import AddFileDialog
 from .AddDirectoryDialog import AddDirectoryDialog
 from .PropertiesDialog import PropertiesDialog
 from .AddFoundFilesDialog import AddFoundFilesDialog
 from .DebuggerPropertiesDialog import DebuggerPropertiesDialog
 from .FiletypeAssociationDialog import FiletypeAssociationDialog
 from .LexerAssociationDialog import LexerAssociationDialog
 from .UserPropertiesDialog import UserPropertiesDialog
 from E5XML.XMLUtilities import make_parser
 from E5XML.XMLErrorHandler import XMLErrorHandler, XMLFatalParseError
 from E5XML.XMLEntityResolver import XMLEntityResolver
 from E5XML.ProjectHandler import ProjectHandler
 from E5XML.ProjectWriter import ProjectWriter
 from E5XML.UserProjectHandler import UserProjectHandler
 from E5XML.UserProjectWriter import UserProjectWriter
 from E5XML.SessionHandler import SessionHandler
 from E5XML.SessionWriter import SessionWriter
 from E5XML.TasksHandler import TasksHandler
 from E5XML.TasksWriter import TasksWriter
 from E5XML.DebuggerPropertiesHandler import DebuggerPropertiesHandler
 from E5XML.DebuggerPropertiesWriter import DebuggerPropertiesWriter
 import VCS
 from VCS.CommandOptionsDialog import vcsCommandOptionsDialog
 from VCS.ProjectHelper import VcsProjectHelper
 from Graphics.ApplicationDiagram import ApplicationDiagram
 from DataViews.CodeMetricsDialog import CodeMetricsDialog
 from DataViews.PyCoverageDialog import PyCoverageDialog
 from DataViews.PyProfileDialog import PyProfileDialog
 import UI.PixmapCache
 from E5Gui.E5Action import E5Action, createActionGroup
 import Preferences
 import Utilities
 class Project(QObject):
     """
     Class implementing the project management functionality.
     @signal dirty(int) emitted when the dirty state changes
     @signal projectSessionLoaded() emitted after a project session file was loaded
     @signal projectLanguageAdded(string) emitted after a new language was added
     @signal projectLanguageAddedByCode(string) emitted after a new language was added.
         The language code is sent by this signal.
     @signal projectFormAdded(string) emitted after a new form was added
     @signal projectSourceAdded(string) emitted after a new source file was added
     @signal projectInterfaceAdded(string) emitted after a new IDL file was added
     @signal projectResourceAdded(string) emitted after a new resource file was added
     @signal projectAboutToBeCreated() emitted just before the project will be created
     @signal newProjectHooks() emitted after a new project was generated but before
             the newProject() signal is sent
     @signal newProject() emitted after a new project was generated
     @signal sourceFile(string) emitted after a project file was read to
             open the main script
     @signal projectOpenedHooks() emitted after a project file was read but before the
             projectOpened() signal is sent
     @signal projectOpened() emitted after a project file was read
     @signal projectClosedHooks() emitted after a project file was clsoed but before the
             projectClosed() signal is sent
     @signal projectClosed() emitted after a project was closed
     @signal projectOthersAdded(string) emitted after a file or directory was added
             to the OTHERS project data area
     @signal projectFileRenamed(string, string) emitted after a file of the project
             has been renamed
     @signal projectPropertiesChanged() emitted after the project properties were changed
     @signal directoryRemoved(string) emitted after a directory has been removed from
             the project
     @signal prepareRepopulateItem(string) emitted before an item of the model is
             repopulated
     @signal completeRepopulateItem(string) emitted after an item of the model was
             repopulated
     @signal vcsStatusMonitorStatus(QString, QString) emitted to signal the status of the
             monitoring thread (ok, nok, op, off) and a status message
     @signal reinitVCS() emitted after the VCS has been reinitialized
     @signal showMenu(string, QMenu) emitted when a menu is about to be shown. The name
             of the menu and a reference to the menu are given.
     @signal lexerAssociationsChanged() emitted after the lexer associations have been
             changed
     """
     keynames = [
         "PROGLANGUAGE", "MIXEDLANGUAGE", "PROJECTTYPE",
         "SPELLLANGUAGE", "SPELLWORDS", "SPELLEXCLUDES",
         "DESCRIPTION", "VERSION", "HASH",
         "AUTHOR", "EMAIL",
         "SOURCES", "FORMS", "RESOURCES",
         "TRANSLATIONS", "TRANSLATIONPATTERN", "TRANSLATIONSBINPATH",
         "TRANSLATIONEXCEPTIONS",
         "MAINSCRIPT",
         "VCS", "VCSOPTIONS", "VCSOTHERDATA",
         "OTHERS", "INTERFACES",
         "FILETYPES", "LEXERASSOCS",
         "PROJECTTYPESPECIFICDATA",
         "DOCUMENTATIONPARMS",
         "PACKAGERSPARMS",
         "CHECKERSPARMS",
         "OTHERTOOLSPARMS",
     ]
     dbgKeynames = [
         "INTERPRETER", "DEBUGCLIENT",
         "ENVIRONMENTOVERRIDE", "ENVIRONMENTSTRING",
         "REMOTEDEBUGGER", "REMOTEHOST", "REMOTECOMMAND",
         "PATHTRANSLATION", "REMOTEPATH", "LOCALPATH",
         "CONSOLEDEBUGGER", "CONSOLECOMMAND",
         "REDIRECT", "NOENCODING",
     ]
     userKeynames = [
         "VCSOVERRIDE", "VCSSTATUSMONITORINTERVAL",
     ]
     def __init__(self, parent = None, filename = None):
         """
         Constructor
         @param parent parent widget (usually the ui object) (QWidget)
         @param filename optional filename of a project file to open (string)
         """
         QObject.__init__(self, parent)
         self.ui = parent
         self.sourceExtensions = {
             "Python"  : Preferences.getPython("PythonExtensions"),
             "Python3" : Preferences.getPython("Python3Extensions"),
             "Ruby"    : ['.rb'],
             "Mixed"   : ['.py', '.ptl', '.rb']
         }
         self.dbgFilters = {
             "Python"  : self.trUtf8(\
                          "Python Files (*.py2);;"
                          "Python GUI Files (*.pyw2);;"),
             "Python3" : self.trUtf8(\
                          "Python3 Files (*.py *.py3);;"
                          "Python3 GUI Files (*.pyw *.pyw3);;"),
             "Ruby"    : self.trUtf8("Ruby Files (*.rb);;"),
         }
         self.vcsMenu = None
         self.__initProjectTypes()
         self.__initData()
         self.recent = []
         self.__loadRecent()
         if filename is not None:
             self.openProject(filename)
         else:
             self.vcs = self.initVCS()
         self.__model = ProjectBrowserModel(self)
         self.codemetrics        = None
         self.codecoverage       = None
         self.profiledata        = None
         self.applicationDiagram = None
     def __initProjectTypes(self):
         """
         Private method to initialize the list of supported project types.
         """
         self.__projectTypes = {}
         self.__fileTypeCallbacks = {}
         self.__lexerAssociationCallbacks = {}
         self.__binaryTranslationsCallbacks = {}
         self.__projectTypes["Qt4"] = self.trUtf8("Qt4 GUI")
         self.__projectTypes["Qt4C"] = self.trUtf8("Qt4 Console")
         self.__projectTypes["E4Plugin"] = self.trUtf8("Eric Plugin")
         self.__projectTypes["Console"] = self.trUtf8("Console")
         self.__projectTypes["Other"] = self.trUtf8("Other")
         try:
             import PySide
             self.__projectTypes["PySide"] = self.trUtf8("PySide GUI")
             self.__projectTypes["PySideC"] = self.trUtf8("PySide Console")
             del PySide
         except ImportError:
             pass
     def getProjectTypes(self):
         """
         Public method to get the list of supported project types.
         @return reference to the dictionary of project types.
         """
         return self.__projectTypes
     def hasProjectType(self, type_):
         """
         Public method to check, if a project type is already registered.
         @param type_ internal type designator to be unregistered (string)
         """
         return type_ in self.__projectTypes
     def registerProjectType(self, type_, description, fileTypeCallback = None,
         binaryTranslationsCallback = None, lexerAssociationCallback = None):
         """
         Public method to register a project type.
         @param type_ internal type designator to be registered (string)
         @param description more verbose type name (display string) (string)
         @keyparam fileTypeCallback reference to a method returning a dictionary
             of filetype associations.
         @keyparam binaryTranslationsCallback reference to a method returning the
             name of the binary translation file given the name of the raw
             translation file
         @keyparam lexerAssociationCallback reference to a method returning the
             lexer type to be used for syntax highlighting given the name of
             a file
         """
         if type_ in self.__projectTypes:
             QMessageBox.critical(None,
                 self.trUtf8("Registering Project Type"),
                 self.trUtf8("""<p>The Project type <b>{0}</b> already exists.</p>""")\
                     .format(type_)
             )
         else:
             self.__projectTypes[type_] = description
             self.__fileTypeCallbacks[type_] = fileTypeCallback
             self.__lexerAssociationCallbacks[type_] = lexerAssociationCallback
             self.__binaryTranslationsCallbacks[type_] = binaryTranslationsCallback
     def unregisterProjectType(self, type_):
         """
         Public method to unregister a project type.
         @param type_ internal type designator to be unregistered (string)
         """
         if type_ in self.__projectTypes:
             del self.__projectTypes[type_]
         if type_ in self.__fileTypeCallbacks:
             del self.__fileTypeCallbacks[type_]
         if type_ in self.__lexerAssociationCallbacks:
             del self.__lexerAssociationCallbacks[type_]
         if type_ in self.__binaryTranslationsCallbacks:
             del self.__binaryTranslationsCallbacks[type_]
     def __initData(self):
         """
         Private method to initialize the project data part.
         """
         self.loaded = False     # flag for the loaded status
         self.dirty = False      # dirty flag
         self.pfile = ""         # name of the project file
         self.ppath = ""         # name of the project directory
         self.translationsRoot = ""  # the translations prefix
         self.name = ""
         self.opened = False
         self.subdirs = [""] # record the project dir as a relative path (i.e. empty path)
         self.otherssubdirs = []
         self.vcs = None
         self.dbgCmdline = ''
         self.dbgWd = ''
         self.dbgEnv = ''
         self.dbgReportExceptions = True
         self.dbgExcList = []
         self.dbgExcIgnoreList = []
         self.dbgAutoClearShell = True
         self.dbgTracePython = False
         self.dbgAutoContinue = True
         self.pdata = {}
         for key in self.__class__.keynames:
             self.pdata[key] = []
         self.pdata["AUTHOR"] = ['']
         self.pdata["EMAIL"] = ['']
         self.pdata["HASH"] = ['']
         self.pdata["PROGLANGUAGE"] = ["Python3"]
         self.pdata["MIXEDLANGUAGE"] = [False]
         self.pdata["PROJECTTYPE"] = ["Qt4"]
         self.pdata["SPELLLANGUAGE"] = \
             [Preferences.getEditor("SpellCheckingDefaultLanguage")]
         self.pdata["SPELLWORDS"] = ['']
         self.pdata["SPELLEXCLUDES"] = ['']
         self.pdata["FILETYPES"] = {}
         self.pdata["LEXERASSOCS"] = {}
         self.pdata["PROJECTTYPESPECIFICDATA"] = {}
         self.pdata["CHECKERSPARMS"] = {}
         self.pdata["PACKAGERSPARMS"] = {}
         self.pdata["DOCUMENTATIONPARMS"] = {}
         self.pdata["OTHERTOOLSPARMS"] = {}
         self.__initDebugProperties()
         self.pudata = {}
         for key in self.__class__.userKeynames:
             self.pudata[key] = []
         self.vcs = self.initVCS()
     def getData(self, category, key):
         """
         Public method to get data out of the project data store.
         @param category category of the data to get (string, one of
             PROJECTTYPESPECIFICDATA, CHECKERSPARMS, PACKAGERSPARMS, DOCUMENTATIONPARMS
             or OTHERTOOLSPARMS)
         @param key key of the data entry to get (string).
         @return a copy of the requested data or None
         """
         if category in ["PROJECTTYPESPECIFICDATA","CHECKERSPARMS", "PACKAGERSPARMS",
                         "DOCUMENTATIONPARMS", "OTHERTOOLSPARMS"] and \
            key in self.pdata[category]:
             return copy.deepcopy(self.pdata[category][key])
         else:
             return None
     def setData(self, category, key, data):
         """
         Public method to store data in the project data store.
         @param category category of the data to get (string, one of
             PROJECTTYPESPECIFICDATA, CHECKERSPARMS, PACKAGERSPARMS, DOCUMENTATIONPARMS
             or OTHERTOOLSPARMS)
         @param key key of the data entry to get (string).
         @param data data to be stored
         @return flag indicating success (boolean)
         """
         if category not in ["PROJECTTYPESPECIFICDATA","CHECKERSPARMS", "PACKAGERSPARMS",
                             "DOCUMENTATIONPARMS", "OTHERTOOLSPARMS"]:
             return False
         # test for changes of data and save them in the project
         # 1. there were none, now there are
         if key not in self.pdata[category] and len(data) > 0:
             self.pdata[category][key] = copy.deepcopy(data)
             self.setDirty(True)
         # 2. there were some, now there aren't
         elif key in self.pdata[category] and len(data) == 0:
             del self.pdata[category][key]
             self.setDirty(True)
         # 3. there were some and still are
         elif key in self.pdata[category] and len(data) > 0:
             if data != self.pdata[category][key]:
                 self.pdata[category][key] = copy.deepcopy(data)
                 self.setDirty(True)
         # 4. there were none and none are given
         else:
             return False
         return True
     def initFileTypes(self):
         """
         Public method to initialize the filetype associations with default values.
         """
         self.pdata["FILETYPES"] = {}
         if self.pdata["MIXEDLANGUAGE"][0]:
             sourceKey = "Mixed"
         else:
             sourceKey = self.pdata["PROGLANGUAGE"][0]
         for ext in self.sourceExtensions[sourceKey]:
             self.pdata["FILETYPES"]["*%s" % ext] = "SOURCES"
         self.pdata["FILETYPES"]["*.idl"] = "INTERFACES"
         if self.pdata["PROJECTTYPE"][0] in ["Qt4", "E4Plugin", "PySide"]:
             self.pdata["FILETYPES"]["*.ui"] = "FORMS"
             self.pdata["FILETYPES"]["*.ui.h"] = "FORMS"
         if self.pdata["PROJECTTYPE"][0] in ["Qt4", "Qt4C", "E4Plugin",
                                             "PySide", "PySideC"]:
             self.pdata["FILETYPES"]["*.qrc"] = "RESOURCES"
         if self.pdata["PROJECTTYPE"][0] in ["Qt4", "Qt4C", "E4Plugin",
                                             "PySide", "PySideC"]:
             self.pdata["FILETYPES"]["*.ts"] = "TRANSLATIONS"
             self.pdata["FILETYPES"]["*.qm"] = "TRANSLATIONS"
         try:
             if self.__fileTypeCallbacks[self.pdata["PROJECTTYPE"][0]] is not None:
                 ftypes = self.__fileTypeCallbacks[self.pdata["PROJECTTYPE"][0]]()
                 self.pdata["FILETYPES"].update(ftypes)
         except KeyError:
             pass
         self.setDirty(True)
     def updateFileTypes(self):
         """
         Public method to update the filetype associations with new default values.
         """
         if self.pdata["PROJECTTYPE"][0] in ["Qt4", "Qt4C", "E4Plugin",
                                             "PySide", "PySideC"]:
             if "*.ts" not in self.pdata["FILETYPES"]:
                 self.pdata["FILETYPES"]["*.ts"] = "TRANSLATIONS"
             if "*.qm" not in self.pdata["FILETYPES"]:
                 self.pdata["FILETYPES"]["*.qm"] = "TRANSLATIONS"
         try:
             if self.__fileTypeCallbacks[self.pdata["PROJECTTYPE"][0]] is not None:
                 ftypes = self.__fileTypeCallbacks[self.pdata["PROJECTTYPE"][0]]()
                 for pattern, ftype in list(ftypes.items()):
                     if pattern not in self.pdata["FILETYPES"]:
                         self.pdata["FILETYPES"][pattern] = ftype
                         self.setDirty(True)
         except KeyError:
             pass
     def __loadRecent(self):
         """
         Private method to load the recently opened project filenames.
         """
         self.recent = []
         Preferences.Prefs.rsettings.sync()
         rp = Preferences.Prefs.rsettings.value(recentNameProject)
         if rp is not None:
             for f in rp:
                 if QFileInfo(f).exists():
                     self.recent.append(f)
     def __saveRecent(self):
         """
         Private method to save the list of recently opened filenames.
         """
         Preferences.Prefs.rsettings.setValue(recentNameProject, self.recent)
         Preferences.Prefs.rsettings.sync()
     def getMostRecent(self):
         """
         Public method to get the most recently opened project.
         @return path of the most recently opened project (string)
         """
         if len(self.recent):
             return self.recent[0]
         else:
             return None
     def getModel(self):
         """
         Public method to get a reference to the project browser model.
         @return reference to the project browser model (ProjectBrowserModel)
         """
         return self.__model
     def getVcs(self):
         """
         Public method to get a reference to the VCS object.
         @return reference to the VCS object
         """
         return self.vcs
     def handlePreferencesChanged(self):
         """
         Public slot used to handle the preferencesChanged signal.
         """
         if self.pudata["VCSSTATUSMONITORINTERVAL"]:
             self.setStatusMonitorInterval(\
                 self.pudata["VCSSTATUSMONITORINTERVAL"][0])
         else:
             self.setStatusMonitorInterval(\
                 Preferences.getVCS("StatusMonitorInterval"))
         self.__model.preferencesChanged()
     def setDirty(self, b):
         """
         Public method to set the dirty state.
         It emits the signal dirty(int).
         @param b dirty state (boolean)
         """
         self.dirty = b
         self.saveAct.setEnabled(b)
         self.emit(SIGNAL("dirty"), bool(b))
     def isDirty(self):
         """
         Public method to return the dirty state.
         @return dirty state (boolean)
         """
         return self.dirty
     def isOpen(self):
         """
         Public method to return the opened state.
         @return open state (boolean)
         """
         return self.opened
     def __checkFilesExist(self, index):
         """
         Private method to check, if the files in a list exist.
         The files in the indicated list are checked for existance in the
         filesystem. Non existant files are removed from the list and the
         dirty state of the project is changed accordingly.
         @param index key of the list to be checked (string)
         """
         removed = False
         removelist = []
         for file in self.pdata[index]:
             if not os.path.exists(os.path.join(self.ppath, file)):
                 removelist.append(file)
                 removed = True
         if removed:
             for file in removelist:
                 self.pdata[index].remove(file)
             self.setDirty(True)
     def __readProject(self, fn):
         """
         Private method to read in a project (.e4p, .e4pz) file.
         @param fn filename of the project file to be read (string)
         @return flag indicating success
         """
         try:
             if fn.lower().endswith("e4pz"):
                 try:
                     import gzip
                 except ImportError:
                     QApplication.restoreOverrideCursor()
                     QMessageBox.critical(None,
                         self.trUtf8("Read project file"),
                         self.trUtf8("""Compressed project files not supported."""
                                     """ The compression library is missing."""))
                     return False
                 g = gzip.open(fn, "rb")
                 f = io.StringIO(g.read().decode("utf-8"))
                 g.close()
             else:
                 f = open(fn, "r", encoding = "utf-8")
             line = f.readline()
             dtdLine = f.readline()
             f.close()
         except EnvironmentError:
             QApplication.restoreOverrideCursor()
             QMessageBox.critical(None,
                 self.trUtf8("Read project file"),
                 self.trUtf8("<p>The project file <b>{0}</b> could not be read.</p>")\
                     .format(fn))
             return False
         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()
         # now read the file
         if not line.startswith('<?xml'):
             QApplication.restoreOverrideCursor()
             QMessageBox.critical(None,
                 self.trUtf8("Read project file"),
                 self.trUtf8("<p>The project file <b>{0}</b> has an unsupported"
                             " format.</p>").format(fn))
             return False
         res = self.__readXMLProject(fn, dtdLine.startswith("<!DOCTYPE"))
         if res:
             if len(self.pdata["TRANSLATIONPATTERN"]) == 1:
                 self.translationsRoot = \
                     self.pdata["TRANSLATIONPATTERN"][0].split("%language%")[0]
             elif len(self.pdata["MAINSCRIPT"]) == 1:
                 self.translationsRoot = os.path.splitext(self.pdata["MAINSCRIPT"][0])[0]
             if os.path.isdir(os.path.join(self.ppath, self.translationsRoot)):
                 dn = self.translationsRoot
             else:
                 dn = os.path.dirname(self.translationsRoot)
             if dn not in self.subdirs:
                 self.subdirs.append(dn)
             self.name = os.path.splitext(os.path.basename(fn))[0]
             # check, if the files of the project still exist in the project directory
             self.__checkFilesExist("SOURCES")
             self.__checkFilesExist("FORMS")
             self.__checkFilesExist("INTERFACES")
             self.__checkFilesExist("TRANSLATIONS")
             self.__checkFilesExist("RESOURCES")
             self.__checkFilesExist("OTHERS")
             # get the names of subdirectories the files are stored in
             for fn in self.pdata["SOURCES"] + \
                       self.pdata["FORMS"] + \
                       self.pdata["INTERFACES"] + \
                       self.pdata["RESOURCES"] + \
                       self.pdata["TRANSLATIONS"]:
                 dn = os.path.dirname(fn)
                 if dn not in self.subdirs:
                     self.subdirs.append(dn)
             # get the names of other subdirectories
             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 not self.pdata["HASH"][0]:
                 hash = str(QCryptographicHash.hash(
                     QByteArray(self.ppath), QCryptographicHash.Sha1).toHex(),
                     encoding = "utf-8")
                 self.pdata["HASH"] = [hash]
                 self.setDirty(True)
         return res
     def __readXMLProject(self, fn, validating):
         """
         Private method to read the project data from an XML file.
         @param fn filename of the project file to be read (string)
         @param validating flag indicating a validation of the XML file is
             requested (boolean)
         @return flag indicating success (boolean)
         """
         if fn.lower().endswith("e4pz"):
             # work around for a bug in xmlproc
             validating = False
         parser = make_parser(validating)
         handler = ProjectHandler(self)
         er = XMLEntityResolver()
         eh = XMLErrorHandler()
         parser.setContentHandler(handler)
         parser.setEntityResolver(er)
         parser.setErrorHandler(eh)
         try:
             if fn.lower().endswith("e4pz"):
                 try:
                     import gzip
                 except ImportError:
                     QApplication.restoreOverrideCursor()
                     QMessageBox.critical(None,
                         self.trUtf8("Read project file"),
                         self.trUtf8("""Compressed project files not supported."""
                                     """ The compression library is missing."""))
                     return False
                 g = gzip.open(fn, "rb")
                 f = io.StringIO(g.read().decode("utf-8"))
                 g.close()
             else:
                 f = open(fn, "r", encoding = "utf-8")
             try:
                 try:
                     parser.parse(f)
                 except UnicodeEncodeError:
                     f.seek(0)
                     buf = io.StringIO(f.read())
                     parser.parse(buf)
             finally:
                 f.close()
         except IOError:
             QApplication.restoreOverrideCursor()
             QMessageBox.critical(None,
                 self.trUtf8("Read project file"),
                 self.trUtf8("<p>The project file <b>{0}</b> could not be read.</p>")\
                     .format(fn))
             return False
         except XMLFatalParseError:
             QApplication.restoreOverrideCursor()
             QMessageBox.critical(None,
                 self.trUtf8("Read project file"),
                 self.trUtf8("<p>The project file <b>{0}</b> has invalid contents.</p>")\
                     .format(fn))
             eh.showParseMessages()
             return False
         QApplication.restoreOverrideCursor()
         eh.showParseMessages()
         QApplication.setOverrideCursor(QCursor(Qt.WaitCursor))
         QApplication.processEvents()
         return True
     def __writeProject(self, fn = None):
         """
         Private method to save the project infos to a project file.
         @param fn optional filename of the project file to be written (string).
                 If fn is None, the filename stored in the project object
                 is used. This is the 'save' action. If fn is given, this filename
                 is used instead of the one in the project object. This is the
                 'save as' action.
         @return flag indicating success
         """
         if self.vcs is not None:
             self.pdata["VCSOPTIONS"] = [copy.deepcopy(self.vcs.vcsGetOptions())]
             self.pdata["VCSOTHERDATA"] = [copy.deepcopy(self.vcs.vcsGetOtherData())]
         if fn is None:
             fn = self.pfile
         res = self.__writeXMLProject(fn)
         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]
             self.setDirty(False)
             # insert filename into list of recently opened projects
             self.__syncRecent()
         return res
     def __writeXMLProject(self, fn = None):
         """
         Private method to write the project data to an XML file.
         @param fn the filename of the project file (string)
         @return flag indicating success (boolean)
         """
         try:
             if fn.lower().endswith("e4pz"):
                 try:
                     import gzip
                 except ImportError:
                     QMessageBox.critical(None,
                         self.trUtf8("Save project file"),
                         self.trUtf8("""Compressed project files not supported."""
                                     """ The compression library is missing."""))
                     return False
                 f = io.StringIO()
             else:
                 f = open(fn, "w", encoding = "utf-8")
             ProjectWriter(f, os.path.splitext(os.path.basename(fn))[0]).writeXML()
             if fn.lower().endswith("e4pz"):
                 g = gzip.open(fn, "wb")
                 g.write(f.getvalue().encode("utf-8"))
                 g.close()
             f.close()
         except IOError:
             QMessageBox.critical(None,
                 self.trUtf8("Save project file"),
                 self.trUtf8("<p>The project file <b>{0}</b> could not be written.</p>")\
                     .format(fn))
             return False
         return True
     def __readUserProperties(self):
         """
         Private method to read in the user specific project file (.e4q)
         """
         if self.pfile is None:
             return
         fn, ext = os.path.splitext(os.path.basename(self.pfile))
         fn = os.path.join(self.getProjectManagementDir(), '%s.e4q' % fn)
         if os.path.exists(fn):
             try:
                 f = open(fn, "r", encoding = "utf-8")
                 parser = make_parser(True)
                 handler = UserProjectHandler(self)
                 er = XMLEntityResolver()
                 eh = XMLErrorHandler()
                 parser.setContentHandler(handler)
                 parser.setEntityResolver(er)
                 parser.setErrorHandler(eh)
                 try:
                     try:
                         parser.parse(f)
                     except UnicodeEncodeError:
                         f.seek(0)
                         buf = io.StringIO(f.read())
                         parser.parse(buf)
                 finally:
                     f.close()
             except IOError:
                 QMessageBox.critical(None,
                     self.trUtf8("Read user project properties"),
                     self.trUtf8("<p>The user specific project properties file <b>{0}</b>"
                         " could not be read.</p>").format(fn))
                 return
             except XMLFatalParseError:
                 pass
             eh.showParseMessages()
     def __writeUserProperties(self):
         """
         Private method to write the project data to an XML file.
         """
         if self.pfile is None:
             return
         fn, ext = os.path.splitext(os.path.basename(self.pfile))
         fn = os.path.join(self.getProjectManagementDir(), '%s.e4q' % fn)
         try:
             f = open(fn, "w", encoding = "utf-8")
             UserProjectWriter(f, os.path.splitext(os.path.basename(fn))[0]).writeXML()
             f.close()
         except IOError:
             QMessageBox.critical(None,
                 self.trUtf8("Save user project properties"),
                 self.trUtf8("<p>The user specific project properties file <b>{0}</b>"
                     " could not be written.</p>").format(fn))
     def __readSession(self, quiet = False, indicator = ""):
         """
         Private method to read in the project session file (.e4s)
         @param quiet flag indicating quiet operations.
                 If this flag is true, no errors are reported.
         @keyparam indicator indicator string (string)
         """
         if self.pfile is None:
             if not quiet:
                 QMessageBox.critical(None,
                     self.trUtf8("Read project session"),
                     self.trUtf8("Please save the project first."))
             return
         fn, ext = os.path.splitext(os.path.basename(self.pfile))
         try:
             if ext.lower() in [".e4pz"]:
                 fn = os.path.join(self.getProjectManagementDir(),
                                   '%s%s.e4sz' % (fn, indicator))
                 try:
                     import gzip
                 except ImportError:
                     if not quiet:
                         QMessageBox.critical(None,
                             self.trUtf8("Read project session"),
                             self.trUtf8("""Compressed project session files not"""
                                 """ supported. The compression library is missing."""))
                     return
                 g = gzip.open(fn, "rb")
                 f = io.StringIO(g.read().decode("utf-8"))
                 g.close()
             else:
                 fn = os.path.join(self.getProjectManagementDir(),
                                   '%s%s.e4s' % (fn, indicator))
                 f = open(fn, "r", encoding = "utf-8")
             line = f.readline()
             dtdLine = f.readline()
             f.close()
         except EnvironmentError:
             if not quiet:
                 QMessageBox.critical(None,
                     self.trUtf8("Read project session"),
                     self.trUtf8("<p>The project session <b>{0}</b>"
                                 " could not be read.</p>")\
                         .format(fn))
             return
         # now read the file
         if line.startswith('<?xml'):
             self.__readXMLSession(fn, dtdLine.startswith("<!DOCTYPE"), quiet)
         else:
             if not quiet:
                 QMessageBox.critical(None,
                     self.trUtf8("Read project session"),
                     self.trUtf8("<p>The project session <b>{0}</b> has an unsupported"
                         " format.</p>").format(fn))
     def __readXMLSession(self, fn, validating, quiet):
         """
         Private method to read the session data from an XML file.
         The data read is:
             <ul>
             <li>all open source filenames</li>
             <li>the active window</li>
             <li>all breakpoints</li>
             <li>the commandline</li>
             <li>the working directory</li>
             <li>the exception reporting flag</li>
             <li>the list of exception types to be highlighted</li>
             <li>all bookmarks</li>
             </ul>
         @param fn filename of the project session file to be read (string)
         @param validating flag indicating a validation of the XML file is
             requested (boolean)
         @param quiet flag indicating quiet operations.
             If this flag is true, no errors are reported.
         """
         if fn.lower().endswith("e4sz"):
             # work around for a bug in xmlproc
             validating = False
         parser = make_parser(validating)
         handler = SessionHandler(self)
         er = XMLEntityResolver()
         eh = XMLErrorHandler()
         parser.setContentHandler(handler)
         parser.setEntityResolver(er)
         parser.setErrorHandler(eh)
         try:
             if fn.lower().endswith("e4sz"):
                 try:
                     import gzip
                 except ImportError:
                     if not quiet:
                         QMessageBox.critical(None,
                             self.trUtf8("Read project session"),
                             self.trUtf8("<p>The project session <b>{0}</b> could not"
                                 " be read.</p>").format(fn))
                     return
                 g = gzip.open(fn, "rb")
                 f = io.StringIO(g.read().decode("utf-8"))
                 g.close()
             else:
                 f = open(fn, "r", encoding = "utf-8")
             try:
                 try:
                     parser.parse(f)
                 except UnicodeEncodeError:
                     f.seek(0)
                     buf = io.StringIO(f.read())
                     parser.parse(buf)
             finally:
                 f.close()
         except IOError:
             if not quiet:
                 QMessageBox.critical(None,
                     self.trUtf8("Read project session"),
                     self.trUtf8("<p>The project session file <b>{0}</b> could not be"
                         " read.</p>").format(fn))
             return
         except XMLFatalParseError:
             pass
         if not quiet:
             eh.showParseMessages()
     def __writeSession(self, quiet = False, indicator = ""):
         """
         Private method to write the session data to an XML file (.e4s).
         The data saved is:
             <ul>
             <li>all open source filenames belonging to the project</li>
             <li>the active window, if it belongs to the project</li>
             <li>all breakpoints</li>
             <li>the commandline</li>
             <li>the working directory</li>
             <li>the exception reporting flag</li>
             <li>the list of exception types to be highlighted</li>
             <li>all bookmarks of files belonging to the project</li>
             </ul>
         @param quiet flag indicating quiet operations.
                 If this flag is true, no errors are reported.
         @keyparam indicator indicator string (string)
         """
         if self.pfile is None:
             if not quiet:
                 QMessageBox.critical(None,
                     self.trUtf8("Save project session"),
                     self.trUtf8("Please save the project first."))
             return
         fn, ext = os.path.splitext(os.path.basename(self.pfile))
         try:
             if ext.lower() == ".e4pz":
                 fn = os.path.join(self.getProjectManagementDir(),
                                   '%s%s.e4sz' % (fn, indicator))
                 try:
                     import gzip
                 except ImportError:
                     if not quiet:
                         QMessageBox.critical(None,
                             self.trUtf8("Save project session"),
                             self.trUtf8("""Compressed project session files not"""
                                 """ supported. The compression library is missing."""))
                     return
                 f = io.StringIO()
             else:
                 fn = os.path.join(self.getProjectManagementDir(),
                                   '%s%s.e4s' % (fn, indicator))
                 f = open(fn, "w", encoding = "utf-8")
             SessionWriter(f, os.path.splitext(os.path.basename(fn))[0]).writeXML()
             if fn.lower().endswith("e4sz"):
                 g = gzip.open(fn, "wb")
                 g.write(f.getvalue().encode("utf-8"))
                 g.close()
             f.close()
         except IOError:
             if not quiet:
                 QMessageBox.critical(None,
                     self.trUtf8("Save project session"),
                     self.trUtf8("<p>The project session file <b>{0}</b> could not be"
                         " written.</p>").format(fn))
     def __deleteSession(self):
         """
         Private method to delete the session file.
         """
         if self.pfile is None:
             if not quiet:
                 QMessageBox.critical(None,
                     self.trUtf8("Delete project session"),
                     self.trUtf8("Please save the project first."))
             return
         fname, ext = os.path.splitext(os.path.basename(self.pfile))
         for fn in [os.path.join(self.getProjectManagementDir(), "%s.e4sz" % fname),
                    os.path.join(self.getProjectManagementDir(), "%s.e4s" % fname)]:
             if os.path.exists(fn):
                 try:
                     os.remove(fn)
                 except OSError:
                     QMessageBox.critical(None,
                         self.trUtf8("Delete project session"),
                         self.trUtf8("<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 (.e4t)
         """
         if self.pfile is None:
             QMessageBox.critical(None,
                 self.trUtf8("Read tasks"),
                 self.trUtf8("Please save the project first."))
             return
         fn, ext = os.path.splitext(os.path.basename(self.pfile))
         try:
             if ext.lower() in [".e4pz"]:
                 fn = os.path.join(self.getProjectManagementDir(), '%s.e4tz' % fn)
                 if not os.path.exists(fn):
                     return
                 try:
                     import gzip
                 except ImportError:
                     QMessageBox.critical(None,
                         self.trUtf8("Read tasks"),
                         self.trUtf8("""Compressed tasks files not supported."""
                             """ The compression library is missing."""))
                     return
                 g = gzip.open(fn, "rb")
                 f = io.StringIO(g.read().decode("utf-8"))
                 g.close()
             else:
                 fn = os.path.join(self.getProjectManagementDir(), '%s.e4t' % fn)
                 if not os.path.exists(fn):
                     return
                 f = open(fn, "r", encoding = "utf-8")
             line = f.readline()
             dtdLine = f.readline()
             f.close()
         except EnvironmentError:
             QMessageBox.critical(None,
                 self.trUtf8("Read tasks"),
                 self.trUtf8("<p>The tasks file <b>{0}</b> could not be read.</p>")\
                     .format(fn))
             return
         # now read the file
         if line.startswith('<?xml'):
             self.__readXMLTasks(fn, dtdLine.startswith("<!DOCTYPE"))
         else:
             QMessageBox.critical(None,
                 self.trUtf8("Read project session"),
                 self.trUtf8("<p>The tasks file <b>{0}</b> has an unsupported"
                             " format.</p>")\
                     .format(fn))
     def __readXMLTasks(self, fn, validating):
         """
         Private method to read the project tasks data from an XML file.
         @param fn filename of the project tasks file to be read (string)
         @param validating flag indicating a validation of the XML file is
             requested (boolean)
         """
         if fn.lower().endswith("e4tz"):
             # work around for a bug in xmlproc
             validating = False
         parser = make_parser(validating)
         handler = TasksHandler(1)
         er = XMLEntityResolver()
         eh = XMLErrorHandler()
         parser.setContentHandler(handler)
         parser.setEntityResolver(er)
         parser.setErrorHandler(eh)
         try:
             if fn.lower().endswith("e4tz"):
                 try:
                     import gzip
                 except ImportError:
                     QMessageBox.critical(None,
                         self.trUtf8("Read tasks"),
                         self.trUtf8("""Compressed tasks files not supported."""
                             """ The compression library is missing."""))
                     return
                 g = gzip.open(fn, "rb")
                 f = io.StringIO(g.read().decode("utf-8"))
                 g.close()
             else:
                 f = open(fn, "r", encoding = "utf-8")
             try:
                 try:
                     parser.parse(f)
                 except UnicodeEncodeError:
                     f.seek(0)
                     buf = io.StringIO(f.read())
                     parser.parse(buf)
             finally:
                 f.close()
         except IOError:
             QMessageBox.critical(None,
                 self.trUtf8("Read tasks"),
                 self.trUtf8("<p>The tasks file <b>{0}</b> could not be read.</p>")\
                     .format(fn))
             return
         except XMLFatalParseError:
             pass
         eh.showParseMessages()
     def __writeTasks(self):
         """
         Private method to write the tasks data to an XML file (.e4t).
         """
         if self.pfile is None:
             return
         fn, ext = os.path.splitext(os.path.basename(self.pfile))
         try:
             if ext.lower() == ".e4pz":
                 fn = os.path.join(self.getProjectManagementDir(), '%s.e4tz' % fn)
                 try:
                     import gzip
                 except ImportError:
                     QMessageBox.critical(None,
                         self.trUtf8("Save tasks"),
                         self.trUtf8("""Compressed tasks files not supported."""
                             """ The compression library is missing."""))
                     return
                 f = io.StringIO()
             else:
                 fn = os.path.join(self.getProjectManagementDir(), '%s.e4t' % fn)
                 f = open(fn, "w", encoding = "utf-8")
             TasksWriter(f, True, os.path.splitext(os.path.basename(fn))[0]).writeXML()
             if fn.lower().endswith("e4tz"):
 e62c0b9cb
Ported the gzip related code.

Detlev O

Mercurial Repositories > eric / annotate

Project/Project.py@375e3c884874 (annotated)

Project/Project.py