eric: comparison Project/Project.py

-:0a74c1efab70
+:0daf79d65080
 import fnmatch
 import copy
 import zipfile
 from PyQt5.QtCore import pyqtSlot, QFile, QFileInfo, pyqtSignal, \
-QCryptographicHash, QIODevice, QByteArray, QObject, Qt
+QCryptographicHash, QIODevice, QByteArray, QObject, Qt, QProcess
 from PyQt5.QtGui import QCursor, QKeySequence
 from PyQt5.QtWidgets import QLineEdit, QToolBar, QDialog, QInputDialog, \
 QApplication, QMenu, QAction
 from PyQt5.Qsci import QsciScintilla
 @signal showMenu(str, 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
 @signal projectChanged() emitted to signal a change of the project
+@signal appendStdout(str) emitted after something was received from
+a QProcess on stdout
+@signal appendStderr(str) emitted after something was received from
+a QProcess on stderr
 """
 dirty = pyqtSignal(int)
 projectLanguageAdded = pyqtSignal(str)
 projectLanguageAddedByCode = pyqtSignal(str)
 projectLanguageRemoved = pyqtSignal(str)
 vcsStatusMonitorStatus = pyqtSignal(str, str)
 reinitVCS = pyqtSignal()
 showMenu = pyqtSignal(str, QMenu)
 lexerAssociationsChanged = pyqtSignal()
 projectChanged = pyqtSignal()
+appendStdout = pyqtSignal(str)
+appendStderr = pyqtSignal(str)
 eols = [os.linesep, "\n", "\r", "\r\n"]
+DefaultMake = "make"
+DefaultMakefile = "makefile"
 def __init__(self, parent=None, filename=None):
 """
 Constructor
 "Python3 Files (*.py *.py3);;"
 "Python3 GUI Files (*.pyw *.pyw3);;"),
 }
 self.vcsMenu = None
+self.__makeProcess = None
 self.__initProjectTypes()
 self.__initData()
 "PROJECTTYPESPECIFICDATA": {},
 "CHECKERSPARMS": {},
 "PACKAGERSPARMS": {},
 "DOCUMENTATIONPARMS": {},
 "OTHERTOOLSPARMS": {},
+"MAKEPARAMS": {
+"MakeEnabled": False,
+"MakeExecutable": "",
+"MakeFile": "",
+"MakeTarget": "",
+"MakeParameters": "",
+"MakeTestOnly": True,
+},
 "EOL": -1,
 }
 self.__initDebugProperties()
 "*.md": "OTHERS",
 "*.rst": "OTHERS",
 "README": "OTHERS",
 "README.*": "OTHERS",
 "*.e4p": "OTHERS",
+"GNUmakefile": "OTHERS",
+"makefile": "OTHERS",
+"Makefile": "OTHERS",
 }
 # Sources
 if self.pdata["MIXEDLANGUAGE"]:
 sourceKey = "Mixed"
 try:
 fn = os.path.join(self.ppath, langFile)
 if os.path.exists(fn):
 s2t(fn)
-except EnvironmentError:
+except EnvironmentError as err:
 E5MessageBox.critical(
 self.ui,
 self.tr("Delete translation"),
 self.tr(
 "<p>The selected translation file <b>{0}</b> could not be"
-" deleted.</p>").format(langFile))
+" deleted.</p><p>Reason: {1}</p>").format(
+langFile, str(err)))
 return
 self.removeLanguageFile(langFile)
 # now get rid of the .qm file
 os.path.join(self.pdata["TRANSLATIONSBINPATH"],
 os.path.basename(qmFile)))
 fn = os.path.join(self.ppath, qmFile)
 if os.path.exists(fn):
 s2t(fn)
-except EnvironmentError:
+except EnvironmentError as err:
 E5MessageBox.critical(
 self.ui,
 self.tr("Delete translation"),
 self.tr(
 "<p>The selected translation file <b>{0}</b> could"
-" not be deleted.</p>").format(qmFile))
+" not be deleted.</p><p>Reason: {1}</p>").format(
+qmFile, str(err)))
 return
 def appendFile(self, fn, isSourceFile=False, updateModel=True):
 """
 Public method to append a file to the project.
 pat = os.path.join(
 self.ppath, head,
 "__pycache__", "{0}.*{1}".format(tail, ext))
 for f in glob.glob(pat):
 s2t(f)
-except EnvironmentError:
+except EnvironmentError as err:
 E5MessageBox.critical(
 self.ui,
 self.tr("Delete file"),
 self.tr(
 "<p>The selected file <b>{0}</b> could not be"
-" deleted.</p>").format(fn))
+" deleted.</p><p>Reason: {1}</p>").format(
+fn, str(err)))
 return False
 self.removeFile(fn)
 if ext == '.ui':
 self.removeFile(fn + '.h')
 try:
 from ThirdParty.Send2Trash.send2trash import send2trash
 send2trash(dn)
 except ImportError:
 shutil.rmtree(dn, True)
-except EnvironmentError:
+except EnvironmentError as err:
 E5MessageBox.critical(
 self.ui,
 self.tr("Delete directory"),
 self.tr(
 "<p>The selected directory <b>{0}</b> could not be"
-" deleted.</p>").format(dn))
+" deleted.</p><p>Reason: {1}</p>").format(dn, str(err)))
 return False
 self.removeDirectory(dn)
 return True
 self.menuPackagersAct.setEnabled(True)
 self.pluginGrp.setEnabled(
 self.pdata["PROJECTTYPE"] in ["E6Plugin"])
 self.addLanguageAct.setEnabled(
 bool(self.pdata["TRANSLATIONPATTERN"]))
+self.makeGrp.setEnabled(
+self.pdata["MAKEPARAMS"]["MakeEnabled"])
+self.menuMakeAct.setEnabled(
+self.pdata["MAKEPARAMS"]["MakeEnabled"])
 self.projectAboutToBeCreated.emit()
 hashStr = str(QCryptographicHash.hash(
 QByteArray(self.ppath.encode("utf-8")),
 "<p>The project directory <b>{0}</b> could not"
 " be created.</p>")
 .format(self.ppath))
 self.vcs = self.initVCS()
 return
 # create an empty __init__.py file to make it a Python package
 # (only for Python and Python3)
 if self.pdata["PROGLANGUAGE"] in \
 ["Python", "Python2", "Python3"]:
 fn = os.path.join(self.ppath, "__init__.py")
 f = open(fn, "w", encoding="utf-8")
 f.close()
 self.appendFile(fn, True)
 # create an empty main script file, if a name was given
 if self.pdata["MAINSCRIPT"]:
 if not os.path.isabs(self.pdata["MAINSCRIPT"]):
 ms = os.path.join(
 self.ppath, self.pdata["MAINSCRIPT"])
 else:
 ms = self.pdata["MAINSCRIPT"]
 f = open(ms, "w")
 f.close()
 self.appendFile(ms, True)
+if self.pdata["MAKEPARAMS"]["MakeEnabled"]:
+mf = self.pdata["MAKEPARAMS"]["MakeFile"]
+if mf:
+if not os.path.isabs(mf):
+mf = os.path.join(self.ppath, mf)
+else:
+mf = os.path.join(self.ppath, Project.DefaultMakefile)
+f = open(mf, "w")
+f.close()
+self.appendFile(mf)
 tpd = os.path.join(self.ppath, self.translationsRoot)
 if not self.translationsRoot.endswith(os.sep):
 tpd = os.path.dirname(tpd)
 if not os.path.isdir(tpd):
 os.makedirs(tpd)
 self.ui,
 self.tr("Create main script"),
 self.tr(
 "<p>The mainscript <b>{0}</b> could not"
 " be created.<br/>Reason: {1}</p>")
-.format(self.ppath, str(err)))
+.format(ms, str(err)))
-self.appendFile(ms)
+self.appendFile(ms, True)
 else:
 ms = ""
+if self.pdata["MAKEPARAMS"]["MakeEnabled"]:
+mf = self.pdata["MAKEPARAMS"]["MakeFile"]
+if mf:
+if not os.path.isabs(mf):
+mf = os.path.join(self.ppath, mf)
+else:
+mf = os.path.join(self.ppath, Project.DefaultMakefile)
+if not os.path.exists(mf):
+try:
+f = open(mf, "w")
+f.close()
+except EnvironmentError as err:
+E5MessageBox.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(
 self.ui,
 self.tr("New Project"),
 else:
 ms = self.pdata["MAINSCRIPT"]
 if os.path.exists(ms):
 self.appendFile(ms)
+if self.pdata["MAKEPARAMS"]["MakeEnabled"]:
+mf = self.pdata["MAKEPARAMS"]["MakeFile"]
+if mf:
+if not os.path.isabs(mf):
+mf = os.path.join(self.ppath, mf)
+else:
+mf = os.path.join(self.ppath, Project.DefaultMakefile)
+if not os.path.exists(mf):
+try:
+f = open(mf, "w")
+f.close()
+except EnvironmentError as err:
+E5MessageBox.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)
 if self.pdata["PROJECTTYPE"] != projectType:
 # reinitialize filetype associations
 self.initFileTypes()
 if self.translationsRoot:
 self.menuPackagersAct.setEnabled(True)
 self.pluginGrp.setEnabled(
 self.pdata["PROJECTTYPE"] in ["E6Plugin"])
 self.addLanguageAct.setEnabled(
 bool(self.pdata["TRANSLATIONPATTERN"]))
+self.makeGrp.setEnabled(
+self.pdata["MAKEPARAMS"]["MakeEnabled"])
+self.menuMakeAct.setEnabled(
+self.pdata["MAKEPARAMS"]["MakeEnabled"])
 self.__model.projectOpened()
 self.projectOpenedHooks.emit()
 self.projectOpened.emit()
 if Preferences.getProject("AutoSaveDbgProperties") and \
 self.isDebugPropertiesLoaded() and \
 not noSave:
 self.__writeDebugProperties(True)
-# now save all open modified files of the project
 vm = e5App().getObject("ViewManager")
+# check dirty status of all project files first
+for fn in vm.getOpenFilenames():
+if self.isProjectFile(fn):
+reset = vm.checkFileDirty(fn)
+if not reset:
+# abort shutting down
+return False
+# close all project related editors
 success = True
 for fn in vm.getOpenFilenames():
 if self.isProjectFile(fn):
-success &= vm.closeWindow(fn)
+success &= vm.closeWindow(fn, ignoreDirty=True)
 if not success:
 return False
 # stop the VCS monitor thread
 if self.vcs is not None:
 self.vcs.vcsShutdown()
 self.vcs.deleteLater()
 self.vcs = None
 e5App().getObject("PluginManager").deactivateVcsPlugins()
-# now close all project related windows
+# now close all project related tool windows
 self.__closeAllWindows()
 self.__initData()
 self.closeAct.setEnabled(False)
 self.saveasAct.setEnabled(False)
 self.menuShowAct.setEnabled(False)
 self.menuDiagramAct.setEnabled(False)
 self.menuApidocAct.setEnabled(False)
 self.menuPackagersAct.setEnabled(False)
 self.pluginGrp.setEnabled(False)
+self.makeGrp.setEnabled(False)
+self.menuMakeAct.setEnabled(False)
 self.__model.projectClosed()
 self.projectClosedHooks.emit()
 self.projectClosed.emit()
 ))
 self.pluginSArchiveAct.triggered.connect(
 self.__pluginCreateSnapshotArchives)
 self.actions.append(self.pluginSArchiveAct)
+self.makeGrp = createActionGroup(self)
+self.makeExecuteAct = E5Action(
+self.tr('Execute Make'),
+self.tr('&Execute Make'), 0, 0,
+self.makeGrp, 'project_make_execute')
+self.makeExecuteAct.setStatusTip(
+self.tr("Perform a 'make' run."))
+self.makeExecuteAct.setWhatsThis(self.tr(
+"""<b>Execute Make</b>"""
+"""<p>This performs a 'make' run to rebuild the configured"""
+""" target.</p>"""
+))
+self.makeExecuteAct.triggered.connect(self.__executeMake)
+self.actions.append(self.makeExecuteAct)
+self.makeTestAct = E5Action(
+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."))
+self.makeTestAct.setWhatsThis(self.tr(
+"""<b>Test for Changes</b>"""
+"""<p>This questions 'make', if a rebuild of the configured"""
+""" target is necessary.</p>"""
+))
+self.makeTestAct.triggered.connect(
+lambda: self.__executeMake(questionOnly=True))
+self.actions.append(self.makeTestAct)
 self.closeAct.setEnabled(False)
 self.saveAct.setEnabled(False)
 self.saveasAct.setEnabled(False)
 self.actGrp2.setEnabled(False)
 self.propsAct.setEnabled(False)
 self.sessionMenu = QMenu(self.tr('Session'), menu)
 self.apidocMenu = QMenu(self.tr('Source &Documentation'), menu)
 self.apidocMenu.setTearOffEnabled(True)
 self.debuggerMenu = QMenu(self.tr('Debugger'), menu)
 self.packagersMenu = QMenu(self.tr('Pac&kagers'), menu)
-self.packagersMenu.setTearOffEnabled(True)
+self.makeMenu = QMenu(self.tr('Make'), menu)
 self.__menus = {
 "Main": menu,
 "Recent": self.recentMenu,
 "VCS": self.vcsMenu,
 "Graphics": self.graphicsMenu,
 "Session": self.sessionMenu,
 "Apidoc": self.apidocMenu,
 "Debugger": self.debuggerMenu,
 "Packagers": self.packagersMenu,
+"Make": self.makeMenu,
 }
 # connect the aboutToShow signals
 self.recentMenu.aboutToShow.connect(self.__showContextMenuRecent)
 self.recentMenu.triggered.connect(self.__openRecent)
 self.graphicsMenu.aboutToShow.connect(self.__showContextMenuGraphics)
 self.apidocMenu.aboutToShow.connect(self.__showContextMenuApiDoc)
 self.packagersMenu.aboutToShow.connect(self.__showContextMenuPackagers)
 self.sessionMenu.aboutToShow.connect(self.__showContextMenuSession)
 self.debuggerMenu.aboutToShow.connect(self.__showContextMenuDebugger)
+self.makeMenu.aboutToShow.connect(self.__showContextMenuMake)
 menu.aboutToShow.connect(self.__showMenu)
 # build the show menu
 self.menuShow.setTearOffEnabled(True)
 self.menuShow.addAction(self.codeMetricsAct)
 # build the debugger menu
 self.debuggerMenu.setTearOffEnabled(True)
 self.debuggerMenu.addActions(self.dbgActGrp.actions())
 # build the packagers menu
+self.packagersMenu.setTearOffEnabled(True)
 self.packagersMenu.addActions(self.pluginGrp.actions())
 self.packagersMenu.addSeparator()
+# build the make menu
+self.makeMenu.setTearOffEnabled(True)
+self.makeMenu.addActions(self.makeGrp.actions())
+self.makeMenu.addSeparator()
 # build the main menu
 menu.setTearOffEnabled(True)
 menu.addActions(self.actGrp1.actions())
 self.menuRecentAct = menu.addMenu(self.recentMenu)
 menu.addSeparator()
 self.menuDebuggerAct = menu.addMenu(self.debuggerMenu)
 self.menuSessionAct = menu.addMenu(self.sessionMenu)
 menu.addSeparator()
 menu.addActions(self.actGrp2.actions())
+menu.addSeparator()
+self.menuMakeAct = menu.addMenu(self.makeMenu)
 menu.addSeparator()
 self.menuDiagramAct = menu.addMenu(self.graphicsMenu)
 menu.addSeparator()
 self.menuCheckAct = menu.addMenu(self.checksMenu)
 menu.addSeparator()
 self.menuDiagramAct.setEnabled(False)
 self.menuSessionAct.setEnabled(False)
 self.menuDebuggerAct.setEnabled(False)
 self.menuApidocAct.setEnabled(False)
 self.menuPackagersAct.setEnabled(False)
+self.menuMakeAct.setEnabled(False)
 self.menu = menu
 return menu
 def initToolbars(self, toolbarManager):
 version = sourceline.replace("version = ", "").strip()\
 .replace('"', "").replace("'", "")
 break
 return version
+#########################################################################
+## Below are methods implementing the 'make' support
+#########################################################################
+def __showContextMenuMake(self):
+"""
+Private slot called before the make menu is shown.
+"""
+self.showMenu.emit("Make", self.makeMenu)
+def hasDefaultMakeParameters(self):
+"""
+Public method to test, if the project contains the default make
+parameters.
+@return flag indicating default parameter set
+@rtype bool
+"""
+return self.pdata["MAKEPARAMS"] == {
+"MakeEnabled": False,
+"MakeExecutable": "",
+"MakeFile": "",
+"MakeTarget": "",
+"MakeParameters": "",
+"MakeTestOnly": True,
+}
+def isMakeEnabled(self):
+"""
+Public method to test, if make is enabled for the project.
+@return flag indicating enabled make support
+@rtype bool
+"""
+return self.pdata["MAKEPARAMS"]["MakeEnabled"]
+@pyqtSlot()
+def executeMake(self):
+"""
+Public slot to execute a project specific make run (auto-run)
+(execute or question).
+"""
+self.__executeMake(
+questionOnly=self.pdata["MAKEPARAMS"]["MakeTestOnly"],
+interactive=False)
+@pyqtSlot()
+def __executeMake(self, questionOnly=False, interactive=True):
+"""
+Private method to execute a project specific make run.
+@param questionOnly flag indicating to ask make for changes only
+@type bool
+@param interactive flag indicating an interactive invocation (i.e.
+through a menu action)
+@type bool
+"""
+if not self.pdata["MAKEPARAMS"]["MakeEnabled"] or \
+self.__makeProcess is not None:
+return
+if self.pdata["MAKEPARAMS"]["MakeExecutable"]:
+prog = self.pdata["MAKEPARAMS"]["MakeExecutable"]
+else:
+prog = Project.DefaultMake
+args = []
+if self.pdata["MAKEPARAMS"]["MakeParameters"]:
+args.extend(Utilities.parseOptionString(
+self.pdata["MAKEPARAMS"]["MakeParameters"]))
+if self.pdata["MAKEPARAMS"]["MakeFile"]:
+args.append("--makefile={0}".format(
+self.pdata["MAKEPARAMS"]["MakeFile"]))
+if questionOnly:
+args.append("--question")
+if self.pdata["MAKEPARAMS"]["MakeTarget"]:
+args.append(self.pdata["MAKEPARAMS"]["MakeTarget"])
+self.__makeProcess = QProcess(self)
+self.__makeProcess.readyReadStandardOutput.connect(
+self.__makeReadStdOut)
+self.__makeProcess.readyReadStandardError.connect(
+self.__makeReadStdErr)
+self.__makeProcess.finished.connect(
+lambda exitCode, exitStatus: self.__makeFinished(
+exitCode, exitStatus, questionOnly, interactive))
+self.__makeProcess.setWorkingDirectory(self.getProjectPath())
+self.__makeProcess.start(prog, args)
+if not self.__makeProcess.waitForStarted():
+E5MessageBox.critical(
+self.ui,
+self.tr("Execute Make"),
+self.tr("""The make process did not start."""))
+self.__cleanupMake()
+@pyqtSlot()
+def __makeReadStdOut(self):
+"""
+Private slot to process process output received via stdout.
+"""
+if self.__makeProcess is not None:
+output = str(self.__makeProcess.readAllStandardOutput(),
+Preferences.getSystem("IOEncoding"),
+'replace')
+self.appendStdout.emit(output)
+@pyqtSlot()
+def __makeReadStdErr(self):
+"""
+Private slot to process process output received via stderr.
+"""
+if self.__makeProcess is not None:
+error = str(self.__makeProcess.readAllStandardError(),
+Preferences.getSystem("IOEncoding"),
+'replace')
+self.appendStderr.emit(error)
+def __makeFinished(self, exitCode, exitStatus, questionOnly,
+interactive=True):
+"""
+Private slot handling the make process finished signal.
+@param exitCode exit code of the make process
+@type int
+@param exitStatus exit status of the make process
+@type QProcess.ExitStatus
+@param questionOnly flag indicating a test only run
+@type bool
+@param interactive flag indicating an interactive invocation (i.e.
+through a menu action)
+@type bool
+"""
+if exitStatus == QProcess.CrashExit:
+E5MessageBox.critical(
+self.ui,
+self.tr("Execute Make"),
+self.tr("""The make process crashed."""))
+else:
+if questionOnly and exitCode == 1:
+# a rebuild is needed
+title = self.tr("Test for Changes")
+if self.pdata["MAKEPARAMS"]["MakeTarget"]:
+message = self.tr(
+"""<p>There are changes that require the configured"""
+""" make target <b>{0}</b> to be rebuilt.</p>""")\
+.format(self.pdata["MAKEPARAMS"]["MakeTarget"])
+else:
+message = self.tr(
+"""<p>There are changes that require the default"""
+""" make target to be rebuilt.</p>""")
+if self.ui.notificationsEnabled() and not interactive:
+self.ui.showNotification(
+UI.PixmapCache.getPixmap("makefile48.png"),
+title,
+message)
+else:
+E5MessageBox.information(self.ui, title, message)
+elif exitCode > 1:
+E5MessageBox.critical(
+self.ui,
+self.tr("Execute Make"),
+self.tr("""The makefile contains errors."""))
+self.__cleanupMake()
+def __cleanupMake(self):
+"""
+Private method to clean up make related stuff.
+"""
+self.__makeProcess.readyReadStandardOutput.disconnect()
+self.__makeProcess.readyReadStandardError.disconnect()
+self.__makeProcess.finished.disconnect()
+self.__makeProcess.deleteLater()
+self.__makeProcess = None

Mercurial Repositories > eric / file comparison

comparison: Project/Project.py

Project/Project.py