eric: comparison eric7/Plugins/VcsPlugins/vcsGit/ProjectHelper.py

-:8a7677a63c8d
+:68ec9c3d4de5
 import os
 from PyQt6.QtCore import QFileInfo
 from PyQt6.QtWidgets import QMenu, QInputDialog, QToolBar
-from E5Gui import E5MessageBox
+from E5Gui import EricMessageBox
-from E5Gui.E5Application import e5App
+from E5Gui.EricApplication import ericApp
 from VCS.ProjectHelper import VcsProjectHelper
-from E5Gui.E5Action import E5Action
+from E5Gui.EricAction import EricAction
 import UI.PixmapCache
 class GitProjectHelper(VcsProjectHelper):
 def getActions(self):
 """
 Public method to get a list of all actions.
-@return list of all actions (list of E5Action)
+@return list of all actions (list of EricAction)
 """
 actions = self.actions[:]
 return actions
 def initActions(self):
 """
 Public method to generate the action objects.
 """
-self.vcsNewAct = E5Action(
+self.vcsNewAct = EricAction(
 self.tr('New from repository'),
 UI.PixmapCache.getIcon("vcsCheckout"),
 self.tr('&New from repository...'), 0, 0,
 self, 'git_new')
 self.vcsNewAct.setStatusTip(self.tr(
 """a Git repository.</p>"""
 ))
 self.vcsNewAct.triggered.connect(self._vcsCheckout)
 self.actions.append(self.vcsNewAct)
-self.gitFetchAct = E5Action(
+self.gitFetchAct = EricAction(
 self.tr('Fetch changes'),
 UI.PixmapCache.getIcon("vcsUpdate"),
 self.tr('Fetch changes'),
 0, 0, self, 'git_fetch')
 self.gitFetchAct.setStatusTip(self.tr(
 """local repository.</p>"""
 ))
 self.gitFetchAct.triggered.connect(self.__gitFetch)
 self.actions.append(self.gitFetchAct)
-self.gitPullAct = E5Action(
+self.gitPullAct = EricAction(
 self.tr('Pull changes'),
 UI.PixmapCache.getIcon("vcsUpdate"),
 self.tr('Pull changes'),
 0, 0, self, 'git_pull')
 self.gitPullAct.setStatusTip(self.tr(
 """local repository and updates the work area.</p>"""
 ))
 self.gitPullAct.triggered.connect(self.__gitPull)
 self.actions.append(self.gitPullAct)
-self.vcsCommitAct = E5Action(
+self.vcsCommitAct = EricAction(
 self.tr('Commit changes to repository'),
 UI.PixmapCache.getIcon("vcsCommit"),
 self.tr('Commit changes to repository...'), 0, 0, self,
 'git_commit')
 self.vcsCommitAct.setStatusTip(self.tr(
 """Git repository.</p>"""
 ))
 self.vcsCommitAct.triggered.connect(self._vcsCommit)
 self.actions.append(self.vcsCommitAct)
-self.gitPushAct = E5Action(
+self.gitPushAct = EricAction(
 self.tr('Push changes'),
 UI.PixmapCache.getIcon("vcsCommit"),
 self.tr('Push changes'),
 0, 0, self, 'git_push')
 self.gitPushAct.setStatusTip(self.tr(
 """remote repository.</p>"""
 ))
 self.gitPushAct.triggered.connect(self.__gitPush)
 self.actions.append(self.gitPushAct)
-self.vcsExportAct = E5Action(
+self.vcsExportAct = EricAction(
 self.tr('Export from repository'),
 UI.PixmapCache.getIcon("vcsExport"),
 self.tr('&Export from repository...'),
 0, 0, self, 'git_export_repo')
 self.vcsExportAct.setStatusTip(self.tr(
 """<p>This exports a project from the repository.</p>"""
 ))
 self.vcsExportAct.triggered.connect(self._vcsExport)
 self.actions.append(self.vcsExportAct)
-self.gitLogBrowserAct = E5Action(
+self.gitLogBrowserAct = EricAction(
 self.tr('Show log browser'),
 UI.PixmapCache.getIcon("vcsLog"),
 self.tr('Show log browser'),
 0, 0, self, 'git_log_browser')
 self.gitLogBrowserAct.setStatusTip(self.tr(
 """ More can be retrieved later on.</p>"""
 ))
 self.gitLogBrowserAct.triggered.connect(self._vcsLogBrowser)
 self.actions.append(self.gitLogBrowserAct)
-self.gitReflogBrowserAct = E5Action(
+self.gitReflogBrowserAct = EricAction(
 self.tr('Show reflog browser'),
 UI.PixmapCache.getIcon("vcsLog"),
 self.tr('Show reflog browser'),
 0, 0, self, 'git_reflog_browser')
 self.gitReflogBrowserAct.setStatusTip(self.tr(
 """ More can be retrieved later on.</p>"""
 ))
 self.gitReflogBrowserAct.triggered.connect(self.__gitReflogBrowser)
 self.actions.append(self.gitReflogBrowserAct)
-self.vcsDiffAct = E5Action(
+self.vcsDiffAct = EricAction(
 self.tr('Show differences'),
 UI.PixmapCache.getIcon("vcsDiff"),
 self.tr('Show &differences...'),
 0, 0, self, 'git_diff')
 self.vcsDiffAct.setStatusTip(self.tr(
 """ repository.</p>"""
 ))
 self.vcsDiffAct.triggered.connect(self._vcsDiff)
 self.actions.append(self.vcsDiffAct)
-self.gitExtDiffAct = E5Action(
+self.gitExtDiffAct = EricAction(
 self.tr('Show differences (extended)'),
 UI.PixmapCache.getIcon("vcsDiff"),
 self.tr('Show differences (extended) ...'),
 0, 0, self, 'git_extendeddiff')
 self.gitExtDiffAct.setStatusTip(self.tr(
 """ project.</p>"""
 ))
 self.gitExtDiffAct.triggered.connect(self.__gitExtendedDiff)
 self.actions.append(self.gitExtDiffAct)
-self.vcsStatusAct = E5Action(
+self.vcsStatusAct = EricAction(
 self.tr('Show status'),
 UI.PixmapCache.getIcon("vcsStatus"),
 self.tr('Show &status...'),
 0, 0, self, 'git_status')
 self.vcsStatusAct.setStatusTip(self.tr(
 """<p>This shows the status of the local project.</p>"""
 ))
 self.vcsStatusAct.triggered.connect(self._vcsStatus)
 self.actions.append(self.vcsStatusAct)
-self.vcsSwitchAct = E5Action(
+self.vcsSwitchAct = EricAction(
 self.tr('Switch'),
 UI.PixmapCache.getIcon("vcsSwitch"),
 self.tr('S&witch...'),
 0, 0, self, 'git_switch')
 self.vcsSwitchAct.setStatusTip(self.tr(
 """ revision.</p>"""
 ))
 self.vcsSwitchAct.triggered.connect(self._vcsSwitch)
 self.actions.append(self.vcsSwitchAct)
-self.vcsTagAct = E5Action(
+self.vcsTagAct = EricAction(
 self.tr('Tag in repository'),
 UI.PixmapCache.getIcon("vcsTag"),
 self.tr('&Tag in repository...'),
 0, 0, self, 'git_tag')
 self.vcsTagAct.setStatusTip(self.tr(
 """ project.</p>"""
 ))
 self.vcsTagAct.triggered.connect(self._vcsTag)
 self.actions.append(self.vcsTagAct)
-self.gitTagListAct = E5Action(
+self.gitTagListAct = EricAction(
 self.tr('List tags'),
 self.tr('&List tags...'),
 0, 0, self, 'git_list_tags')
 self.gitTagListAct.setStatusTip(self.tr(
 'List tags of the project'
 """<p>This lists the tags of the project.</p>"""
 ))
 self.gitTagListAct.triggered.connect(self.__gitTagList)
 self.actions.append(self.gitTagListAct)
-self.gitDescribeTagAct = E5Action(
+self.gitDescribeTagAct = EricAction(
 self.tr('Show most recent tag'),
 self.tr('Show most recent tag'),
 0, 0, self, 'git_describe_tag')
 self.gitDescribeTagAct.setStatusTip(self.tr(
 'Show the most recent tag reachable from the work tree'
 """ tree.</p>"""
 ))
 self.gitDescribeTagAct.triggered.connect(self.__gitDescribeTag)
 self.actions.append(self.gitDescribeTagAct)
-self.gitBranchListAct = E5Action(
+self.gitBranchListAct = EricAction(
 self.tr('List branches'),
 self.tr('&List branches...'),
 0, 0, self, 'git_list_branches')
 self.gitBranchListAct.setStatusTip(self.tr(
 'List branches of the project'
 """<p>This lists the branches of the project.</p>"""
 ))
 self.gitBranchListAct.triggered.connect(self.__gitBranchList)
 self.actions.append(self.gitBranchListAct)
-self.gitMergedBranchListAct = E5Action(
+self.gitMergedBranchListAct = EricAction(
 self.tr('List merged branches'),
 self.tr('List &merged branches...'),
 0, 0, self, 'git_list_merged_branches')
 self.gitMergedBranchListAct.setStatusTip(self.tr(
 'List merged branches of the project'
 ))
 self.gitMergedBranchListAct.triggered.connect(
 self.__gitMergedBranchList)
 self.actions.append(self.gitMergedBranchListAct)
-self.gitNotMergedBranchListAct = E5Action(
+self.gitNotMergedBranchListAct = EricAction(
 self.tr('List non-merged branches'),
 self.tr('List &non-merged branches...'),
 0, 0, self, 'git_list_non_merged_branches')
 self.gitNotMergedBranchListAct.setStatusTip(self.tr(
 'List non-merged branches of the project'
 ))
 self.gitNotMergedBranchListAct.triggered.connect(
 self.__gitNotMergedBranchList)
 self.actions.append(self.gitNotMergedBranchListAct)
-self.gitBranchAct = E5Action(
+self.gitBranchAct = EricAction(
 self.tr('Branch in repository'),
 UI.PixmapCache.getIcon("vcsBranch"),
 self.tr('&Branch in repository...'),
 0, 0, self, 'git_branch')
 self.gitBranchAct.setStatusTip(self.tr(
 """ project.</p>"""
 ))
 self.gitBranchAct.triggered.connect(self.__gitBranch)
 self.actions.append(self.gitBranchAct)
-self.gitDeleteRemoteBranchAct = E5Action(
+self.gitDeleteRemoteBranchAct = EricAction(
 self.tr('Delete Remote Branch'),
 self.tr('&Delete Remote Branch...'),
 0, 0, self, 'git_delete_remote_branch')
 self.gitDeleteRemoteBranchAct.setStatusTip(self.tr(
 'Delete a branch from a remote repository'
 """<p>This deletes a branch from a remote repository.</p>"""
 ))
 self.gitDeleteRemoteBranchAct.triggered.connect(self.__gitDeleteBranch)
 self.actions.append(self.gitDeleteRemoteBranchAct)
-self.gitShowBranchAct = E5Action(
+self.gitShowBranchAct = EricAction(
 self.tr('Show current branch'),
 self.tr('Show current branch'),
 0, 0, self, 'git_show_branch')
 self.gitShowBranchAct.setStatusTip(self.tr(
 'Show the current branch of the project'
 """<p>This shows the current branch of the project.</p>"""
 ))
 self.gitShowBranchAct.triggered.connect(self.__gitShowBranch)
 self.actions.append(self.gitShowBranchAct)
-self.vcsRevertAct = E5Action(
+self.vcsRevertAct = EricAction(
 self.tr('Revert changes'),
 UI.PixmapCache.getIcon("vcsRevert"),
 self.tr('Re&vert changes'),
 0, 0, self, 'git_revert')
 self.vcsRevertAct.setStatusTip(self.tr(
 """<p>This reverts all changes made to the local project.</p>"""
 ))
 self.vcsRevertAct.triggered.connect(self.__gitRevert)
 self.actions.append(self.vcsRevertAct)
-self.gitUnstageAct = E5Action(
+self.gitUnstageAct = EricAction(
 self.tr('Unstage changes'),
 UI.PixmapCache.getIcon("vcsRevert"),
 self.tr('&Unstage changes'),
 0, 0, self, 'git_revert')
 self.gitUnstageAct.setStatusTip(self.tr(
 """<p>This unstages all changes made to the local project.</p>"""
 ))
 self.gitUnstageAct.triggered.connect(self.__gitUnstage)
 self.actions.append(self.gitUnstageAct)
-self.vcsMergeAct = E5Action(
+self.vcsMergeAct = EricAction(
 self.tr('Merge'),
 UI.PixmapCache.getIcon("vcsMerge"),
 self.tr('Mer&ge changes...'),
 0, 0, self, 'git_merge')
 self.vcsMergeAct.setStatusTip(self.tr(
 """<p>This merges changes into the local project.</p>"""
 ))
 self.vcsMergeAct.triggered.connect(self._vcsMerge)
 self.actions.append(self.vcsMergeAct)
-self.gitCancelMergeAct = E5Action(
+self.gitCancelMergeAct = EricAction(
 self.tr('Cancel uncommitted/failed merge'),
 self.tr('Cancel uncommitted/failed merge'),
 0, 0, self, 'git_cancel_merge')
 self.gitCancelMergeAct.setStatusTip(self.tr(
 'Cancel an uncommitted or failed merge and lose all changes'
 """ changes to be lost.</p>"""
 ))
 self.gitCancelMergeAct.triggered.connect(self.__gitCancelMerge)
 self.actions.append(self.gitCancelMergeAct)
-self.gitCommitMergeAct = E5Action(
+self.gitCommitMergeAct = EricAction(
 self.tr('Commit failed merge'),
 self.tr('Commit failed merge'),
 0, 0, self, 'git_commit_merge')
 self.gitCommitMergeAct.setStatusTip(self.tr(
 'Commit a failed merge after conflicts have been resolved'
 """ resolved.</p>"""
 ))
 self.gitCommitMergeAct.triggered.connect(self.__gitCommitMerge)
 self.actions.append(self.gitCommitMergeAct)
-self.vcsCleanupAct = E5Action(
+self.vcsCleanupAct = EricAction(
 self.tr('Cleanup'),
 self.tr('Cleanu&p'),
 0, 0, self, 'git_cleanup')
 self.vcsCleanupAct.setStatusTip(self.tr(
 'Cleanup the local project'
 """<p>This performs a cleanup of the local project.</p>"""
 ))
 self.vcsCleanupAct.triggered.connect(self._vcsCleanup)
 self.actions.append(self.vcsCleanupAct)
-self.vcsCommandAct = E5Action(
+self.vcsCommandAct = EricAction(
 self.tr('Execute command'),
 self.tr('E&xecute command...'),
 0, 0, self, 'git_command')
 self.vcsCommandAct.setStatusTip(self.tr(
 'Execute an arbitrary Git command'
 """ command.</p>"""
 ))
 self.vcsCommandAct.triggered.connect(self._vcsCommand)
 self.actions.append(self.vcsCommandAct)
-self.gitConfigAct = E5Action(
+self.gitConfigAct = EricAction(
 self.tr('Configure'),
 self.tr('Configure...'),
 0, 0, self, 'git_configure')
 self.gitConfigAct.setStatusTip(self.tr(
 'Show the configuration dialog with the Git page selected'
 """ selected.</p>"""
 ))
 self.gitConfigAct.triggered.connect(self.__gitConfigure)
 self.actions.append(self.gitConfigAct)
-self.gitRemotesShowAct = E5Action(
+self.gitRemotesShowAct = EricAction(
 self.tr('Show Remotes'),
 self.tr('Show Remotes...'),
 0, 0, self, 'git_show_remotes')
 self.gitRemotesShowAct.setStatusTip(self.tr(
 'Show the available remote repositories'
 """ pulling, fetching and pushing.</p>"""
 ))
 self.gitRemotesShowAct.triggered.connect(self.__gitShowRemotes)
 self.actions.append(self.gitRemotesShowAct)
-self.gitRemoteShowAct = E5Action(
+self.gitRemoteShowAct = EricAction(
 self.tr('Show Remote Info'),
 self.tr('Show Remote Info...'),
 0, 0, self, 'git_show_remote_info')
 self.gitRemoteShowAct.setStatusTip(self.tr(
 'Show information about a remote repository'
 """ pulling, fetching and pushing.</p>"""
 ))
 self.gitRemoteShowAct.triggered.connect(self.__gitShowRemote)
 self.actions.append(self.gitRemoteShowAct)
-self.gitRemoteAddAct = E5Action(
+self.gitRemoteAddAct = EricAction(
 self.tr('Add'),
 self.tr('Add...'),
 0, 0, self, 'git_add_remote')
 self.gitRemoteAddAct.setStatusTip(self.tr(
 'Add a remote repository'
 """<p>This adds a remote repository.</p>"""
 ))
 self.gitRemoteAddAct.triggered.connect(self.__gitAddRemote)
 self.actions.append(self.gitRemoteAddAct)
-self.gitRemoteRemoveAct = E5Action(
+self.gitRemoteRemoveAct = EricAction(
 self.tr('Remove'),
 self.tr('Remove...'),
 0, 0, self, 'git_remove_remote')
 self.gitRemoteRemoveAct.setStatusTip(self.tr(
 'Remove a remote repository'
 """<p>This removes a remote repository.</p>"""
 ))
 self.gitRemoteRemoveAct.triggered.connect(self.__gitRemoveRemote)
 self.actions.append(self.gitRemoteRemoveAct)
-self.gitRemotePruneAct = E5Action(
+self.gitRemotePruneAct = EricAction(
 self.tr('Prune'),
 self.tr('Prune...'),
 0, 0, self, 'git_prune_remote')
 self.gitRemotePruneAct.setStatusTip(self.tr(
 'Prune stale remote-tracking branches of a remote repository'
 """ repository.</p>"""
 ))
 self.gitRemotePruneAct.triggered.connect(self.__gitPruneRemote)
 self.actions.append(self.gitRemotePruneAct)
-self.gitRemoteRenameAct = E5Action(
+self.gitRemoteRenameAct = EricAction(
 self.tr('Rename'),
 self.tr('Rename...'),
 0, 0, self, 'git_rename_remote')
 self.gitRemoteRenameAct.setStatusTip(self.tr(
 'Rename a remote repository'
 """<p>This renames a remote repository.</p>"""
 ))
 self.gitRemoteRenameAct.triggered.connect(self.__gitRenameRemote)
 self.actions.append(self.gitRemoteRenameAct)
-self.gitRemoteChangeUrlAct = E5Action(
+self.gitRemoteChangeUrlAct = EricAction(
 self.tr('Change URL'),
 self.tr('Change URL...'),
 0, 0, self, 'git_change_remote_url')
 self.gitRemoteChangeUrlAct.setStatusTip(self.tr(
 'Change the URL of a remote repository'
 """<p>This changes the URL of a remote repository.</p>"""
 ))
 self.gitRemoteChangeUrlAct.triggered.connect(self.__gitChangeRemoteUrl)
 self.actions.append(self.gitRemoteChangeUrlAct)
-self.gitRemoteCredentialsAct = E5Action(
+self.gitRemoteCredentialsAct = EricAction(
 self.tr('Credentials'),
 self.tr('Credentials...'),
 0, 0, self, 'git_remote_credentials')
 self.gitRemoteCredentialsAct.setStatusTip(self.tr(
 'Change or set the user credentials of a remote repository'
 ))
 self.gitRemoteCredentialsAct.triggered.connect(
 self.__gitRemoteCredentials)
 self.actions.append(self.gitRemoteCredentialsAct)
-self.gitCherryPickAct = E5Action(
+self.gitCherryPickAct = EricAction(
 self.tr('Copy Commits'),
 UI.PixmapCache.getIcon("vcsGraft"),
 self.tr('Copy Commits'),
 0, 0, self, 'git_cherrypick')
 self.gitCherryPickAct.setStatusTip(self.tr(
 """<p>This copies commits on top of the current branch.</p>"""
 ))
 self.gitCherryPickAct.triggered.connect(self.__gitCherryPick)
 self.actions.append(self.gitCherryPickAct)
-self.gitCherryPickContinueAct = E5Action(
+self.gitCherryPickContinueAct = EricAction(
 self.tr('Continue Copying Session'),
 self.tr('Continue Copying Session'),
 0, 0, self, 'git_cherrypick_continue')
 self.gitCherryPickContinueAct.setStatusTip(self.tr(
 'Continue the last copying session after conflicts were resolved'
 ))
 self.gitCherryPickContinueAct.triggered.connect(
 self.__gitCherryPickContinue)
 self.actions.append(self.gitCherryPickContinueAct)
-self.gitCherryPickQuitAct = E5Action(
+self.gitCherryPickQuitAct = EricAction(
 self.tr('Quit Copying Session'),
 self.tr('Quit Copying Session'),
 0, 0, self, 'git_cherrypick_quit')
 self.gitCherryPickQuitAct.setStatusTip(self.tr(
 'Quit the current copying session'
 """<p>This quits the current copying session.</p>"""
 ))
 self.gitCherryPickQuitAct.triggered.connect(self.__gitCherryPickQuit)
 self.actions.append(self.gitCherryPickQuitAct)
-self.gitCherryPickAbortAct = E5Action(
+self.gitCherryPickAbortAct = EricAction(
 self.tr('Cancel Copying Session'),
 self.tr('Cancel Copying Session'),
 0, 0, self, 'git_cherrypick_abort')
 self.gitCherryPickAbortAct.setStatusTip(self.tr(
 'Cancel the current copying session and return to the'
 """ the previous state.</p>"""
 ))
 self.gitCherryPickAbortAct.triggered.connect(self.__gitCherryPickAbort)
 self.actions.append(self.gitCherryPickAbortAct)
-self.gitStashAct = E5Action(
+self.gitStashAct = EricAction(
 self.tr('Stash changes'),
 self.tr('Stash changes...'),
 0, 0, self, 'git_stash')
 self.gitStashAct.setStatusTip(self.tr(
 'Stash all current changes of the project'
 """<p>This stashes all current changes of the project.</p>"""
 ))
 self.gitStashAct.triggered.connect(self.__gitStashSave)
 self.actions.append(self.gitStashAct)
-self.gitStashBrowserAct = E5Action(
+self.gitStashBrowserAct = EricAction(
 self.tr('Show stash browser'),
 self.tr('Show stash browser...'),
 0, 0, self, 'git_stash_browser')
 self.gitStashBrowserAct.setStatusTip(self.tr(
 'Show a dialog with all stashes'
 """ context menu.</p>"""
 ))
 self.gitStashBrowserAct.triggered.connect(self.__gitStashBrowser)
 self.actions.append(self.gitStashBrowserAct)
-self.gitStashShowAct = E5Action(
+self.gitStashShowAct = EricAction(
 self.tr('Show stash'),
 self.tr('Show stash...'),
 0, 0, self, 'git_stash_show')
 self.gitStashShowAct.setStatusTip(self.tr(
 'Show a dialog with a patch of a stash'
 """ stash.</p>"""
 ))
 self.gitStashShowAct.triggered.connect(self.__gitStashShow)
 self.actions.append(self.gitStashShowAct)
-self.gitStashApplyAct = E5Action(
+self.gitStashApplyAct = EricAction(
 self.tr('Restore && Keep'),
 self.tr('Restore && Keep'),
 0, 0, self, 'git_stash_apply')
 self.gitStashApplyAct.setStatusTip(self.tr(
 'Restore a stash but keep it'
 """<p>This restores a selectable stash and keeps it.</p>"""
 ))
 self.gitStashApplyAct.triggered.connect(self.__gitStashApply)
 self.actions.append(self.gitStashApplyAct)
-self.gitStashPopAct = E5Action(
+self.gitStashPopAct = EricAction(
 self.tr('Restore && Delete'),
 self.tr('Restore && Delete'),
 0, 0, self, 'git_stash_pop')
 self.gitStashPopAct.setStatusTip(self.tr(
 'Restore a stash and delete it'
 """<p>This restores a selectable stash and deletes it.</p>"""
 ))
 self.gitStashPopAct.triggered.connect(self.__gitStashPop)
 self.actions.append(self.gitStashPopAct)
-self.gitStashBranchAct = E5Action(
+self.gitStashBranchAct = EricAction(
 self.tr('Create Branch'),
 self.tr('Create Branch'),
 0, 0, self, 'git_stash_branch')
 self.gitStashBranchAct.setStatusTip(self.tr(
 'Create a new branch and restore a stash into it'
 """ it.</p>"""
 ))
 self.gitStashBranchAct.triggered.connect(self.__gitStashBranch)
 self.actions.append(self.gitStashBranchAct)
-self.gitStashDropAct = E5Action(
+self.gitStashDropAct = EricAction(
 self.tr('Delete'),
 self.tr('Delete'),
 0, 0, self, 'git_stash_delete')
 self.gitStashDropAct.setStatusTip(self.tr(
 'Delete a stash'
 """<p>This deletes a stash.</p>"""
 ))
 self.gitStashDropAct.triggered.connect(self.__gitStashDrop)
 self.actions.append(self.gitStashDropAct)
-self.gitStashClearAct = E5Action(
+self.gitStashClearAct = EricAction(
 self.tr('Delete All'),
 self.tr('Delete All'),
 0, 0, self, 'git_stash_delete_all')
 self.gitStashClearAct.setStatusTip(self.tr(
 'Delete all stashes'
 """<p>This deletes all stashes.</p>"""
 ))
 self.gitStashClearAct.triggered.connect(self.__gitStashClear)
 self.actions.append(self.gitStashClearAct)
-self.gitEditUserConfigAct = E5Action(
+self.gitEditUserConfigAct = EricAction(
 self.tr('Edit user configuration'),
 self.tr('Edit user configuration...'),
 0, 0, self, 'git_user_configure')
 self.gitEditUserConfigAct.setStatusTip(self.tr(
 'Show an editor to edit the user configuration file'
 """<p>Show an editor to edit the user configuration file.</p>"""
 ))
 self.gitEditUserConfigAct.triggered.connect(self.__gitEditUserConfig)
 self.actions.append(self.gitEditUserConfigAct)
-self.gitRepoConfigAct = E5Action(
+self.gitRepoConfigAct = EricAction(
 self.tr('Edit repository configuration'),
 self.tr('Edit repository configuration...'),
 0, 0, self, 'git_repo_configure')
 self.gitRepoConfigAct.setStatusTip(self.tr(
 'Show an editor to edit the repository configuration file'
 """ file.</p>"""
 ))
 self.gitRepoConfigAct.triggered.connect(self.__gitEditRepoConfig)
 self.actions.append(self.gitRepoConfigAct)
-self.gitCreateIgnoreAct = E5Action(
+self.gitCreateIgnoreAct = EricAction(
 self.tr('Create .gitignore'),
 self.tr('Create .gitignore'),
 0, 0, self, 'git_create_ignore')
 self.gitCreateIgnoreAct.setStatusTip(self.tr(
 'Create a .gitignore file with default values'
 """<p>This creates a .gitignore file with default values.</p>"""
 ))
 self.gitCreateIgnoreAct.triggered.connect(self.__gitCreateIgnore)
 self.actions.append(self.gitCreateIgnoreAct)
-self.gitShowConfigAct = E5Action(
+self.gitShowConfigAct = EricAction(
 self.tr('Show combined configuration settings'),
 self.tr('Show combined configuration settings...'),
 0, 0, self, 'git_show_config')
 self.gitShowConfigAct.setStatusTip(self.tr(
 'Show the combined configuration settings from all configuration'
 """ from all configuration files.</p>"""
 ))
 self.gitShowConfigAct.triggered.connect(self.__gitShowConfig)
 self.actions.append(self.gitShowConfigAct)
-self.gitVerifyAct = E5Action(
+self.gitVerifyAct = EricAction(
 self.tr('Verify repository'),
 self.tr('Verify repository...'),
 0, 0, self, 'git_verify')
 self.gitVerifyAct.setStatusTip(self.tr(
 'Verify the connectivity and validity of objects of the database'
 """ of the database.</p>"""
 ))
 self.gitVerifyAct.triggered.connect(self.__gitVerify)
 self.actions.append(self.gitVerifyAct)
-self.gitHouseKeepingAct = E5Action(
+self.gitHouseKeepingAct = EricAction(
 self.tr('Optimize repository'),
 self.tr('Optimize repository...'),
 0, 0, self, 'git_housekeeping')
 self.gitHouseKeepingAct.setStatusTip(self.tr(
 'Cleanup and optimize the local repository'
 """<p>This cleans up and optimizes the local repository.</p>"""
 ))
 self.gitHouseKeepingAct.triggered.connect(self.__gitHouseKeeping)
 self.actions.append(self.gitHouseKeepingAct)
-self.gitStatisticsAct = E5Action(
+self.gitStatisticsAct = EricAction(
 self.tr('Repository Statistics'),
 self.tr('Repository Statistics...'),
 0, 0, self, 'git_statistics')
 self.gitStatisticsAct.setStatusTip(self.tr(
 'Show some statistics of the local repository'
 """<p>This show some statistics of the local repository.</p>"""
 ))
 self.gitStatisticsAct.triggered.connect(self.__gitStatistics)
 self.actions.append(self.gitStatisticsAct)
-self.gitCreateArchiveAct = E5Action(
+self.gitCreateArchiveAct = EricAction(
 self.tr('Create Archive'),
 self.tr('Create Archive'),
 0, 0, self, 'git_create_archive')
 self.gitCreateArchiveAct.setStatusTip(self.tr(
 'Create an archive from the local repository'
 """<p>This creates an archive from the local repository.</p>"""
 ))
 self.gitCreateArchiveAct.triggered.connect(self.__gitCreateArchive)
 self.actions.append(self.gitCreateArchiveAct)
-self.gitBundleAct = E5Action(
+self.gitBundleAct = EricAction(
 self.tr('Create bundle'),
 self.tr('Create bundle...'),
 0, 0, self, 'mercurial_bundle_create')
 self.gitBundleAct.setStatusTip(self.tr(
 'Create bundle file collecting changesets'
 """ changesets (git bundle create).</p>"""
 ))
 self.gitBundleAct.triggered.connect(self.__gitBundle)
 self.actions.append(self.gitBundleAct)
-self.gitBundleVerifyAct = E5Action(
+self.gitBundleVerifyAct = EricAction(
 self.tr('Verify bundle'),
 self.tr('Verify bundle...'),
 0, 0, self, 'mercurial_bundle_verify')
 self.gitBundleVerifyAct.setStatusTip(self.tr(
 'Verify the validity and applicability of a bundle file'
 """ apply cleanly.</p>"""
 ))
 self.gitBundleVerifyAct.triggered.connect(self.__gitVerifyBundle)
 self.actions.append(self.gitBundleVerifyAct)
-self.gitBundleListHeadsAct = E5Action(
+self.gitBundleListHeadsAct = EricAction(
 self.tr('List bundle heads'),
 self.tr('List bundle heads...'),
 0, 0, self, 'mercurial_bundle_list_heads')
 self.gitBundleListHeadsAct.setStatusTip(self.tr(
 'List all heads contained in a bundle file'
 """<p>This lists all heads contained in a bundle file.</p>"""
 ))
 self.gitBundleListHeadsAct.triggered.connect(self.__gitBundleListHeads)
 self.actions.append(self.gitBundleListHeadsAct)
-self.gitBundleApplyFetchAct = E5Action(
+self.gitBundleApplyFetchAct = EricAction(
 self.tr('Apply Bundle (fetch)'),
 self.tr('Apply Bundle (fetch)...'),
 0, 0, self, 'mercurial_bundle_apply_fetch')
 self.gitBundleApplyFetchAct.setStatusTip(self.tr(
 'Apply a head of a bundle file using fetch'
 """<p>This applies a head of a bundle file using fetch.</p>"""
 ))
 self.gitBundleApplyFetchAct.triggered.connect(self.__gitBundleFetch)
 self.actions.append(self.gitBundleApplyFetchAct)
-self.gitBundleApplyPullAct = E5Action(
+self.gitBundleApplyPullAct = EricAction(
 self.tr('Apply Bundle (pull)'),
 self.tr('Apply Bundle (pull)...'),
 0, 0, self, 'mercurial_bundle_apply_pull')
 self.gitBundleApplyPullAct.setStatusTip(self.tr(
 'Apply a head of a bundle file using pull'
 """<p>This applies a head of a bundle file using pull.</p>"""
 ))
 self.gitBundleApplyPullAct.triggered.connect(self.__gitBundlePull)
 self.actions.append(self.gitBundleApplyPullAct)
-self.gitBisectStartAct = E5Action(
+self.gitBisectStartAct = EricAction(
 self.tr('Start'),
 self.tr('Start'),
 0, 0, self, 'git_bisect_start')
 self.gitBisectStartAct.setStatusTip(self.tr(
 'Start a bisect session'
 """<p>This starts a bisect session.</p>"""
 ))
 self.gitBisectStartAct.triggered.connect(self.__gitBisectStart)
 self.actions.append(self.gitBisectStartAct)
-self.gitBisectStartExtendedAct = E5Action(
+self.gitBisectStartExtendedAct = EricAction(
 self.tr('Start (Extended)'),
 self.tr('Start (Extended)'),
 0, 0, self, 'git_bisect_start_extended')
 self.gitBisectStartExtendedAct.setStatusTip(self.tr(
 'Start a bisect session giving a bad and optionally good commits'
 ))
 self.gitBisectStartExtendedAct.triggered.connect(
 self.__gitBisectStartExtended)
 self.actions.append(self.gitBisectStartExtendedAct)
-self.gitBisectGoodAct = E5Action(
+self.gitBisectGoodAct = EricAction(
 self.tr('Mark as "good"'),
 self.tr('Mark as "good"...'),
 0, 0, self, 'git_bisect_good')
 self.gitBisectGoodAct.setStatusTip(self.tr(
 'Mark a selectable revision as good'
 """<p>This marks a selectable revision as good.</p>"""
 ))
 self.gitBisectGoodAct.triggered.connect(self.__gitBisectGood)
 self.actions.append(self.gitBisectGoodAct)
-self.gitBisectBadAct = E5Action(
+self.gitBisectBadAct = EricAction(
 self.tr('Mark as "bad"'),
 self.tr('Mark as "bad"...'),
 0, 0, self, 'git_bisect_bad')
 self.gitBisectBadAct.setStatusTip(self.tr(
 'Mark a selectable revision as bad'
 """<p>This marks a selectable revision as bad.</p>"""
 ))
 self.gitBisectBadAct.triggered.connect(self.__gitBisectBad)
 self.actions.append(self.gitBisectBadAct)
-self.gitBisectSkipAct = E5Action(
+self.gitBisectSkipAct = EricAction(
 self.tr('Skip'),
 self.tr('Skip...'),
 0, 0, self, 'git_bisect_skip')
 self.gitBisectSkipAct.setStatusTip(self.tr(
 'Skip a selectable revision'
 """<p>This skips a selectable revision.</p>"""
 ))
 self.gitBisectSkipAct.triggered.connect(self.__gitBisectSkip)
 self.actions.append(self.gitBisectSkipAct)
-self.gitBisectResetAct = E5Action(
+self.gitBisectResetAct = EricAction(
 self.tr('Reset'),
 self.tr('Reset...'),
 0, 0, self, 'git_bisect_reset')
 self.gitBisectResetAct.setStatusTip(self.tr(
 'Reset the bisect session'
 """<p>This resets the bisect session.</p>"""
 ))
 self.gitBisectResetAct.triggered.connect(self.__gitBisectReset)
 self.actions.append(self.gitBisectResetAct)
-self.gitBisectLogBrowserAct = E5Action(
+self.gitBisectLogBrowserAct = EricAction(
 self.tr('Show bisect log browser'),
 UI.PixmapCache.getIcon("vcsLog"),
 self.tr('Show bisect log browser'),
 0, 0, self, 'git_bisect_log_browser')
 self.gitBisectLogBrowserAct.setStatusTip(self.tr(
 ))
 self.gitBisectLogBrowserAct.triggered.connect(
 self.__gitBisectLogBrowser)
 self.actions.append(self.gitBisectLogBrowserAct)
-self.gitBisectCreateReplayAct = E5Action(
+self.gitBisectCreateReplayAct = EricAction(
 self.tr('Create replay file'),
 self.tr('Create replay file'),
 0, 0, self, 'git_bisect_create_replay')
 self.gitBisectCreateReplayAct.setStatusTip(self.tr(
 'Create a replay file to repeat the current bisect session'
 ))
 self.gitBisectCreateReplayAct.triggered.connect(
 self.__gitBisectCreateReplay)
 self.actions.append(self.gitBisectCreateReplayAct)
-self.gitBisectEditReplayAct = E5Action(
+self.gitBisectEditReplayAct = EricAction(
 self.tr('Edit replay file'),
 self.tr('Edit replay file'),
 0, 0, self, 'git_bisect_edit_replay')
 self.gitBisectEditReplayAct.setStatusTip(self.tr(
 'Edit a bisect replay file'
 ))
 self.gitBisectEditReplayAct.triggered.connect(
 self.__gitBisectEditReplay)
 self.actions.append(self.gitBisectEditReplayAct)
-self.gitBisectReplayAct = E5Action(
+self.gitBisectReplayAct = EricAction(
 self.tr('Replay session'),
 self.tr('Replay session'),
 0, 0, self, 'git_bisect_replay')
 self.gitBisectReplayAct.setStatusTip(self.tr(
 'Replay a bisect session from file'
 """<p>This replays a bisect session from file.</p>"""
 ))
 self.gitBisectReplayAct.triggered.connect(self.__gitBisectReplay)
 self.actions.append(self.gitBisectReplayAct)
-self.gitCheckPatchesAct = E5Action(
+self.gitCheckPatchesAct = EricAction(
 self.tr('Check patch files'),
 self.tr('Check patch files'),
 0, 0, self, 'git_check_patches')
 self.gitCheckPatchesAct.setStatusTip(self.tr(
 'Check a list of patch files, if they would apply cleanly'
 """ cleanly.</p>"""
 ))
 self.gitCheckPatchesAct.triggered.connect(self.__gitCheckPatches)
 self.actions.append(self.gitCheckPatchesAct)
-self.gitApplyPatchesAct = E5Action(
+self.gitApplyPatchesAct = EricAction(
 self.tr('Apply patch files'),
 self.tr('Apply patch files'),
 0, 0, self, 'git_apply_patches')
 self.gitApplyPatchesAct.setStatusTip(self.tr(
 'Apply a list of patch files'
 """<p>This applies a list of patch files.</p>"""
 ))
 self.gitApplyPatchesAct.triggered.connect(self.__gitApplyPatches)
 self.actions.append(self.gitApplyPatchesAct)
-self.gitShowPatcheStatisticsAct = E5Action(
+self.gitShowPatcheStatisticsAct = EricAction(
 self.tr('Show patch statistics'),
 self.tr('Show patch statistics'),
 0, 0, self, 'git_show_patches_statistics')
 self.gitShowPatcheStatisticsAct.setStatusTip(self.tr(
 'Show some statistics for a list of patch files'
 ))
 self.gitShowPatcheStatisticsAct.triggered.connect(
 self.__gitShowPatchStatistics)
 self.actions.append(self.gitShowPatcheStatisticsAct)
-self.gitSubmoduleAddAct = E5Action(
+self.gitSubmoduleAddAct = EricAction(
 self.tr('Add'),
 self.tr('Add'),
 0, 0, self, 'git_submodule_add')
 self.gitSubmoduleAddAct.setStatusTip(self.tr(
 'Add a submodule to the current project'
 ))
 self.gitSubmoduleAddAct.triggered.connect(
 self.__gitSubmoduleAdd)
 self.actions.append(self.gitSubmoduleAddAct)
-self.gitSubmodulesListAct = E5Action(
+self.gitSubmodulesListAct = EricAction(
 self.tr('List'),
 self.tr('List'),
 0, 0, self, 'git_submodules_list')
 self.gitSubmodulesListAct.setStatusTip(self.tr(
 'List the submodule of the current project'
 ))
 self.gitSubmodulesListAct.triggered.connect(
 self.__gitSubmodulesList)
 self.actions.append(self.gitSubmodulesListAct)
-self.gitSubmodulesInitAct = E5Action(
+self.gitSubmodulesInitAct = EricAction(
 self.tr('Initialize'),
 self.tr('Initialize'),
 0, 0, self, 'git_submodules_init')
 self.gitSubmodulesInitAct.setStatusTip(self.tr(
 'Initialize the submodules of the current project'
 ))
 self.gitSubmodulesInitAct.triggered.connect(
 self.__gitSubmodulesInit)
 self.actions.append(self.gitSubmodulesInitAct)
-self.gitSubmodulesDeinitAct = E5Action(
+self.gitSubmodulesDeinitAct = EricAction(
 self.tr('Unregister'),
 self.tr('Unregister'),
 0, 0, self, 'git_submodules_deinit')
 self.gitSubmodulesDeinitAct.setStatusTip(self.tr(
 'Unregister submodules of the current project'
 ))
 self.gitSubmodulesDeinitAct.triggered.connect(
 self.__gitSubmodulesDeinit)
 self.actions.append(self.gitSubmodulesDeinitAct)
-self.gitSubmodulesUpdateAct = E5Action(
+self.gitSubmodulesUpdateAct = EricAction(
 self.tr('Update'),
 self.tr('Update'),
 0, 0, self, 'git_submodules_update')
 self.gitSubmodulesUpdateAct.setStatusTip(self.tr(
 'Update submodules of the current project'
 ))
 self.gitSubmodulesUpdateAct.triggered.connect(
 self.__gitSubmodulesUpdate)
 self.actions.append(self.gitSubmodulesUpdateAct)
-self.gitSubmodulesUpdateInitAct = E5Action(
+self.gitSubmodulesUpdateInitAct = EricAction(
 self.tr('Initialize and Update'),
 self.tr('Initialize and Update'),
 0, 0, self, 'git_submodules_update_init')
 self.gitSubmodulesUpdateInitAct.setStatusTip(self.tr(
 'Initialize and update submodules of the current project'
 ))
 self.gitSubmodulesUpdateInitAct.triggered.connect(
 self.__gitSubmodulesUpdateInit)
 self.actions.append(self.gitSubmodulesUpdateInitAct)
-self.gitSubmodulesUpdateRemoteAct = E5Action(
+self.gitSubmodulesUpdateRemoteAct = EricAction(
 self.tr('Fetch and Update'),
 self.tr('Fetch and Update'),
 0, 0, self, 'git_submodules_update_remote')
 self.gitSubmodulesUpdateRemoteAct.setStatusTip(self.tr(
 'Fetch and update submodules of the current project'
 ))
 self.gitSubmodulesUpdateRemoteAct.triggered.connect(
 self.__gitSubmodulesUpdateRemote)
 self.actions.append(self.gitSubmodulesUpdateRemoteAct)
-self.gitSubmodulesUpdateOptionsAct = E5Action(
+self.gitSubmodulesUpdateOptionsAct = EricAction(
 self.tr('Update with Options'),
 self.tr('Update with Options'),
 0, 0, self, 'git_submodules_update_options')
 self.gitSubmodulesUpdateOptionsAct.setStatusTip(self.tr(
 'Update submodules of the current project offering a dialog'
 ))
 self.gitSubmodulesUpdateOptionsAct.triggered.connect(
 self.__gitSubmodulesUpdateOptions)
 self.actions.append(self.gitSubmodulesUpdateOptionsAct)
-self.gitSubmodulesSyncAct = E5Action(
+self.gitSubmodulesSyncAct = EricAction(
 self.tr('Synchronize URLs'),
 self.tr('Synchronize URLs'),
 0, 0, self, 'git_submodules_sync')
 self.gitSubmodulesSyncAct.setStatusTip(self.tr(
 'Synchronize URLs of submodules of the current project'
 ))
 self.gitSubmodulesSyncAct.triggered.connect(
 self.__gitSubmodulesSync)
 self.actions.append(self.gitSubmodulesSyncAct)
-self.gitSubmodulesStatusAct = E5Action(
+self.gitSubmodulesStatusAct = EricAction(
 self.tr('Show Status'),
 self.tr('Show Status'),
 0, 0, self, 'git_submodules_status')
 self.gitSubmodulesStatusAct.setStatusTip(self.tr(
 'Show the status of submodules of the current project'
 ))
 self.gitSubmodulesStatusAct.triggered.connect(
 self.__gitSubmodulesStatus)
 self.actions.append(self.gitSubmodulesStatusAct)
-self.gitSubmodulesSummaryAct = E5Action(
+self.gitSubmodulesSummaryAct = EricAction(
 self.tr('Show Summary'),
 self.tr('Show Summary'),
 0, 0, self, 'git_submodules_summary')
 self.gitSubmodulesSummaryAct.setStatusTip(self.tr(
 'Show summary information for submodules of the current project'
 """
 Public slot to initialize the VCS toolbar.
 @param ui reference to the main window (UserInterface)
 @param toolbarManager reference to a toolbar manager object
-(E5ToolBarManager)
+(EricToolBarManager)
 """
 self.__toolbar = QToolBar(self.tr("Git"), ui)
 self.__toolbar.setIconSize(UI.Config.ToolBarIconSize)
 self.__toolbar.setObjectName("GitToolbar")
 self.__toolbar.setToolTip(self.tr('Git'))
 """
 Public method to remove a toolbar created by initToolbar().
 @param ui reference to the main window (UserInterface)
 @param toolbarManager reference to a toolbar manager object
-(E5ToolBarManager)
+(EricToolBarManager)
 """
 ui.removeToolBar(self.__toolbar)
 ui.unregisterToolbar("git")
 title = self.__toolbar.windowTitle()
 shouldReopen = (
 self.vcs.gitBranch(self.project.getProjectPath())[1] or
 QFileInfo(pfile).lastModified().toString() != lastModified
 )
 if shouldReopen:
-res = E5MessageBox.yesNo(
+res = EricMessageBox.yesNo(
 self.parent(),
 self.tr("Branch"),
 self.tr("""The project should be reread. Do this now?"""),
 yesDefault=True)
 if res:
 shouldReopen = (
 self.vcs.gitPull(self.project.getProjectPath()) or
 QFileInfo(pfile).lastModified().toString() != lastModified
 )
 if shouldReopen:
-res = E5MessageBox.yesNo(
+res = EricMessageBox.yesNo(
 self.parent(),
 self.tr("Pull"),
 self.tr("""The project should be reread. Do this now?"""),
 yesDefault=True)
 if res:
 shouldReopen = (
 self.vcs.gitRevert(self.project.getProjectPath()) or
 QFileInfo(pfile).lastModified().toString() != lastModified
 )
 if shouldReopen:
-res = E5MessageBox.yesNo(
+res = EricMessageBox.yesNo(
 self.parent(),
 self.tr("Revert Changes"),
 self.tr("""The project should be reread. Do this now?"""),
 yesDefault=True)
 if res:
 shouldReopen = (
 self.vcs.gitUnstage(self.project.getProjectPath()) or
 QFileInfo(pfile).lastModified().toString() != lastModified
 )
 if shouldReopen:
-res = E5MessageBox.yesNo(
+res = EricMessageBox.yesNo(
 self.parent(),
 self.tr("Unstage Changes"),
 self.tr("""The project should be reread. Do this now?"""),
 yesDefault=True)
 if res:
 shouldReopen = (
 self.vcs.gitCherryPick(self.project.getProjectPath()) or
 QFileInfo(pfile).lastModified().toString() != lastModified
 )
 if shouldReopen:
-res = E5MessageBox.yesNo(
+res = EricMessageBox.yesNo(
 None,
 self.tr("Copy Commits"),
 self.tr("""The project should be reread. Do this now?"""),
 yesDefault=True)
 if res:
 shouldReopen = (
 self.vcs.gitCherryPickContinue(self.project.getProjectPath()) or
 QFileInfo(pfile).lastModified().toString() != lastModified
 )
 if shouldReopen:
-res = E5MessageBox.yesNo(
+res = EricMessageBox.yesNo(
 None,
 self.tr("Copy Commits (Continue)"),
 self.tr("""The project should be reread. Do this now?"""),
 yesDefault=True)
 if res:
 shouldReopen = (
 self.vcs.gitCherryPickQuit(self.project.getProjectPath()) or
 QFileInfo(pfile).lastModified().toString() != lastModified
 )
 if shouldReopen:
-res = E5MessageBox.yesNo(
+res = EricMessageBox.yesNo(
 None,
 self.tr("Copy Commits (Quit)"),
 self.tr("""The project should be reread. Do this now?"""),
 yesDefault=True)
 if res:
 shouldReopen = (
 self.vcs.gitCherryPickAbort(self.project.getProjectPath()) or
 QFileInfo(pfile).lastModified().toString() != lastModified
 )
 if shouldReopen:
-res = E5MessageBox.yesNo(
+res = EricMessageBox.yesNo(
 None,
 self.tr("Copy Commits (Cancel)"),
 self.tr("""The project should be reread. Do this now?"""),
 yesDefault=True)
 if res:
 shouldReopen = (
 self.vcs.gitStashSave(self.project.getProjectPath()) or
 QFileInfo(pfile).lastModified().toString() != lastModified
 )
 if shouldReopen:
-res = E5MessageBox.yesNo(
+res = EricMessageBox.yesNo(
 self.parent(),
 self.tr("Save Stash"),
 self.tr("""The project should be reread. Do this now?"""),
 yesDefault=True)
 if res:
 shouldReopen = (
 self.vcs.gitStashApply(self.project.getProjectPath()) or
 QFileInfo(pfile).lastModified().toString() != lastModified
 )
 if shouldReopen:
-res = E5MessageBox.yesNo(
+res = EricMessageBox.yesNo(
 self.parent(),
 self.tr("Restore Stash"),
 self.tr("""The project should be reread. Do this now?"""),
 yesDefault=True)
 if res:
 shouldReopen = (
 self.vcs.gitStashPop(self.project.getProjectPath()) or
 QFileInfo(pfile).lastModified().toString() != lastModified
 )
 if shouldReopen:
-res = E5MessageBox.yesNo(
+res = EricMessageBox.yesNo(
 self.parent(),
 self.tr("Restore Stash"),
 self.tr("""The project should be reread. Do this now?"""),
 yesDefault=True)
 if res:
 shouldReopen = (
 self.vcs.gitStashBranch(self.project.getProjectPath()) or
 QFileInfo(pfile).lastModified().toString() != lastModified
 )
 if shouldReopen:
-res = E5MessageBox.yesNo(
+res = EricMessageBox.yesNo(
 self.parent(),
 self.tr("Create Branch"),
 self.tr("""The project should be reread. Do this now?"""),
 yesDefault=True)
 if res:
 def __gitConfigure(self):
 """
 Private method to open the configuration dialog.
 """
-e5App().getObject("UserInterface").showPreferences("zzz_gitPage")
+ericApp().getObject("UserInterface").showPreferences("zzz_gitPage")
 def __gitEditUserConfig(self):
 """
 Private slot used to edit the user configuration file.
 """
 shouldReopen = (
 self.vcs.gitBundlePull(self.project.getProjectPath()) or
 QFileInfo(pfile).lastModified().toString() != lastModified
 )
 if shouldReopen:
-res = E5MessageBox.yesNo(
+res = EricMessageBox.yesNo(
 self.parent(),
 self.tr("Apply Bundle (pull)"),
 self.tr("""The project should be reread. Do this now?"""),
 yesDefault=True)
 if res:
 self.vcs.gitBisect(self.project.getProjectPath(),
 "start_extended") or
 QFileInfo(pfile).lastModified().toString() != lastModified
 )
 if shouldReopen:
-res = E5MessageBox.yesNo(
+res = EricMessageBox.yesNo(
 self.parent(),
 self.tr("Bisect"),
 self.tr("""The project should be reread. Do this now?"""),
 yesDefault=True)
 if res:
 shouldReopen = (
 self.vcs.gitBisect(self.project.getProjectPath(), "good") or
 QFileInfo(pfile).lastModified().toString() != lastModified
 )
 if shouldReopen:
-res = E5MessageBox.yesNo(
+res = EricMessageBox.yesNo(
 self.parent(),
 self.tr("Bisect"),
 self.tr("""The project should be reread. Do this now?"""),
 yesDefault=True)
 if res:
 shouldReopen = (
 self.vcs.gitBisect(self.project.getProjectPath(), "bad") or
 QFileInfo(pfile).lastModified().toString() != lastModified
 )
 if shouldReopen:
-res = E5MessageBox.yesNo(
+res = EricMessageBox.yesNo(
 self.parent(),
 self.tr("Bisect"),
 self.tr("""The project should be reread. Do this now?"""),
 yesDefault=True)
 if res:
 shouldReopen = (
 self.vcs.gitBisect(self.project.getProjectPath(), "skip") or
 QFileInfo(pfile).lastModified().toString() != lastModified
 )
 if shouldReopen:
-res = E5MessageBox.yesNo(
+res = EricMessageBox.yesNo(
 self.parent(),
 self.tr("Bisect"),
 self.tr("""The project should be reread. Do this now?"""),
 yesDefault=True)
 if res:
 shouldReopen = (
 self.vcs.gitBisect(self.project.getProjectPath(), "reset") or
 QFileInfo(pfile).lastModified().toString() != lastModified
 )
 if shouldReopen:
-res = E5MessageBox.yesNo(
+res = EricMessageBox.yesNo(
 self.parent(),
 self.tr("Bisect"),
 self.tr("""The project should be reread. Do this now?"""),
 yesDefault=True)
 if res:
 shouldReopen = (
 self.vcs.gitBisectReplay(self.project.getProjectPath()) or
 QFileInfo(pfile).lastModified().toString() != lastModified
 )
 if shouldReopen:
-res = E5MessageBox.yesNo(
+res = EricMessageBox.yesNo(
 self.parent(),
 self.tr("Bisect"),
 self.tr("""The project should be reread. Do this now?"""),
 yesDefault=True)
 if res:
 """
 pfile = self.project.getProjectFile()
 lastModified = QFileInfo(pfile).lastModified().toString()
 self.vcs.gitApplyCheckPatches(self.project.getProjectPath())
 if QFileInfo(pfile).lastModified().toString() != lastModified:
-res = E5MessageBox.yesNo(
+res = EricMessageBox.yesNo(
 self.parent(),
 self.tr("Apply patch files"),
 self.tr("""The project should be reread. Do this now?"""),
 yesDefault=True)
 if res:

Mercurial Repositories > eric / file comparison

comparison: eric7/Plugins/VcsPlugins/vcsGit/ProjectHelper.py

eric7/Plugins/VcsPlugins/vcsGit/ProjectHelper.py