eric: comparison Project/Project.py

-:f7a6d271bb40
+:071afe8be2a1
 import glob
 import fnmatch
 import copy
 import zipfile
-from PyQt4.QtCore import QFile, QFileInfo, pyqtSignal, QCryptographicHash, \
+from PyQt4.QtCore import pyqtSlot, QFile, QFileInfo, pyqtSignal, \
-QIODevice, QByteArray, QObject, Qt
+QCryptographicHash, QIODevice, QByteArray, QObject, Qt
 from PyQt4.QtGui import QCursor, QLineEdit, QToolBar, QDialog, QInputDialog, \
 QApplication, QMenu, QAction
 from PyQt4.Qsci import QsciScintilla
 from E5Gui.E5Application import e5App
 self.sessActGrp.findChild(
 QAction, "project_load_session").setEnabled(enable)
 self.sessActGrp.findChild(
 QAction, "project_delete_session").setEnabled(enable)
+@pyqtSlot()
 def __readSession(self, quiet=False, indicator=""):
 """
 Private method to read in the project session file (.e4s).
 @param quiet flag indicating quiet operations.
 self.tr("Read project session"),
 self.tr(
 "<p>The project session file <b>{0}</b> could not be"
 " read.</p>").format(fn))
+@pyqtSlot()
 def __writeSession(self, quiet=False, indicator=""):
 """
 Private method to write the session data to an XML file (.e4s).
 @param quiet flag indicating quiet operations.
 self.dbgActGrp.findChild(
 QAction, "project_debugger_properties_load").setEnabled(enable)
 self.dbgActGrp.findChild(
 QAction, "project_debugger_properties_delete").setEnabled(enable)
+@pyqtSlot()
 def __readDebugProperties(self, quiet=False):
 """
 Private method to read in the project debugger properties file (.e4d).
 @param quiet flag indicating quiet operations.
 self.tr("Read debugger properties"),
 self.tr(
 "<p>The project debugger properties file <b>{0}</b>"
 " could not be read.</p>").format(fn))
+@pyqtSlot()
 def __writeDebugProperties(self, quiet=False):
 """
 Private method to write the project debugger properties file (.e4d).
 @param quiet flag indicating quiet operations.
 self.otherssubdirs.append(newdir)
 if dirty:
 self.setDirty(True)
+@pyqtSlot()
 def addFiles(self, filter=None, startdir=None):
 """
 Public slot used to add files to the project.
 @param filter filter to be used by the add file dialog
 ns = os.path.join(source, name)
 if os.path.isdir(ns):
 nt = os.path.join(target, name)
 self.__addRecursiveDirectory(filetype, ns, nt)
+@pyqtSlot()
 def addDirectory(self, filter=None, startdir=None):
 """
 Public method used to add all files of a directory to the project.
 @param filter filter to be used by the add directory dialog
 pass
 # return empty string to signal to use the global setting
 return ""
+@pyqtSlot()
+@pyqtSlot(str)
 def openProject(self, fn=None, restoreSession=True, reopen=False):
 """
 Public slot to open a project.
 @param fn optional filename of the project file to be read
 self.codecoverage and self.codecoverage.close()
 self.profiledata and self.profiledata.close()
 self.applicationDiagram and self.applicationDiagram.close()
 self.loadedDiagram and self.loadedDiagram.close()
+@pyqtSlot()
 def closeProject(self, reopen=False, noSave=False):
 """
 Public slot to close the current project.
 @keyparam reopen flag indicating a reopening of the project (boolean)
 act.setWhatsThis(self.tr(
 """<b>New...</b>"""
 """<p>This opens a dialog for entering the info for a"""
 """ new project.</p>"""
 ))
-act.triggered[()].connect(self.createNewProject)
+act.triggered.connect(self.createNewProject)
 self.actions.append(act)
 act = E5Action(
 self.tr('Open project'),
 UI.PixmapCache.getIcon("projectOpen.png"),
 act.setStatusTip(self.tr('Open an existing project'))
 act.setWhatsThis(self.tr(
 """<b>Open...</b>"""
 """<p>This opens an existing project.</p>"""
 ))
-act.triggered[()].connect(self.openProject)
+act.triggered.connect(self.openProject)
 self.actions.append(act)
 self.closeAct = E5Action(
 self.tr('Close project'),
 UI.PixmapCache.getIcon("projectClose.png"),
 self.closeAct.setStatusTip(self.tr('Close the current project'))
 self.closeAct.setWhatsThis(self.tr(
 """<b>Close</b>"""
 """<p>This closes the current project.</p>"""
 ))
-self.closeAct.triggered[()].connect(self.closeProject)
+self.closeAct.triggered.connect(self.closeProject)
 self.actions.append(self.closeAct)
 self.saveAct = E5Action(
 self.tr('Save project'),
 UI.PixmapCache.getIcon("projectSave.png"),
 self.saveAct.setStatusTip(self.tr('Save the current project'))
 self.saveAct.setWhatsThis(self.tr(
 """<b>Save</b>"""
 """<p>This saves the current project.</p>"""
 ))
-self.saveAct.triggered[()].connect(self.saveProject)
+self.saveAct.triggered.connect(self.saveProject)
 self.actions.append(self.saveAct)
 self.saveasAct = E5Action(
 self.tr('Save project as'),
 UI.PixmapCache.getIcon("projectSaveAs.png"),
 'Save the current project to a new file'))
 self.saveasAct.setWhatsThis(self.tr(
 """<b>Save as</b>"""
 """<p>This saves the current project to a new file.</p>"""
 ))
-self.saveasAct.triggered[()].connect(self.saveProjectAs)
+self.saveasAct.triggered.connect(self.saveProjectAs)
 self.actions.append(self.saveasAct)
 self.actGrp2 = createActionGroup(self)
 self.addFilesAct = E5Action(
 """<b>Add files...</b>"""
 """<p>This opens a dialog for adding files"""
 """ to the current project. The place to add is"""
 """ determined by the file extension.</p>"""
 ))
-self.addFilesAct.triggered[()].connect(self.addFiles)
+self.addFilesAct.triggered.connect(self.addFiles)
 self.actions.append(self.addFilesAct)
 self.addDirectoryAct = E5Action(
 self.tr('Add directory to project'),
 UI.PixmapCache.getIcon("dirOpen.png"),
 self.addDirectoryAct.setWhatsThis(self.tr(
 """<b>Add directory...</b>"""
 """<p>This opens a dialog for adding a directory"""
 """ to the current project.</p>"""
 ))
-self.addDirectoryAct.triggered[()].connect(self.addDirectory)
+self.addDirectoryAct.triggered.connect(self.addDirectory)
 self.actions.append(self.addDirectoryAct)
 self.addLanguageAct = E5Action(
 self.tr('Add translation to project'),
 UI.PixmapCache.getIcon("linguist4.png"),
 self.addLanguageAct.setWhatsThis(self.tr(
 """<b>Add translation...</b>"""
 """<p>This opens a dialog for add a translation"""
 """ to the current project.</p>"""
 ))
-self.addLanguageAct.triggered[()].connect(self.addLanguage)
+self.addLanguageAct.triggered.connect(self.addLanguage)
 self.actions.append(self.addLanguageAct)
 act = E5Action(
 self.tr('Search new files'),
 self.tr('Searc&h new files...'), 0, 0,
 act.setWhatsThis(self.tr(
 """<b>Search new files...</b>"""
 """<p>This searches for new files (sources, *.ui, *.idl) in"""
 """ the project directory and registered subdirectories.</p>"""
 ))
-act.triggered[()].connect(self.__searchNewFiles)
+act.triggered.connect(self.__searchNewFiles)
 self.actions.append(act)
 self.propsAct = E5Action(
 self.tr('Project properties'),
 UI.PixmapCache.getIcon("projectProps.png"),
 self.propsAct.setStatusTip(self.tr('Show the project properties'))
 self.propsAct.setWhatsThis(self.tr(
 """<b>Properties...</b>"""
 """<p>This shows a dialog to edit the project properties.</p>"""
 ))
-self.propsAct.triggered[()].connect(self.__showProperties)
+self.propsAct.triggered.connect(self.__showProperties)
 self.actions.append(self.propsAct)
 self.userPropsAct = E5Action(
 self.tr('User project properties'),
 UI.PixmapCache.getIcon("projectUserProps.png"),
 self.userPropsAct.setWhatsThis(self.tr(
 """<b>User Properties...</b>"""
 """<p>This shows a dialog to edit the user specific project"""
 """ properties.</p>"""
 ))
-self.userPropsAct.triggered[()].connect(self.__showUserProperties)
+self.userPropsAct.triggered.connect(self.__showUserProperties)
 self.actions.append(self.userPropsAct)
 self.filetypesAct = E5Action(
 self.tr('Filetype Associations'),
 self.tr('Filetype Associations...'), 0, 0,
 """ the project. These associations determine the type"""
 """ (source, form, interface or others) with a filename"""
 """ pattern. They are used when adding a file to the project"""
 """ and when performing a search for new files.</p>"""
 ))
-self.filetypesAct.triggered[()].connect(
+self.filetypesAct.triggered.connect(
 self.__showFiletypeAssociations)
 self.actions.append(self.filetypesAct)
 self.lexersAct = E5Action(
 self.tr('Lexer Associations'),
 """<p>This shows a dialog to edit the lexer associations of"""
 """ the project. These associations override the global lexer"""
 """ associations. Lexers are used to highlight the editor"""
 """ text.</p>"""
 ))
-self.lexersAct.triggered[()].connect(self.__showLexerAssociations)
+self.lexersAct.triggered.connect(self.__showLexerAssociations)
 self.actions.append(self.lexersAct)
 self.dbgActGrp = createActionGroup(self)
 act = E5Action(
 act.setWhatsThis(self.tr(
 """<b>Debugger Properties...</b>"""
 """<p>This shows a dialog to edit project specific debugger"""
 """ settings.</p>"""
 ))
-act.triggered[()].connect(self.__showDebugProperties)
+act.triggered.connect(self.__showDebugProperties)
 self.actions.append(act)
 act = E5Action(
 self.tr('Load'),
 self.tr('&Load'), 0, 0,
 act.setStatusTip(self.tr('Load the debugger properties'))
 act.setWhatsThis(self.tr(
 """<b>Load Debugger Properties</b>"""
 """<p>This loads the project specific debugger settings.</p>"""
 ))
-act.triggered[()].connect(self.__readDebugProperties)
+act.triggered.connect(self.__readDebugProperties)
 self.actions.append(act)
 act = E5Action(
 self.tr('Save'),
 self.tr('&Save'), 0, 0,
 act.setStatusTip(self.tr('Save the debugger properties'))
 act.setWhatsThis(self.tr(
 """<b>Save Debugger Properties</b>"""
 """<p>This saves the project specific debugger settings.</p>"""
 ))
-act.triggered[()].connect(self.__writeDebugProperties)
+act.triggered.connect(self.__writeDebugProperties)
 self.actions.append(act)
 act = E5Action(
 self.tr('Delete'),
 self.tr('&Delete'), 0, 0,
 act.setWhatsThis(self.tr(
 """<b>Delete Debugger Properties</b>"""
 """<p>This deletes the file containing the project specific"""
 """ debugger settings.</p>"""
 ))
-act.triggered[()].connect(self.__deleteDebugProperties)
+act.triggered.connect(self.__deleteDebugProperties)
 self.actions.append(act)
 act = E5Action(
 self.tr('Reset'),
 self.tr('&Reset'), 0, 0,
 act.setStatusTip(self.tr('Reset the debugger properties'))
 act.setWhatsThis(self.tr(
 """<b>Reset Debugger Properties</b>"""
 """<p>This resets the project specific debugger settings.</p>"""
 ))
-act.triggered[()].connect(self.__initDebugProperties)
+act.triggered.connect(self.__initDebugProperties)
 self.actions.append(act)
 self.sessActGrp = createActionGroup(self)
 act = E5Action(
 """- all breakpoint<br>"""
 """- the commandline arguments<br>"""
 """- the working directory<br>"""
 """- the exception reporting flag</p>"""
 ))
-act.triggered[()].connect(self.__readSession)
+act.triggered.connect(self.__readSession)
 self.actions.append(act)
 act = E5Action(
 self.tr('Save session'),
 self.tr('Save session'), 0, 0,
 """- all breakpoint<br>"""
 """- the commandline arguments<br>"""
 """- the working directory<br>"""
 """- the exception reporting flag</p>"""
 ))
-act.triggered[()].connect(self.__writeSession)
+act.triggered.connect(self.__writeSession)
 self.actions.append(act)
 act = E5Action(
 self.tr('Delete session'),
 self.tr('Delete session'), 0, 0,
 act.setStatusTip(self.tr('Delete the projects session file.'))
 act.setWhatsThis(self.tr(
 """<b>Delete session</b>"""
 """<p>This deletes the projects session file</p>"""
 ))
-act.triggered[()].connect(self.__deleteSession)
+act.triggered.connect(self.__deleteSession)
 self.actions.append(act)
 self.chkGrp = createActionGroup(self)
 self.codeMetricsAct = E5Action(
 self.codeMetricsAct.setWhatsThis(self.tr(
 """<b>Code Metrics...</b>"""
 """<p>This shows some code metrics for all Python files in"""
 """ the project.</p>"""
 ))
-self.codeMetricsAct.triggered[()].connect(self.__showCodeMetrics)
+self.codeMetricsAct.triggered.connect(self.__showCodeMetrics)
 self.actions.append(self.codeMetricsAct)
 self.codeCoverageAct = E5Action(
 self.tr('Python Code Coverage'),
 self.tr('Code Co&verage...'), 0, 0,
 self.codeCoverageAct.setWhatsThis(self.tr(
 """<b>Code Coverage...</b>"""
 """<p>This shows the code coverage information for all Python"""
 """ files in the project.</p>"""
 ))
-self.codeCoverageAct.triggered[()].connect(self.__showCodeCoverage)
+self.codeCoverageAct.triggered.connect(self.__showCodeCoverage)
 self.actions.append(self.codeCoverageAct)
 self.codeProfileAct = E5Action(
 self.tr('Profile Data'),
 self.tr('&Profile Data...'), 0, 0,
 self.tr('Show profiling data for the project.'))
 self.codeProfileAct.setWhatsThis(self.tr(
 """<b>Profile Data...</b>"""
 """<p>This shows the profiling data for the project.</p>"""
 ))
-self.codeProfileAct.triggered[()].connect(self.__showProfileData)
+self.codeProfileAct.triggered.connect(self.__showProfileData)
 self.actions.append(self.codeProfileAct)
 self.graphicsGrp = createActionGroup(self)
 self.applicationDiagramAct = E5Action(
 self.tr('Show a diagram of the project.'))
 self.applicationDiagramAct.setWhatsThis(self.tr(
 """<b>Application Diagram...</b>"""
 """<p>This shows a diagram of the project.</p>"""
 ))
-self.applicationDiagramAct.triggered[()].connect(
+self.applicationDiagramAct.triggered.connect(
 self.handleApplicationDiagram)
 self.actions.append(self.applicationDiagramAct)
 self.loadDiagramAct = E5Action(
 self.tr('Load Diagram'),
 self.tr('Load a diagram from file.'))
 self.loadDiagramAct.setWhatsThis(self.tr(
 """<b>Load Diagram...</b>"""
 """<p>This loads a diagram from file.</p>"""
 ))
-self.loadDiagramAct.triggered[()].connect(self.__loadDiagram)
+self.loadDiagramAct.triggered.connect(self.__loadDiagram)
 self.actions.append(self.loadDiagramAct)
 self.pluginGrp = createActionGroup(self)
 self.pluginPkgListAct = E5Action(
 """<b>Create Package List</b>"""
 """<p>This creates an initial list of files to include in an"""
 """ eric5 plugin archive. The list is created from the project"""
 """ file.</p>"""
 ))
-self.pluginPkgListAct.triggered[()].connect(self.__pluginCreatePkgList)
+self.pluginPkgListAct.triggered.connect(self.__pluginCreatePkgList)
 self.actions.append(self.pluginPkgListAct)
 self.pluginArchiveAct = E5Action(
 self.tr('Create Plugin Archive'),
 UI.PixmapCache.getIcon("pluginArchive.png"),
 """<b>Create Plugin Archive</b>"""
 """<p>This creates an eric5 plugin archive file using the list"""
 """ of files given in the PKGLIST file. The archive name is"""
 """ built from the main script name.</p>"""
 ))
-self.pluginArchiveAct.triggered[()].connect(self.__pluginCreateArchive)
+self.pluginArchiveAct.triggered.connect(self.__pluginCreateArchive)
 self.actions.append(self.pluginArchiveAct)
 self.pluginSArchiveAct = E5Action(
 self.tr('Create Plugin Archive (Snapshot)'),
 UI.PixmapCache.getIcon("pluginArchiveSnapshot.png"),
 """<p>This creates an eric5 plugin archive file using the list"""
 """ of files given in the PKGLIST file. The archive name is"""
 """ built from the main script name. The version entry of the"""
 """ main script is modified to reflect a snapshot release.</p>"""
 ))
-self.pluginSArchiveAct.triggered[()].connect(
+self.pluginSArchiveAct.triggered.connect(
 self.__pluginCreateSnapshotArchive)
 self.actions.append(self.pluginSArchiveAct)
 self.closeAct.setEnabled(False)
 self.saveAct.setEnabled(False)
 return
 if not "PKGLIST" in self.pdata["OTHERS"]:
 self.appendFile("PKGLIST")
+@pyqtSlot()
 def __pluginCreateArchive(self, snapshot=False):
 """
 Private slot to create an eric5 plugin archive.
 @param snapshot flag indicating a snapshot archive (boolean)

Mercurial Repositories > eric / file comparison

comparison: Project/Project.py

Project/Project.py