eric: comparison Project/Project.py

-:622ab17a68d5
+:c3abc7895a01
 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
+@signal vcsStatusMonitorStatus(string, string) 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
 """
+dirty = pyqtSignal(int)
+projectLanguageAdded = pyqtSignal(str)
+projectLanguageAddedByCode = pyqtSignal(str)
+projectFormAdded = pyqtSignal(str)
+projectSourceAdded = pyqtSignal(str)
+projectInterfaceAdded = pyqtSignal(str)
+projectResourceAdded = pyqtSignal(str)
+projectOthersAdded = pyqtSignal(str)
+projectAboutToBeCreated = pyqtSignal()
+newProjectHooks = pyqtSignal()
+newProject = pyqtSignal()
 sourceFile = pyqtSignal(str)
+projectOpenedHooks = pyqtSignal()
 projectOpened = pyqtSignal()
-newProject = pyqtSignal()
+projectClosedHooks = pyqtSignal()
 projectClosed = pyqtSignal()
+projectFileRenamed = pyqtSignal(str, str)
+projectPropertiesChanged = pyqtSignal()
+directoryRemoved = pyqtSignal(str)
+prepareRepopulateItem = pyqtSignal(str)
+completeRepopulateItem = pyqtSignal(str)
+vcsStatusMonitorStatus = pyqtSignal(str, str)
+reinitVCS = pyqtSignal()
+showMenu = pyqtSignal(str, QMenu)
+lexerAssociationsChanged = pyqtSignal()
 keynames = [
 "PROGLANGUAGE", "MIXEDLANGUAGE", "PROJECTTYPE",
 "SPELLLANGUAGE", "SPELLWORDS", "SPELLEXCLUDES",
 "DESCRIPTION", "VERSION", "HASH",
 @param b dirty state (boolean)
 """
 self.dirty = b
 self.saveAct.setEnabled(b)
-self.emit(SIGNAL("dirty"), bool(b))
+self.dirty.emit(bool(b))
 def isDirty(self):
 """
 Public method to return the dirty state.
 lang = dlg.getSelectedLanguage()
 if self.pdata["PROJECTTYPE"][0] in \
 ["Qt4", "Qt4C", "E4Plugin", "PySide", "PySideC"]:
 langFile = self.pdata["TRANSLATIONPATTERN"][0].replace("%language%", lang)
 self.appendFile(langFile)
-self.emit(SIGNAL("projectLanguageAddedByCode"), lang)
+self.projectLanguageAddedByCode.emit(lang)
 def __binaryTranslationFile(self, langFile):
 """
 Private method to calculate the filename of the binary translations file
 given the name of the raw translations file.
 if filetype in ["SOURCES", "FORMS", "INTERFACES", "RESOURCES"]:
 if filetype == "SOURCES":
 if newfn not in self.pdata["SOURCES"]:
 self.pdata["SOURCES"].append(newfn)
-self.emit(SIGNAL('projectSourceAdded'), newfn)
+self.projectSourceAdded.emit(newfn)
 updateModel and self.__model.addNewItem("SOURCES", newfn)
 dirty = True
 else:
 updateModel and self.repopulateItem(newfn)
 elif filetype == "FORMS":
 if newfn not in self.pdata["FORMS"]:
 self.pdata["FORMS"].append(newfn)
-self.emit(SIGNAL('projectFormAdded'), newfn)
+self.projectFormAdded.emit(newfn)
 updateModel and self.__model.addNewItem("FORMS", newfn)
 dirty = True
 else:
 updateModel and self.repopulateItem(newfn)
 elif filetype == "INTERFACES":
 if newfn not in self.pdata["INTERFACES"]:
 self.pdata["INTERFACES"].append(newfn)
-self.emit(SIGNAL('projectInterfaceAdded'), newfn)
+self.projectInterfaceAdded.emit(newfn)
 updateModel and self.__model.addNewItem("INTERFACES", newfn)
 dirty = True
 else:
 updateModel and self.repopulateItem(newfn)
 elif filetype == "RESOURCES":
 if newfn not in self.pdata["RESOURCES"]:
 self.pdata["RESOURCES"].append(newfn)
-self.emit(SIGNAL('projectResourceAdded'), newfn)
+self.projectResourceAdded.emit(newfn)
 updateModel and self.__model.addNewItem("RESOURCES", newfn)
 dirty = True
 else:
 updateModel and self.repopulateItem(newfn)
 if newdir not in self.subdirs:
 self.subdirs.append(newdir)
 elif filetype == "TRANSLATIONS":
 if newfn not in self.pdata["TRANSLATIONS"]:
 self.pdata["TRANSLATIONS"].append(newfn)
 updateModel and self.__model.addNewItem("TRANSLATIONS", newfn)
-self.emit(SIGNAL('projectLanguageAdded'), newfn)
+self.projectLanguageAdded.emit(newfn)
 dirty = True
 else:
 updateModel and self.repopulateItem(newfn)
 else:   # filetype == "OTHERS"
 if newfn not in self.pdata["OTHERS"]:
 self.appendFile(newname, isSourceFile, False)
 self.__model.renameItem(fn, newname)
 else:
 self.removeFile(oldname)
 self.appendFile(newname, isSourceFile)
-self.emit(SIGNAL('projectFileRenamed'), oldname, newname)
+self.projectFileRenamed.emit(oldname, newname)
 self.renameMainScript(fn, newname)
 def getFiles(self, start):
 """
 self.setDirty(True)
 typeString = typeStrings[0]
 del typeStrings[0]
 self.__model.removeItem(olddn)
 self.__model.addNewItem(typeString, newdn, typeStrings)
-self.emit(SIGNAL('directoryRemoved'), olddn)
+self.directoryRemoved.emit(olddn)
 def removeFile(self, fn, updateModel = True):
 """
 Public slot to remove a file from the project.
 self.pdata[key].remove(entry)
 dirty = True
 self.__model.removeItem(dn)
 if dirty:
 self.setDirty(True)
-self.emit(SIGNAL('directoryRemoved'), dn)
+self.directoryRemoved.emit(dn)
 def deleteFile(self, fn):
 """
 Public slot to delete a file from the project directory.
 self.menuDiagramAct.setEnabled(True)
 self.menuApidocAct.setEnabled(True)
 self.menuPackagersAct.setEnabled(True)
 self.pluginGrp.setEnabled(self.pdata["PROJECTTYPE"][0] == "E4Plugin")
-self.emit(SIGNAL("projectAboutToBeCreated"))
+self.projectAboutToBeCreated.emit()
 hash = str(QCryptographicHash.hash(
 QByteArray(self.ppath), QCryptographicHash.Sha1).toHex(),
 encoding = "utf-8")
 self.pdata["HASH"] = [hash]
 # create the project in the VCS
 self.vcs.vcsSetDataFromDict(vcsDataDict)
 self.saveProject()
 self.vcs.vcsConvertProject(vcsDataDict, self)
 else:
-self.emit(SIGNAL('newProjectHooks'))
+self.newProjectHooks.emit()
 self.newProject.emit()
 else:
-self.emit(SIGNAL('newProjectHooks'))
+self.newProjectHooks.emit()
 self.newProject.emit()
 def newProjectAddFiles(self, mainscript):
 """
 self.getRelativePath(self.pdata["TRANSLATIONPATTERN"][0])
 pattern = self.pdata["TRANSLATIONPATTERN"][0].replace("%language%", "*")
 for ts in tslist:
 if fnmatch.fnmatch(ts, pattern):
 self.pdata["TRANSLATIONS"].append(ts)
-self.emit(SIGNAL('projectLanguageAdded'), ts)
+self.projectLanguageAdded.emit(ts)
 if len(self.pdata["MAINSCRIPT"]) == 0 or \
 len(self.pdata["MAINSCRIPT"][0]) == 0:
 if self.pdata["PROGLANGUAGE"][0] in ["Python", "Python3"]:
 self.pdata["MAINSCRIPT"] = ['{0}.py'.format(mainscriptname)]
 elif self.pdata["PROGLANGUAGE"][0] == "Ruby":
 os.path.basename(self.pdata["TRANSLATIONPATTERN"][0]))
 pattern = self.__binaryTranslationFile(pattern)
 qmlist = Utilities.direntries(tpd, True, pattern)
 for qm in qmlist:
 self.pdata["TRANSLATIONS"].append(qm)
-self.emit(SIGNAL('projectLanguageAdded'), qm)
+self.projectLanguageAdded.emit(qm)
 self.setDirty(True)
 QApplication.restoreOverrideCursor()
 def __showProperties(self):
 """
 self.subdirs.append(tp)
 self.pluginGrp.setEnabled(self.pdata["PROJECTTYPE"][0] == "E4Plugin")
 self.__model.projectPropertiesChanged()
-self.emit(SIGNAL('projectPropertiesChanged'))
+self.projectPropertiesChanged.emit()
 def __showUserProperties(self):
 """
 Private slot to display the user specific properties dialog.
 """
 (vcsSystemOverride is not None and \
 len(self.pudata["VCSOVERRIDE"]) == 0):
 # stop the VCS monitor thread and shutdown VCS
 if self.vcs is not None:
 self.vcs.stopStatusMonitor()
-self.disconnect(self.vcs,
+self.vcs.vcsStatusMonitorData.disconnect(self.__model.changeVCSStates)
-SIGNAL("vcsStatusMonitorData(QStringList)"),
+self.vcs.vcsStatusMonitorStatus.disconnect(self.__statusMonitorStatus)
-self.__model.changeVCSStates)
-self.disconnect(self.vcs,
-SIGNAL("vcsStatusMonitorStatus(QString, QString)"),
-self.__statusMonitorStatus)
 self.vcs.vcsShutdown()
 self.vcs = None
 e5App().getObject("PluginManager").deactivateVcsPlugins()
 # reinit VCS
 self.vcs = self.initVCS()
 # start the VCS monitor thread
 if self.vcs is not None:
 self.vcs.startStatusMonitor(self)
-self.connect(self.vcs,
+self.vcs.vcsStatusMonitorData.connect(self.__model.changeVCSStates)
-SIGNAL("vcsStatusMonitorData(QStringList)"),
+self.vcs.vcsStatusMonitorStatus.connect(self.__statusMonitorStatus)
-self.__model.changeVCSStates)
+self.reinitVCS.emit()
-self.connect(self.vcs,
-SIGNAL("vcsStatusMonitorStatus(QString, QString)"),
-self.__statusMonitorStatus)
-self.emit(SIGNAL("reinitVCS"))
 if self.pudata["VCSSTATUSMONITORINTERVAL"]:
 self.setStatusMonitorInterval(\
 self.pudata["VCSSTATUSMONITORINTERVAL"][0])
 else:
 """
 dlg = LexerAssociationDialog(self)
 if dlg.exec_() == QDialog.Accepted:
 dlg.transferData()
 self.setDirty(True)
-self.emit(SIGNAL("lexerAssociationsChanged"))
+self.lexerAssociationsChanged.emit()
 def getEditorLexerAssoc(self, filename):
 """
 Public method to retrieve a lexer association.
 self.menuApidocAct.setEnabled(True)
 self.menuPackagersAct.setEnabled(True)
 self.pluginGrp.setEnabled(self.pdata["PROJECTTYPE"][0] == "E4Plugin")
 self.__model.projectOpened()
-self.emit(SIGNAL('projectOpenedHooks'))
+self.projectOpenedHooks.emit()
 self.projectOpened.emit()
 QApplication.restoreOverrideCursor()
 if Preferences.getProject("SearchNewFiles"):
 self.__readDebugProperties(True)
 # start the VCS monitor thread
 if self.vcs is not None:
 self.vcs.startStatusMonitor(self)
-self.connect(self.vcs,
+self.vcs.vcsStatusMonitorData.connect(
-SIGNAL("vcsStatusMonitorData(QStringList)"),
+self.__model.changeVCSStates)
-self.__model.changeVCSStates)
+self.vcs.vcsStatusMonitorStatus.connect(
-self.connect(self.vcs,
+self.__statusMonitorStatus)
-SIGNAL("vcsStatusMonitorStatus(QString, QString)"),
-self.__statusMonitorStatus)
 else:
 QApplication.restoreOverrideCursor()
 def reopenProject(self):
 """
 # now save the tasks
 self.__writeTasks()
 self.sessActGrp.setEnabled(ok)
 self.menuSessionAct.setEnabled(ok)
-self.emit(SIGNAL('projectClosedHooks'))
+self.projectClosedHooks.emit()
 self.projectClosed.emit()
-self.emit(SIGNAL('projectOpenedHooks'))
+self.projectOpenedHooks.emit()
 self.projectOpened.emit()
 return True
 else:
 return False
 return False
 # stop the VCS monitor thread
 if self.vcs is not None:
 self.vcs.stopStatusMonitor()
-self.disconnect(self.vcs,
+self.vcs.vcsStatusMonitorData.disconnect(self.__model.changeVCSStates)
-SIGNAL("vcsStatusMonitorData(QStringList)"),
+self.vcs.vcsStatusMonitorStatus.disconnect(self.__statusMonitorStatus)
-self.__model.changeVCSStates)
-self.disconnect(self.vcs,
-SIGNAL("vcsStatusMonitorStatus(QString, QString)"),
-self.__statusMonitorStatus)
 # now save the tasks
 if not noSave:
 self.__writeTasks()
 self.ui.taskViewer.clearProjectTasks()
 self.menuApidocAct.setEnabled(False)
 self.menuPackagersAct.setEnabled(False)
 self.pluginGrp.setEnabled(False)
 self.__model.projectClosed()
-self.emit(SIGNAL('projectClosedHooks'))
+self.projectClosedHooks.emit()
 self.projectClosed.emit()
 return True
 def saveAllScripts(self, reportSyntaxErrors = False):
 self.vcsMenu = QMenu(self.trUtf8('&Version Control'), menu)
 self.vcsMenu.setTearOffEnabled(True)
 self.vcsProjectHelper.initMenu(self.vcsMenu)
 self.checksMenu = QMenu(self.trUtf8('Chec&k'), menu)
 self.checksMenu.setTearOffEnabled(True)
-self.showMenu = QMenu(self.trUtf8('Sho&w'), menu)
+self.menuShow = QMenu(self.trUtf8('Sho&w'), menu)
 self.graphicsMenu = QMenu(self.trUtf8('&Diagrams'), menu)
 self.sessionMenu = QMenu(self.trUtf8('Session'), menu)
 self.apidocMenu = QMenu(self.trUtf8('Source &Documentation'), menu)
 self.apidocMenu.setTearOffEnabled(True)
 self.debuggerMenu = QMenu(self.trUtf8('Debugger'), menu)
 self.__menus = {
 "Main"      : menu,
 "Recent"    : self.recentMenu,
 "VCS"       : self.vcsMenu,
 "Checks"    : self.checksMenu,
-"Show"      : self.showMenu,
+"Show"      : self.menuShow,
 "Graphics"  : self.graphicsMenu,
 "Session"   : self.sessionMenu,
 "Apidoc"    : self.apidocMenu,
 "Debugger"  : self.debuggerMenu,
 "Packagers" : self.packagersMenu,
 }
 # connect the aboutToShow signals
 self.recentMenu.aboutToShow.connect(self.__showContextMenuRecent)
-self.connect(self.recentMenu, SIGNAL('triggered(QAction *)'),
+self.recentMenu.triggered.connect(self.__openRecent)
-self.__openRecent)
 self.vcsMenu.aboutToShow.connect(self.__showContextMenuVCS)
 self.checksMenu.aboutToShow.connect(self.__showContextMenuChecks)
-self.showMenu.aboutToShow.connect(self.__showContextMenuShow)
+self.menuShow.aboutToShow.connect(self.__showContextMenuShow)
 self.graphicsMenu.aboutToShow.connect(self.__showContextMenuGraphics)
 self.apidocMenu.aboutToShow.connect(self.__showContextMenuApiDoc)
 self.packagersMenu.aboutToShow.connect(self.__showContextMenuPackagers)
 menu.aboutToShow.connect(self.__showMenu)
 # build the show menu
-self.showMenu.setTearOffEnabled(True)
+self.menuShow.setTearOffEnabled(True)
-self.showMenu.addAction(self.codeMetricsAct)
+self.menuShow.addAction(self.codeMetricsAct)
-self.showMenu.addAction(self.codeCoverageAct)
+self.menuShow.addAction(self.codeCoverageAct)
-self.showMenu.addAction(self.codeProfileAct)
+self.menuShow.addAction(self.codeProfileAct)
 # build the diagrams menu
 self.graphicsMenu.setTearOffEnabled(True)
 self.graphicsMenu.addAction(self.applicationDiagramAct)
 menu.addSeparator()
 self.menuCheckAct = menu.addMenu(self.checksMenu)
 menu.addSeparator()
 menu.addMenu(self.vcsMenu)
 menu.addSeparator()
-self.menuShowAct = menu.addMenu(self.showMenu)
+self.menuShowAct = menu.addMenu(self.menuShow)
 menu.addSeparator()
 self.menuApidocAct = menu.addMenu(self.apidocMenu)
 menu.addSeparator()
 self.menuPackagersAct = menu.addMenu(self.packagersMenu)
 menu.addSeparator()
 """
 Private method to set up the project menu.
 """
 self.menuRecentAct.setEnabled(len(self.recent) > 0)
-self.emit(SIGNAL("showMenu"), "Main", self.__menus["Main"])
+self.showMenu.emit("Main", self.__menus["Main"])
 def __syncRecent(self):
 """
 Private method to synchronize the list of recently opened projects
 with the central store.
 Public slot to be called, if something was added to the OTHERS project data area.
 @param fn filename or directory name added (string)
 @param updateModel flag indicating an update of the model is requested (boolean)
 """
-self.emit(SIGNAL('projectOthersAdded'), fn)
+self.projectOthersAdded.emit(fn)
 updateModel and self.__model.addNewItem("OTHERS", fn)
 def getActions(self):
 """
 Public method to get a list of all actions.
 """
 if not self.isOpen():
 return
 name = self.getRelativePath(fullname)
-self.emit(SIGNAL("prepareRepopulateItem"), name)
+self.prepareRepopulateItem.emit(name)
 self.__model.repopulateItem(name)
-self.emit(SIGNAL("completeRepopulateItem"), name)
+self.completeRepopulateItem.emit(name)
 ##############################################################
 ## Below is the VCS interface
 ##############################################################
 """
 Private slot called before the vcs menu is shown.
 """
 self.vcsProjectHelper.showMenu()
 if self.vcsBasicHelper:
-self.emit(SIGNAL("showMenu"), "VCS", self.vcsMenu)
+self.showMenu.emit("VCS", self.vcsMenu)
 #########################################################################
 ## Below is the interface to the checker tools
 #########################################################################
 def __showContextMenuChecks(self):
 """
 Private slot called before the checks menu is shown.
 """
-self.emit(SIGNAL("showMenu"), "Checks", self.checksMenu)
+self.showMenu.emit("Checks", self.checksMenu)
 #########################################################################
 ## Below is the interface to the packagers tools
 #########################################################################
 def __showContextMenuPackagers(self):
 """
 Private slot called before the packagers menu is shown.
 """
-self.emit(SIGNAL("showMenu"), "Packagers", self.packagersMenu)
+self.showMenu.emit("Packagers", self.packagersMenu)
 #########################################################################
 ## Below is the interface to the apidoc tools
 #########################################################################
 def __showContextMenuApiDoc(self):
 """
 Private slot called before the apidoc menu is shown.
 """
-self.emit(SIGNAL("showMenu"), "Apidoc", self.apidocMenu)
+self.showMenu.emit("Apidoc", self.apidocMenu)
 #########################################################################
 ## Below is the interface to the show tools
 #########################################################################
 os.path.isfile("{0}.coverage".format(tbasename))))
 else:
 self.codeProfileAct.setEnabled(False)
 self.codeCoverageAct.setEnabled(False)
-self.emit(SIGNAL("showMenu"), "Show", self.showMenu)
+self.showMenu.emit("Show", self.menuShow)
 #########################################################################
 ## Below is the interface to the diagrams
 #########################################################################
 def __showContextMenuGraphics(self):
 """
 Private slot called before the graphics menu is shown.
 """
-self.emit(SIGNAL("showMenu"), "Graphics", self.graphicsMenu)
+self.showMenu.emit("Graphics", self.graphicsMenu)
 def handleApplicationDiagram(self):
 """
 Private method to handle the application diagram context menu action.
 """
 It simply reemits the received status.
 @param status status of the monitoring thread (string, ok, nok or off)
 @param statusMsg explanotory text for the signaled status (string)
 """
-self.emit(SIGNAL("vcsStatusMonitorStatus(QString, QString)"), status, statusMsg)
+self.vcsStatusMonitorStatus.emit(status, statusMsg)
 def setStatusMonitorInterval(self, interval):
 """
 Public method to se the interval of the VCS status monitor thread.

Mercurial Repositories > eric / file comparison

comparison: Project/Project.py

Project/Project.py