eric: comparison Plugins/VcsPlugins/vcsMercurial/ProjectHelper.py

-:0bc58cbb64b2
+:a81097a85889
 self.vcsNewAct.setWhatsThis(self.trUtf8(
 """<b>New from repository</b>"""
 """<p>This creates (clones) a new local project from """
 """a Mercurial repository.</p>"""
 ))
-self.connect(self.vcsNewAct, SIGNAL('triggered()'), self._vcsCheckout)
+self.vcsNewAct.triggered.connect(self._vcsCheckout)
 self.actions.append(self.vcsNewAct)
 self.hgIncomingAct = E5Action(self.trUtf8('Show incoming log'),
 UI.PixmapCache.getIcon("vcsUpdate.png"),
 self.trUtf8('Show incoming log'),
 ))
 self.hgIncomingAct.setWhatsThis(self.trUtf8(
 """<b>Show incoming log</b>"""
 """<p>This shows the log of changes coming into the repository.</p>"""
 ))
-self.connect(self.hgIncomingAct, SIGNAL('triggered()'), self.__hgIncoming)
+self.hgIncomingAct.triggered.connect(self.__hgIncoming)
 self.actions.append(self.hgIncomingAct)
 self.hgPullAct = E5Action(self.trUtf8('Pull changes'),
 UI.PixmapCache.getIcon("vcsUpdate.png"),
 self.trUtf8('Pull changes'),
 self.hgPullAct.setWhatsThis(self.trUtf8(
 """<b>Pull changes</b>"""
 """<p>This pulls changes from a remote repository into the """
 """local repository.</p>"""
 ))
-self.connect(self.hgPullAct, SIGNAL('triggered()'), self.__hgPull)
+self.hgPullAct.triggered.connect(self.__hgPull)
 self.actions.append(self.hgPullAct)
 self.vcsUpdateAct = E5Action(self.trUtf8('Update from repository'),
 UI.PixmapCache.getIcon("vcsUpdate.png"),
 self.trUtf8('&Update from repository'), 0, 0, self,
 ))
 self.vcsUpdateAct.setWhatsThis(self.trUtf8(
 """<b>Update from repository</b>"""
 """<p>This updates the local project from the Mercurial repository.</p>"""
 ))
-self.connect(self.vcsUpdateAct, SIGNAL('triggered()'), self._vcsUpdate)
+self.vcsUpdateAct.triggered.connect(self._vcsUpdate)
 self.actions.append(self.vcsUpdateAct)
 self.vcsCommitAct = E5Action(self.trUtf8('Commit changes to repository'),
 UI.PixmapCache.getIcon("vcsCommit.png"),
 self.trUtf8('&Commit changes to repository...'), 0, 0, self,
 self.vcsCommitAct.setWhatsThis(self.trUtf8(
 """<b>Commit changes to repository</b>"""
 """<p>This commits changes to the local project to the """
 """Mercurial repository.</p>"""
 ))
-self.connect(self.vcsCommitAct, SIGNAL('triggered()'), self._vcsCommit)
+self.vcsCommitAct.triggered.connect(self._vcsCommit)
 self.actions.append(self.vcsCommitAct)
 self.hgOutgoingAct = E5Action(self.trUtf8('Show outgoing log'),
 UI.PixmapCache.getIcon("vcsCommit.png"),
 self.trUtf8('Show outgoing log'),
 ))
 self.hgOutgoingAct.setWhatsThis(self.trUtf8(
 """<b>Show outgoing log</b>"""
 """<p>This shows the log of changes outgoing out of the repository.</p>"""
 ))
-self.connect(self.hgOutgoingAct, SIGNAL('triggered()'), self.__hgOutgoing)
+self.hgOutgoingAct.triggered.connect(self.__hgOutgoing)
 self.actions.append(self.hgOutgoingAct)
 self.hgPushAct = E5Action(self.trUtf8('Push changes'),
 UI.PixmapCache.getIcon("vcsCommit.png"),
 self.trUtf8('Push changes'),
 self.hgPushAct.setWhatsThis(self.trUtf8(
 """<b>Push changes</b>"""
 """<p>This pushes changes from the local repository to a """
 """remote repository.</p>"""
 ))
-self.connect(self.hgPushAct, SIGNAL('triggered()'), self.__hgPush)
+self.hgPushAct.triggered.connect(self.__hgPush)
 self.actions.append(self.hgPushAct)
 self.hgPushForcedAct = E5Action(self.trUtf8('Push changes (force)'),
 UI.PixmapCache.getIcon("vcsCommit.png"),
 self.trUtf8('Push changes (force)'),
 self.hgPushForcedAct.setWhatsThis(self.trUtf8(
 """<b>Push changes (force)</b>"""
 """<p>This pushes changes from the local repository to a """
 """remote repository using the 'force' option.</p>"""
 ))
-self.connect(self.hgPushForcedAct, SIGNAL('triggered()'), self.__hgPushForced)
+self.hgPushForcedAct.triggered.connect(self.__hgPushForced)
 self.actions.append(self.hgPushForcedAct)
 self.vcsExportAct = E5Action(self.trUtf8('Export from repository'),
 UI.PixmapCache.getIcon("vcsExport.png"),
 self.trUtf8('&Export from repository...'),
 ))
 self.vcsExportAct.setWhatsThis(self.trUtf8(
 """<b>Export from repository</b>"""
 """<p>This exports a project from the repository.</p>"""
 ))
-self.connect(self.vcsExportAct, SIGNAL('triggered()'), self._vcsExport)
+self.vcsExportAct.triggered.connect(self._vcsExport)
 self.actions.append(self.vcsExportAct)
 self.vcsAddAct = E5Action(self.trUtf8('Add to repository'),
 UI.PixmapCache.getIcon("vcsAdd.png"),
 self.trUtf8('&Add to repository...'), 0, 0, self, 'mercurial_add')
 ))
 self.vcsAddAct.setWhatsThis(self.trUtf8(
 """<b>Add to repository</b>"""
 """<p>This adds (imports) the local project to the repository.</p>"""
 ))
-self.connect(self.vcsAddAct, SIGNAL('triggered()'), self._vcsImport)
+self.vcsAddAct.triggered.connect(self._vcsImport)
 self.actions.append(self.vcsAddAct)
 self.vcsRemoveAct = E5Action(self.trUtf8('Remove from repository (and disk)'),
 UI.PixmapCache.getIcon("vcsRemove.png"),
 self.trUtf8('&Remove from repository (and disk)'),
 self.vcsRemoveAct.setWhatsThis(self.trUtf8(
 """<b>Remove from repository</b>"""
 """<p>This removes the local project from the repository"""
 """ (and disk).</p>"""
 ))
-self.connect(self.vcsRemoveAct, SIGNAL('triggered()'), self._vcsRemove)
+self.vcsRemoveAct.triggered.connect(self._vcsRemove)
 self.actions.append(self.vcsRemoveAct)
 self.vcsLogAct = E5Action(self.trUtf8('Show log'),
 UI.PixmapCache.getIcon("vcsLog.png"),
 self.trUtf8('Show &log'),
 ))
 self.vcsLogAct.setWhatsThis(self.trUtf8(
 """<b>Show log</b>"""
 """<p>This shows the log of the local project.</p>"""
 ))
-self.connect(self.vcsLogAct, SIGNAL('triggered()'), self._vcsLog)
+self.vcsLogAct.triggered.connect(self._vcsLog)
 self.actions.append(self.vcsLogAct)
 self.hgLogLimitedAct = E5Action(self.trUtf8('Show limited log'),
 UI.PixmapCache.getIcon("vcsLog.png"),
 self.trUtf8('Show limited log'),
 self.hgLogLimitedAct.setWhatsThis(self.trUtf8(
 """<b>Show limited log</b>"""
 """<p>This shows the log of the local project limited to a selectable"""
 """ number of entries.</p>"""
 ))
-self.connect(self.hgLogLimitedAct, SIGNAL('triggered()'), self.__hgLogLimited)
+self.hgLogLimitedAct.triggered.connect(self.__hgLogLimited)
 self.actions.append(self.hgLogLimitedAct)
 self.hgLogBrowserAct = E5Action(self.trUtf8('Show log browser'),
 UI.PixmapCache.getIcon("vcsLog.png"),
 self.trUtf8('Show log browser'),
 """<b>Show log browser</b>"""
 """<p>This shows a dialog to browse the log of the local project."""
 """ A limited number of entries is shown first. More can be"""
 """ retrieved later on.</p>"""
 ))
-self.connect(self.hgLogBrowserAct, SIGNAL('triggered()'), self.__hgLogBrowser)
+self.hgLogBrowserAct.triggered.connect(self.__hgLogBrowser)
 self.actions.append(self.hgLogBrowserAct)
 self.vcsDiffAct = E5Action(self.trUtf8('Show difference'),
 UI.PixmapCache.getIcon("vcsDiff.png"),
 self.trUtf8('Show &difference'),
 ))
 self.vcsDiffAct.setWhatsThis(self.trUtf8(
 """<b>Show difference</b>"""
 """<p>This shows the difference of the local project to the repository.</p>"""
 ))
-self.connect(self.vcsDiffAct, SIGNAL('triggered()'), self._vcsDiff)
+self.vcsDiffAct.triggered.connect(self._vcsDiff)
 self.actions.append(self.vcsDiffAct)
 self.hgExtDiffAct = E5Action(self.trUtf8('Show difference (extended)'),
 UI.PixmapCache.getIcon("vcsDiff.png"),
 self.trUtf8('Show difference (extended)'),
 ))
 self.hgExtDiffAct.setWhatsThis(self.trUtf8(
 """<b>Show difference (extended)</b>"""
 """<p>This shows the difference of selectable revisions of the project.</p>"""
 ))
-self.connect(self.hgExtDiffAct, SIGNAL('triggered()'), self.__hgExtendedDiff)
+self.hgExtDiffAct.triggered.connect(self.__hgExtendedDiff)
 self.actions.append(self.hgExtDiffAct)
 self.vcsStatusAct = E5Action(self.trUtf8('Show status'),
 UI.PixmapCache.getIcon("vcsStatus.png"),
 self.trUtf8('Show &status'),
 ))
 self.vcsStatusAct.setWhatsThis(self.trUtf8(
 """<b>Show status</b>"""
 """<p>This shows the status of the local project.</p>"""
 ))
-self.connect(self.vcsStatusAct, SIGNAL('triggered()'), self._vcsStatus)
+self.vcsStatusAct.triggered.connect(self._vcsStatus)
 self.actions.append(self.vcsStatusAct)
 self.hgHeadsAct = E5Action(self.trUtf8('Show heads'),
 self.trUtf8('Show heads'),
 0, 0, self, 'mercurial_heads')
 ))
 self.hgHeadsAct.setWhatsThis(self.trUtf8(
 """<b>Show heads</b>"""
 """<p>This shows the heads of the repository.</p>"""
 ))
-self.connect(self.hgHeadsAct, SIGNAL('triggered()'), self.__hgHeads)
+self.hgHeadsAct.triggered.connect(self.__hgHeads)
 self.actions.append(self.hgHeadsAct)
 self.hgParentsAct = E5Action(self.trUtf8('Show parents'),
 self.trUtf8('Show parents'),
 0, 0, self, 'mercurial_parents')
 ))
 self.hgParentsAct.setWhatsThis(self.trUtf8(
 """<b>Show parents</b>"""
 """<p>This shows the parents of the repository.</p>"""
 ))
-self.connect(self.hgParentsAct, SIGNAL('triggered()'), self.__hgParents)
+self.hgParentsAct.triggered.connect(self.__hgParents)
 self.actions.append(self.hgParentsAct)
 self.hgTipAct = E5Action(self.trUtf8('Show tip'),
 self.trUtf8('Show tip'),
 0, 0, self, 'mercurial_tip')
 ))
 self.hgTipAct.setWhatsThis(self.trUtf8(
 """<b>Show tip</b>"""
 """<p>This shows the tip of the repository.</p>"""
 ))
-self.connect(self.hgTipAct, SIGNAL('triggered()'), self.__hgTip)
+self.hgTipAct.triggered.connect(self.__hgTip)
 self.actions.append(self.hgTipAct)
 self.vcsRevertAct = E5Action(self.trUtf8('Revert changes'),
 UI.PixmapCache.getIcon("vcsRevert.png"),
 self.trUtf8('Re&vert changes'),
 ))
 self.vcsRevertAct.setWhatsThis(self.trUtf8(
 """<b>Revert changes</b>"""
 """<p>This reverts all changes made to the local project.</p>"""
 ))
-self.connect(self.vcsRevertAct, SIGNAL('triggered()'), self._vcsRevert)
+self.vcsRevertAct.triggered.connect(self._vcsRevert)
 self.actions.append(self.vcsRevertAct)
 self.vcsMergeAct = E5Action(self.trUtf8('Merge'),
 UI.PixmapCache.getIcon("vcsMerge.png"),
 self.trUtf8('Mer&ge changes...'),
 ))
 self.vcsMergeAct.setWhatsThis(self.trUtf8(
 """<b>Merge</b>"""
 """<p>This merges changes of a revision into the local project.</p>"""
 ))
-self.connect(self.vcsMergeAct, SIGNAL('triggered()'), self._vcsMerge)
+self.vcsMergeAct.triggered.connect(self._vcsMerge)
 self.actions.append(self.vcsMergeAct)
 self.vcsResolveAct = E5Action(self.trUtf8('Resolve conflicts'),
 self.trUtf8('Resolve con&flicts'),
 0, 0, self, 'mercurial_resolve')
 ))
 self.vcsResolveAct.setWhatsThis(self.trUtf8(
 """<b>Resolve conflicts</b>"""
 """<p>This resolves all conflicts of the local project.</p>"""
 ))
-self.connect(self.vcsResolveAct, SIGNAL('triggered()'), self.__hgResolve)
+self.vcsResolveAct.triggered.connect(self.__hgResolve)
 self.actions.append(self.vcsResolveAct)
 self.vcsTagAct = E5Action(self.trUtf8('Tag in repository'),
 UI.PixmapCache.getIcon("vcsTag.png"),
 self.trUtf8('&Tag in repository...'),
 ))
 self.vcsTagAct.setWhatsThis(self.trUtf8(
 """<b>Tag in repository</b>"""
 """<p>This tags the local project in the repository.</p>"""
 ))
-self.connect(self.vcsTagAct, SIGNAL('triggered()'), self._vcsTag)
+self.vcsTagAct.triggered.connect(self._vcsTag)
 self.actions.append(self.vcsTagAct)
 self.hgTagListAct = E5Action(self.trUtf8('List tags'),
 self.trUtf8('List tags...'),
 0, 0, self, 'mercurial_list_tags')
 ))
 self.hgTagListAct.setWhatsThis(self.trUtf8(
 """<b>List tags</b>"""
 """<p>This lists the tags of the project.</p>"""
 ))
-self.connect(self.hgTagListAct, SIGNAL('triggered()'), self.__hgTagList)
+self.hgTagListAct.triggered.connect(self.__hgTagList)
 self.actions.append(self.hgTagListAct)
 self.hgBranchListAct = E5Action(self.trUtf8('List branches'),
 self.trUtf8('List branches...'),
 0, 0, self, 'mercurial_list_branches')
 ))
 self.hgBranchListAct.setWhatsThis(self.trUtf8(
 """<b>List branches</b>"""
 """<p>This lists the branches of the project.</p>"""
 ))
-self.connect(self.hgBranchListAct, SIGNAL('triggered()'), self.__hgBranchList)
+self.hgBranchListAct.triggered.connect(self.__hgBranchList)
 self.actions.append(self.hgBranchListAct)
 self.hgBranchAct = E5Action(self.trUtf8('Create branch'),
 UI.PixmapCache.getIcon("vcsBranch.png"),
 self.trUtf8('Create &branch...'),
 self.hgBranchAct.setWhatsThis(self.trUtf8(
 """<b>Create branch</b>"""
 """<p>This creates a new branch for the local project """
 """in the repository.</p>"""
 ))
-self.connect(self.hgBranchAct, SIGNAL('triggered()'), self.__hgBranch)
+self.hgBranchAct.triggered.connect(self.__hgBranch)
 self.actions.append(self.hgBranchAct)
 self.hgCloseBranchAct = E5Action(self.trUtf8('Close branch'),
 self.trUtf8('Close branch'),
 0, 0, self, 'mercurial_close_branch')
 ))
 self.hgCloseBranchAct.setWhatsThis(self.trUtf8(
 """<b>Close branch</b>"""
 """<p>This closes the current branch of the local project.</p>"""
 ))
-self.connect(self.hgCloseBranchAct, SIGNAL('triggered()'), self.__hgCloseBranch)
+self.hgCloseBranchAct.triggered.connect(self.__hgCloseBranch)
 self.actions.append(self.hgCloseBranchAct)
 self.hgShowBranchAct = E5Action(self.trUtf8('Show current branch'),
 self.trUtf8('Show current branch'),
 0, 0, self, 'mercurial_show_branch')
 ))
 self.hgShowBranchAct.setWhatsThis(self.trUtf8(
 """<b>Show current branch</b>"""
 """<p>This shows the current branch of the project.</p>"""
 ))
-self.connect(self.hgShowBranchAct, SIGNAL('triggered()'), self.__hgShowBranch)
+self.hgShowBranchAct.triggered.connect(self.__hgShowBranch)
 self.actions.append(self.hgShowBranchAct)
 self.vcsSwitchAct = E5Action(self.trUtf8('Switch'),
 UI.PixmapCache.getIcon("vcsSwitch.png"),
 self.trUtf8('S&witch...'),
 ))
 self.vcsSwitchAct.setWhatsThis(self.trUtf8(
 """<b>Switch</b>"""
 """<p>This switches the working directory to another revision.</p>"""
 ))
-self.connect(self.vcsSwitchAct, SIGNAL('triggered()'), self._vcsSwitch)
+self.vcsSwitchAct.triggered.connect(self._vcsSwitch)
 self.actions.append(self.vcsSwitchAct)
 self.vcsCleanupAct = E5Action(self.trUtf8('Cleanup'),
 self.trUtf8('Cleanu&p'),
 0, 0, self, 'mercurial_cleanup')
 ))
 self.vcsCleanupAct.setWhatsThis(self.trUtf8(
 """<b>Cleanup</b>"""
 """<p>This performs a cleanup of the local project.</p>"""
 ))
-self.connect(self.vcsCleanupAct, SIGNAL('triggered()'), self._vcsCleanup)
+self.vcsCleanupAct.triggered.connect(self._vcsCleanup)
 self.actions.append(self.vcsCleanupAct)
 self.vcsCommandAct = E5Action(self.trUtf8('Execute command'),
 self.trUtf8('E&xecute command...'),
 0, 0, self, 'mercurial_command')
 ))
 self.vcsCommandAct.setWhatsThis(self.trUtf8(
 """<b>Execute command</b>"""
 """<p>This opens a dialog to enter an arbitrary Mercurial command.</p>"""
 ))
-self.connect(self.vcsCommandAct, SIGNAL('triggered()'), self._vcsCommand)
+self.vcsCommandAct.triggered.connect(self._vcsCommand)
 self.actions.append(self.vcsCommandAct)
 self.vcsPropsAct = E5Action(self.trUtf8('Command options'),
 self.trUtf8('Command &options...'),0,0,self,
 'mercurial_options')
 self.vcsPropsAct.setStatusTip(self.trUtf8('Show the Mercurial command options'))
 self.vcsPropsAct.setWhatsThis(self.trUtf8(
 """<b>Command options...</b>"""
 """<p>This shows a dialog to edit the Mercurial command options.</p>"""
 ))
-self.connect(self.vcsPropsAct, SIGNAL('triggered()'), self._vcsCommandOptions)
+self.vcsPropsAct.triggered.connect(self._vcsCommandOptions)
 self.actions.append(self.vcsPropsAct)
 self.hgConfigAct = E5Action(self.trUtf8('Configure'),
 self.trUtf8('Configure...'),
 0, 0, self, 'mercurial_configure')
 ))
 self.hgConfigAct.setWhatsThis(self.trUtf8(
 """<b>Configure</b>"""
 """<p>Show the configuration dialog with the Mercurial page selected.</p>"""
 ))
-self.connect(self.hgConfigAct, SIGNAL('triggered()'), self.__hgConfigure)
+self.hgConfigAct.triggered.connect(self.__hgConfigure)
 self.actions.append(self.hgConfigAct)
 self.hgRepoConfigAct = E5Action(self.trUtf8('Edit repository config'),
 self.trUtf8('Edit repository config...'),
 0, 0, self, 'mercurial_repo_configure')
 ))
 self.hgRepoConfigAct.setWhatsThis(self.trUtf8(
 """<b>Edit repository config</b>"""
 """<p>Show an editor to edit the repository config file.</p>"""
 ))
-self.connect(self.hgRepoConfigAct, SIGNAL('triggered()'), self.__hgEditRepoConfig)
+self.hgRepoConfigAct.triggered.connect(self.__hgEditRepoConfig)
 self.actions.append(self.hgRepoConfigAct)
 self.hgShowConfigAct = E5Action(self.trUtf8('Show combined config settings'),
 self.trUtf8('Show combined config settings...'),
 0, 0, self, 'mercurial_show_config')
 ))
 self.hgShowConfigAct.setWhatsThis(self.trUtf8(
 """<b>Show combined config settings</b>"""
 """<p>This shows the combined config settings from all config files.</p>"""
 ))
-self.connect(self.hgShowConfigAct, SIGNAL('triggered()'), self.__hgShowConfig)
+self.hgShowConfigAct.triggered.connect(self.__hgShowConfig)
 self.actions.append(self.hgShowConfigAct)
 self.hgShowPathsAct = E5Action(self.trUtf8('Show paths'),
 self.trUtf8('Show paths...'),
 0, 0, self, 'mercurial_show_paths')
 ))
 self.hgShowPathsAct.setWhatsThis(self.trUtf8(
 """<b>Show paths</b>"""
 """<p>This shows the aliases for remote repositories.</p>"""
 ))
-self.connect(self.hgShowPathsAct, SIGNAL('triggered()'), self.__hgShowPaths)
+self.hgShowPathsAct.triggered.connect(self.__hgShowPaths)
 self.actions.append(self.hgShowPathsAct)
 self.hgVerifyAct = E5Action(self.trUtf8('Verify repository'),
 self.trUtf8('Verify repository...'),
 0, 0, self, 'mercurial_verify')
 ))
 self.hgVerifyAct.setWhatsThis(self.trUtf8(
 """<b>Verify repository</b>"""
 """<p>This verifies the integrity of the repository.</p>"""
 ))
-self.connect(self.hgVerifyAct, SIGNAL('triggered()'), self.__hgVerify)
+self.hgVerifyAct.triggered.connect(self.__hgVerify)
 self.actions.append(self.hgVerifyAct)
 self.hgRecoverAct = E5Action(self.trUtf8('Recover'),
 self.trUtf8('Recover...'),
 0, 0, self, 'mercurial_recover')
 ))
 self.hgRecoverAct.setWhatsThis(self.trUtf8(
 """<b>Recover</b>"""
 """<p>This recovers from an interrupted transaction.</p>"""
 ))
-self.connect(self.hgRecoverAct, SIGNAL('triggered()'), self.__hgRecover)
+self.hgRecoverAct.triggered.connect(self.__hgRecover)
 self.actions.append(self.hgRecoverAct)
 self.hgIdentifyAct = E5Action(self.trUtf8('Identify'),
 self.trUtf8('Identify...'),
 0, 0, self, 'mercurial_identify')
 ))
 self.hgIdentifyAct.setWhatsThis(self.trUtf8(
 """<b>Identify</b>"""
 """<p>This identifies the project directory.</p>"""
 ))
-self.connect(self.hgIdentifyAct, SIGNAL('triggered()'), self.__hgIdentify)
+self.hgIdentifyAct.triggered.connect(self.__hgIdentify)
 self.actions.append(self.hgIdentifyAct)
 self.hgCreateIgnoreAct = E5Action(self.trUtf8('Create .hgignore'),
 self.trUtf8('Create .hgignore'),
 0, 0, self, 'mercurial_create ignore')
 ))
 self.hgCreateIgnoreAct.setWhatsThis(self.trUtf8(
 """<b>Create .hgignore</b>"""
 """<p>This creates a .hgignore file with default values.</p>"""
 ))
-self.connect(self.hgCreateIgnoreAct, SIGNAL('triggered()'), self.__hgCreateIgnore)
+self.hgCreateIgnoreAct.triggered.connect(self.__hgCreateIgnore)
 self.actions.append(self.hgCreateIgnoreAct)
 self.hgBundleAct = E5Action(self.trUtf8('Create changegroup'),
 self.trUtf8('Create changegroup...'),
 0, 0, self, 'mercurial_bundle')
 self.hgBundleAct.setWhatsThis(self.trUtf8(
 """<b>Create changegroup</b>"""
 """<p>This creates a changegroup file collecting selected changesets"""
 """ (hg bundle).</p>"""
 ))
-self.connect(self.hgBundleAct, SIGNAL('triggered()'), self.__hgBundle)
+self.hgBundleAct.triggered.connect(self.__hgBundle)
 self.actions.append(self.hgBundleAct)
 self.hgPreviewBundleAct = E5Action(self.trUtf8('Preview changegroup'),
 self.trUtf8('Preview changegroup...'),
 0, 0, self, 'mercurial_preview_bundle')
 self.hgPreviewBundleAct.setWhatsThis(self.trUtf8(
 """<b>Preview changegroup</b>"""
 """<p>This previews a changegroup file containing a collection of"""
 """ changesets.</p>"""
 ))
-self.connect(self.hgPreviewBundleAct, SIGNAL('triggered()'),
+self.hgPreviewBundleAct.triggered.connect(self.__hgPreviewBundle)
-self.__hgPreviewBundle)
 self.actions.append(self.hgPreviewBundleAct)
 self.hgIdentifyBundleAct = E5Action(self.trUtf8('Identify changegroup'),
 self.trUtf8('Identify changegroup...'),
 0, 0, self, 'mercurial_identify_bundle')
 self.hgIdentifyBundleAct.setWhatsThis(self.trUtf8(
 """<b>Identify changegroup</b>"""
 """<p>This identifies a changegroup file containing a collection of"""
 """ changesets.</p>"""
 ))
-self.connect(self.hgIdentifyBundleAct, SIGNAL('triggered()'),
+self.hgIdentifyBundleAct.triggered.connect(self.__hgIdentifyBundle)
-self.__hgIdentifyBundle)
 self.actions.append(self.hgIdentifyBundleAct)
 self.hgUnbundleAct = E5Action(self.trUtf8('Apply changegroups'),
 self.trUtf8('Apply changegroups...'),
 0, 0, self, 'mercurial_unbundle')
 self.hgUnbundleAct.setWhatsThis(self.trUtf8(
 """<b>Apply changegroups</b>"""
 """<p>This applies one or several changegroup files generated by"""
 """ the 'Create changegroup' action (hg unbundle).</p>"""
 ))
-self.connect(self.hgUnbundleAct, SIGNAL('triggered()'), self.__hgUnbundle)
+self.hgUnbundleAct.triggered.connect(self.__hgUnbundle)
 self.actions.append(self.hgUnbundleAct)
 self.hgBisectGoodAct = E5Action(self.trUtf8('Mark as "good"'),
 self.trUtf8('Mark as "good"...'),
 0, 0, self, 'mercurial_bisect_good')
 ))
 self.hgBisectGoodAct.setWhatsThis(self.trUtf8(
 """<b>Mark as good</b>"""
 """<p>This marks a selectable changeset as good.</p>"""
 ))
-self.connect(self.hgBisectGoodAct, SIGNAL('triggered()'), self.__hgBisectGood)
+self.hgBisectGoodAct.triggered.connect(self.__hgBisectGood)
 self.actions.append(self.hgBisectGoodAct)
 self.hgBisectBadAct = E5Action(self.trUtf8('Mark as "bad"'),
 self.trUtf8('Mark as "bad"...'),
 0, 0, self, 'mercurial_bisect_bad')
 ))
 self.hgBisectBadAct.setWhatsThis(self.trUtf8(
 """<b>Mark as bad</b>"""
 """<p>This marks a selectable changeset as bad.</p>"""
 ))
-self.connect(self.hgBisectBadAct, SIGNAL('triggered()'), self.__hgBisectBad)
+self.hgBisectBadAct.triggered.connect(self.__hgBisectBad)
 self.actions.append(self.hgBisectBadAct)
 self.hgBisectSkipAct = E5Action(self.trUtf8('Skip'),
 self.trUtf8('Skip'),
 0, 0, self, 'mercurial_bisect_skip')
 ))
 self.hgBisectSkipAct.setWhatsThis(self.trUtf8(
 """<b>Skip</b>"""
 """<p>This skips the current changeset.</p>"""
 ))
-self.connect(self.hgBisectSkipAct, SIGNAL('triggered()'), self.__hgBisectSkip)
+self.hgBisectSkipAct.triggered.connect(self.__hgBisectSkip)
 self.actions.append(self.hgBisectSkipAct)
 self.hgBisectResetAct = E5Action(self.trUtf8('Reset'),
 self.trUtf8('Reset'),
 0, 0, self, 'mercurial_bisect_reset')
 ))
 self.hgBisectResetAct.setWhatsThis(self.trUtf8(
 """<b>Reset</b>"""
 """<p>This resets the bisect search data.</p>"""
 ))
-self.connect(self.hgBisectResetAct, SIGNAL('triggered()'), self.__hgBisectReset)
+self.hgBisectResetAct.triggered.connect(self.__hgBisectReset)
 self.actions.append(self.hgBisectResetAct)
 self.hgBackoutAct = E5Action(self.trUtf8('Back out changeset'),
 self.trUtf8('Back out changeset'),
 0, 0, self, 'mercurial_backout')
 ))
 self.hgBackoutAct.setWhatsThis(self.trUtf8(
 """<b>Back out changeset</b>"""
 """<p>This backs out changes of an earlier changeset.</p>"""
 ))
-self.connect(self.hgBackoutAct, SIGNAL('triggered()'), self.__hgBackout)
+self.hgBackoutAct.triggered.connect(self.__hgBackout)
 self.actions.append(self.hgBackoutAct)
 self.hgServeAct = E5Action(self.trUtf8('Serve project repository'),
 self.trUtf8('Serve project repository...'),
 0, 0, self, 'mercurial_serve')
 ))
 self.hgServeAct.setWhatsThis(self.trUtf8(
 """<b>Serve project repository</b>"""
 """<p>This serves the project repository.</p>"""
 ))
-self.connect(self.hgServeAct, SIGNAL('triggered()'), self.__hgServe)
+self.hgServeAct.triggered.connect(self.__hgServe)
 self.actions.append(self.hgServeAct)
 def initMenu(self, menu):
 """
 Public method to generate the VCS menu.

Mercurial Repositories > eric / file comparison

comparison: Plugins/VcsPlugins/vcsMercurial/ProjectHelper.py

Plugins/VcsPlugins/vcsMercurial/ProjectHelper.py