/GitUI/GitUICommands.cs

Large files files are truncated, but you can click here to view the full file

using System;
using System.Collections.Generic;
using System.Drawing;
using System.IO;
using System.Linq;
using System.Windows.Forms;
using GitCommands;
using GitUI.CommandsDialogs;
using GitUI.CommandsDialogs.RepoHosting;
using GitUI.CommandsDialogs.SettingsDialog;
using GitUIPluginInterfaces;
using GitUIPluginInterfaces.RepositoryHosts;
using Gravatar;
using Settings = GitCommands.AppSettings;

namespace GitUI
{
    /// <summary>Contains methods to invoke GitEx forms, dialogs, etc.</summary>
    public sealed class GitUICommands : IGitUICommands
    {
        public GitUICommands(GitModule module)
        {
            Module = module;
            RepoChangedNotifier = new ActionNotifier(
                () => InvokeEvent(null, PostRepositoryChanged));
        }

        public GitUICommands(string workingDir)
            : this(new GitModule(workingDir)) { }

        #region IGitUICommands Members

        public event GitUIEventHandler PreBrowse;
        public event GitUIEventHandler PostBrowse;

        public event GitUIEventHandler PreDeleteBranch;
        public event GitUIPostActionEventHandler PostDeleteBranch;

        public event GitUIEventHandler PreCheckoutRevision;
        public event GitUIPostActionEventHandler PostCheckoutRevision;

        public event GitUIEventHandler PreCheckoutBranch;
        public event GitUIPostActionEventHandler PostCheckoutBranch;

        public event GitUIEventHandler PreFileHistory;
        public event GitUIPostActionEventHandler PostFileHistory;

        public event GitUIEventHandler PreCompareRevisions;
        public event GitUIPostActionEventHandler PostCompareRevisions;

        public event GitUIEventHandler PreAddFiles;
        public event GitUIPostActionEventHandler PostAddFiles;

        public event GitUIEventHandler PreCreateBranch;
        public event GitUIPostActionEventHandler PostCreateBranch;

        public event GitUIEventHandler PreClone;
        public event GitUIPostActionEventHandler PostClone;

        public event GitUIEventHandler PreSvnClone;
        public event GitUIPostActionEventHandler PostSvnClone;

        public event GitUIEventHandler PreCommit;
        public event GitUIPostActionEventHandler PostCommit;

        public event GitUIEventHandler PreSvnDcommit;
        public event GitUIPostActionEventHandler PostSvnDcommit;

        public event GitUIEventHandler PreSvnRebase;
        public event GitUIPostActionEventHandler PostSvnRebase;

        public event GitUIEventHandler PreSvnFetch;
        public event GitUIPostActionEventHandler PostSvnFetch;

        public event GitUIEventHandler PreInitialize;
        public event GitUIPostActionEventHandler PostInitialize;

        public event GitUIEventHandler PrePush;
        public event GitUIPostActionEventHandler PostPush;

        public event GitUIEventHandler PrePull;
        public event GitUIPostActionEventHandler PostPull;

        public event GitUIEventHandler PreViewPatch;
        public event GitUIPostActionEventHandler PostViewPatch;

        public event GitUIEventHandler PreApplyPatch;
        public event GitUIPostActionEventHandler PostApplyPatch;

        public event GitUIEventHandler PreFormatPatch;
        public event GitUIPostActionEventHandler PostFormatPatch;

        public event GitUIEventHandler PreStash;
        public event GitUIPostActionEventHandler PostStash;

        public event GitUIEventHandler PreResolveConflicts;
        public event GitUIPostActionEventHandler PostResolveConflicts;

        public event GitUIEventHandler PreCherryPick;
        public event GitUIPostActionEventHandler PostCherryPick;

        public event GitUIEventHandler PreRevertCommit;
        public event GitUIPostActionEventHandler PostRevertCommit;

        public event GitUIEventHandler PreMergeBranch;
        public event GitUIPostActionEventHandler PostMergeBranch;

        public event GitUIEventHandler PreCreateTag;
        public event GitUIPostActionEventHandler PostCreateTag;

        public event GitUIEventHandler PreDeleteTag;
        public event GitUIPostActionEventHandler PostDeleteTag;

        public event GitUIEventHandler PreEditGitIgnore;
        public event GitUIPostActionEventHandler PostEditGitIgnore;

        public event GitUIEventHandler PreSettings;
        public event GitUIPostActionEventHandler PostSettings;

        public event GitUIEventHandler PreArchive;
        public event GitUIPostActionEventHandler PostArchive;

        public event GitUIEventHandler PreMailMap;
        public event GitUIPostActionEventHandler PostMailMap;

        public event GitUIEventHandler PreVerifyDatabase;
        public event GitUIPostActionEventHandler PostVerifyDatabase;

        public event GitUIEventHandler PreRemotes;
        public event GitUIPostActionEventHandler PostRemotes;

        public event GitUIEventHandler PreRebase;
        public event GitUIPostActionEventHandler PostRebase;

        public event GitUIEventHandler PreRename;
        public event GitUIPostActionEventHandler PostRename;

        public event GitUIEventHandler PreSubmodulesEdit;
        public event GitUIPostActionEventHandler PostSubmodulesEdit;

        public event GitUIEventHandler PreUpdateSubmodules;
        public event GitUIPostActionEventHandler PostUpdateSubmodules;

        public event GitUIEventHandler PreSyncSubmodules;
        public event GitUIPostActionEventHandler PostSyncSubmodules;

        public event GitUIEventHandler PreBlame;
        public event GitUIPostActionEventHandler PostBlame;

        public event GitUIEventHandler PreEditGitAttributes;
        public event GitUIPostActionEventHandler PostEditGitAttributes;

        public event GitUIEventHandler PreBrowseInitialize;
        public event GitUIEventHandler PostBrowseInitialize;
        /// <summary>
        /// listeners for changes being made to repository
        /// </summary>
        public event GitUIEventHandler PostRepositoryChanged;

        public event GitUIEventHandler PostRegisterPlugin;

        public ILockableNotifier RepoChangedNotifier { get; private set; }
        public IBrowseRepo BrowseRepo { get; set; }

        #endregion

        public string GitCommand(string arguments)
        {
            return Module.RunGitCmd(arguments);
        }

        public string CommandLineCommand(string cmd, string arguments)
        {
            return Module.RunCmd(cmd, arguments);
        }

        private bool RequiresValidWorkingDir(object owner)
        {
            if (!Module.IsValidGitWorkingDir())
            {
                MessageBoxes.NotValidGitDirectory(owner as IWin32Window);
                return false;
            }

            return true;
        }

        private bool RequiredValidGitSvnWorikingDir(object owner)
        {
            if (!RequiresValidWorkingDir(owner))
                return false;

            if (!GitSvnCommandHelpers.ValidSvnWorkingDir(Module))
            {
                MessageBoxes.NotValidGitSVNDirectory(owner as IWin32Window);
                return false;
            }

            if (!GitSvnCommandHelpers.CheckRefsRemoteSvn(Module))
            {
                MessageBoxes.UnableGetSVNInformation(owner as IWin32Window);
                return false;
            }

            return true;
        }

        public void CacheAvatar(string email)
        {
            FallBackService gravatarFallBack = FallBackService.Identicon;
            try
            {
                gravatarFallBack =
                    (FallBackService)Enum.Parse(typeof(FallBackService), Settings.GravatarFallbackService);
            }
            catch
            {
                Settings.GravatarFallbackService = gravatarFallBack.ToString();
            }
            GravatarService.CacheImage(email + ".png", email, Settings.AuthorImageSize,
                gravatarFallBack);
        }

        public Icon FormIcon { get { return GitExtensionsForm.ApplicationIcon; } } 

        public bool StartBatchFileProcessDialog(object owner, string batchFile)
        {
            string tempFileName = Path.ChangeExtension(Path.GetTempFileName(), ".cmd");
            using (var writer = new StreamWriter(tempFileName))
            {
                writer.WriteLine("@prompt $G");
                writer.Write(batchFile);
            }
            FormProcess.ShowDialog(owner as IWin32Window, Module, "cmd.exe", "/C \"" + tempFileName + "\"");
            File.Delete(tempFileName);
            return true;
        }

        public bool StartBatchFileProcessDialog(string batchFile)
        {
            return StartBatchFileProcessDialog(null, batchFile);
        }

        public bool StartCommandLineProcessDialog(GitCommand cmd, IWin32Window parentForm)
        {
            bool executed;

            if (cmd.AccessesRemote())
                executed = FormRemoteProcess.ShowDialog(parentForm, Module, cmd.ToLine());
            else
                executed = FormProcess.ShowDialog(parentForm, Module, cmd.ToLine());

            if (executed && cmd.ChangesRepoState())
                RepoChangedNotifier.Notify();

            return executed;
        }

        public bool StartCommandLineProcessDialog(object owner, string command, string arguments)
        {
            FormProcess.ShowDialog(owner as IWin32Window, Module, command, arguments);
            return true;
        }

        public bool StartCommandLineProcessDialog(string command, string arguments)
        {
            return StartCommandLineProcessDialog(null, command, arguments);
        }

        public bool StartGitCommandProcessDialog(IWin32Window owner, string arguments)
        {
            FormProcess.ShowDialog(owner, Module, arguments);
            return true;
        }

        public bool StartGitCommandProcessDialog(string arguments)
        {
            return StartGitCommandProcessDialog(null, arguments);
        }

        public bool StartBrowseDialog()
        {
            return StartBrowseDialog("");
        }

        public bool StartDeleteBranchDialog(IWin32Window owner, string branch)
        {
            return DoActionOnRepo(owner, true, false, PreDeleteBranch, PostDeleteBranch, () =>
                {
                    using (var form = new FormDeleteBranch(this, branch))
                        form.ShowDialog(owner);
                    return true;
                }
            );
        }

        public bool StartDeleteBranchDialog(string branch)
        {
            return StartDeleteBranchDialog(null, branch);
        }

        public bool StartCheckoutRevisionDialog(IWin32Window owner, string revision = null)
        {
            return DoActionOnRepo(owner, true, true, PreCheckoutRevision, PostCheckoutRevision, () =>
                {
                    using (var form = new FormCheckoutRevision(this))
                    {
                        form.SetRevision(revision);
                        return form.ShowDialog(owner) == DialogResult.OK;
                    }
                }
            );
        }

        public bool StartCheckoutRevisionDialog()
        {
            return StartCheckoutRevisionDialog(null);
        }

        public bool StashSave(IWin32Window owner, bool includeUntrackedFiles, bool keepIndex = false, string message = "")
        {
            Func<bool> action = () =>
            {
                var arguments = GitCommandHelpers.StashSaveCmd(includeUntrackedFiles, keepIndex, message);
                FormProcess.ShowDialog(owner, Module, arguments);
                return true;
            };

            return DoActionOnRepo(owner, true, true, null, null, action);
        }

        public bool StashPop(IWin32Window owner)
        {
            Func<bool> action = () =>
            {
                FormProcess.ShowDialog(owner, Module, "stash pop");
                MergeConflictHandler.HandleMergeConflicts(this, owner, false, false);
                return true;
            };

            return DoActionOnRepo(owner, true, true, null, null, action);
        }

        /// <summary>Creates and checks out a new branch starting from the commit at which the stash was originally created.
        /// Applies the changes recorded in the stash to the new working directory and index.</summary>
        public bool StashBranch(IWin32Window owner, string branchName, string stash = null)
        {
            Func<bool> action = () =>
            {
                FormProcess.ShowDialog(owner, Module, "stash branch " + branchName.Quote().Combine(" ", stash.QuoteNE()));
                return true;
            };

            return DoActionOnRepo(owner, true, true, null, null, action);
        }


        public bool StashDrop(IWin32Window owner, string stashName)
        {
            Func<bool> action = () =>
            {
                FormProcess.ShowDialog(owner, Module, "stash drop " + stashName.Quote());
                return true;
            };

            return DoActionOnRepo(owner, true, true, null, null, action);
        }

        public bool StashApply(IWin32Window owner, string stashName)
        {
            Func<bool> action = () =>
            {
                FormProcess.ShowDialog(owner, Module, "stash apply " + stashName.Quote());
                MergeConflictHandler.HandleMergeConflicts(this, owner, false, false);
                return true;
            };

            return DoActionOnRepo(owner, true, true, null, null, action);
        }

        public void InvokeEventOnClose(Form form, GitUIEventHandler ev)
        {
            form.FormClosed += (object o, FormClosedEventArgs ea) =>
            {
                InvokeEvent(form == null ? null : form.Owner, ev);
            };

        }

        public void ShowModelessForm(IWin32Window owner, bool requiresValidWorkingDir, 
            GitUIEventHandler preEvent, GitUIPostActionEventHandler postEvent, Func<Form> provideForm)
        {
            if (requiresValidWorkingDir && !RequiresValidWorkingDir(owner))
                return;

            if (!InvokeEvent(owner, preEvent))
                return;

            Form form = provideForm();

            FormClosedEventHandler formClosed = null;

            formClosed = (sender, e) =>
                {
                    form.FormClosed -= formClosed;
                    InvokePostEvent(owner, true, postEvent);
                };

            form.FormClosed += formClosed;
            form.ShowInTaskbar = true;

            if (Application.OpenForms.Count > 0)
                form.Show();
            else
                form.ShowDialog();
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="requiresValidWorkingDir">If action requires valid working directory</param>
        /// <param name="owner">Owner window</param>
        /// <param name="changesRepo">if successfuly done action changes repo state</param>
        /// <param name="preEvent">Event invoked before performing action</param>
        /// <param name="postEvent">Event invoked after performing action</param>
        /// <param name="action">Action to do. Return true to indicate that the action was successfully done.</param>
        /// <returns>true if action was successfully done, false otherwise</returns>
        public bool DoActionOnRepo(IWin32Window owner, bool requiresValidWorkingDir, bool changesRepo, 
            GitUIEventHandler preEvent, GitUIPostActionEventHandler postEvent, Func<bool> action)
        {
            bool actionDone = false;            
            RepoChangedNotifier.Lock();
            try
            {
                if (requiresValidWorkingDir && !RequiresValidWorkingDir(owner))
                    return false;

                if (!InvokeEvent(owner, preEvent))
                    return false;
                try
                {
                    actionDone = action();
                }
                finally
                {
                    InvokePostEvent(owner, actionDone, postEvent);
                }
            }
            finally
            {
                RepoChangedNotifier.UnLock(changesRepo && actionDone);
            }

            return actionDone;
        }

        public void DoActionOnRepo(Action action) 
        {
            Func<bool> fnc = () =>
                {
                    action();
                    return true;
                };
            DoActionOnRepo(null, false, false, null, null, fnc);
        }

        public bool DoActionOnRepo(Func<bool> action)
        {
            return DoActionOnRepo(null, false, true, null, null, action);
        }

        #region Checkout

        public bool StartCheckoutBranch(IWin32Window owner, string branch, bool remote, string[] containRevisons)
        {
            return DoActionOnRepo(owner, true, true, PreCheckoutBranch, PostCheckoutBranch, () =>
            {
                using (var form = new FormCheckoutBranch(this, branch, remote, containRevisons))
                    return form.DoDefaultActionOrShow(owner) != DialogResult.Cancel;
            }
            );
        }

        public bool StartCheckoutBranch(IWin32Window owner, string branch, bool remote)
        {
            return StartCheckoutBranch(owner, branch, remote, null);
        }

        public bool StartCheckoutBranch(IWin32Window owner, string[] containRevisons)
        {
            return StartCheckoutBranch(owner, "", false, containRevisons);
        }

        public bool StartCheckoutBranch(IWin32Window owner)
        {
            return StartCheckoutBranch(owner, "", false, null);
        }

        public bool StartCheckoutBranch(string branch, bool remote)
        {
            return StartCheckoutBranch(null, branch, remote, null);
        }

        public bool StartCheckoutBranch()
        {
            return StartCheckoutBranch(null, "", false, null);
        }

        public bool StartCheckoutRemoteBranch(IWin32Window owner, string branch)
        {
            return StartCheckoutBranch(owner, branch, true);
        }

        #endregion Checkout

        public bool StartCompareRevisionsDialog(IWin32Window owner)
        {
            Func<bool> action = () =>
            {
                using (var form = new FormLog(this))
                {
                    return form.ShowDialog(owner) == DialogResult.OK;
                }
            };

            return DoActionOnRepo(owner, true, true, PreCompareRevisions, PostCompareRevisions, action);
        }

        public bool StartCompareRevisionsDialog()
        {
            return StartCompareRevisionsDialog(null);
        }

        public bool StartAddFilesDialog(IWin32Window owner, string addFiles)
        {
            return DoActionOnRepo(owner, true, true, PreAddFiles, PostAddFiles, () =>
            {
                using (var form = new FormAddFiles(this, addFiles))
                    form.ShowDialog(owner);

                return true;
            }
            );
        }

        public bool StartAddFilesDialog(IWin32Window owner)
        {
            return StartAddFilesDialog(owner, null);
        }

        public bool StartAddFilesDialog(string addFiles)
        {
            return StartAddFilesDialog(null, addFiles);
        }

        public bool StartAddFilesDialog()
        {
            return StartAddFilesDialog(null, null);
        }

        public bool StartCreateBranchDialog(IWin32Window owner, GitRevision revision)
        {
            Func<bool> action = () =>
            {
                using (var form = new FormCreateBranch(this, revision))
                {
                    return form.ShowDialog(owner) == DialogResult.OK;
                }
            };

            return DoActionOnRepo(owner, true, true, PreCreateBranch, PostCreateBranch, action);
        }

        public bool StartCreateBranchDialog()
        {
            return StartCreateBranchDialog(null, null);
        }

        public bool StartCloneDialog(IWin32Window owner, string url, bool openedFromProtocolHandler, GitModuleChangedEventHandler GitModuleChanged)
        {
            Func<bool> action = () =>
            {
                using (var form = new FormClone(this, url, openedFromProtocolHandler, GitModuleChanged))
                    form.ShowDialog(owner);
                return true;
            };

            return DoActionOnRepo(owner, false, false, PreClone, PostClone, action);
        }

        public bool StartCloneDialog(IWin32Window owner, string url, GitModuleChangedEventHandler GitModuleChanged)
        {
            return StartCloneDialog(owner, url, false, GitModuleChanged);
        }

        public bool StartCloneDialog(IWin32Window owner, string url)
        {
            return StartCloneDialog(owner, url, false, null);
        }

        public bool StartCloneDialog(IWin32Window owner)
        {
            return StartCloneDialog(owner, null, false, null);
        }

        public bool StartCloneDialog(string url)
        {
            return StartCloneDialog(null, url, false, null);
        }

        public bool StartCloneDialog()
        {
            return StartCloneDialog(null, null, false, null);
        }

        public bool StartSvnCloneDialog(IWin32Window owner, GitModuleChangedEventHandler GitModuleChanged)
        {
            Func<bool> action = () =>
            {
                using (var form = new FormSvnClone(this, GitModuleChanged))
                    form.ShowDialog(owner);
                return true;
            };

            return DoActionOnRepo(owner, false, false, PreSvnClone, PostSvnClone, action);
        }

        public bool StartSvnCloneDialog()
        {
            return StartSvnCloneDialog(null, null);
        }

        public void StartCleanupRepositoryDialog(IWin32Window owner = null, string path = null)
        {
            using (var form = new FormCleanupRepository(this))
            {
                form.SetPathArgument(path);
                form.ShowDialog(owner);
            }
        }

        public bool StartSquashCommitDialog(IWin32Window owner, GitRevision revision)
        {
            Func<bool> action = () =>
            {
                using (var form = new FormCommit(this, CommitKind.Squash, revision))
                {
                    form.ShowDialog(owner);
                }
                return true;
            };

            return DoActionOnRepo(action);
        }

        public bool StartFixupCommitDialog(IWin32Window owner, GitRevision revision)
        {
            Func<bool> action = () =>
            {
                using (var form = new FormCommit(this, CommitKind.Fixup, revision))
                {
                    form.ShowDialog(owner);
                }
                return true;
            };

            return DoActionOnRepo(action);
        }

        public bool StartCommitDialog(IWin32Window owner, bool showOnlyWhenChanges)
        {
            Func<bool> action = () =>
            {
                using (var form = new FormCommit(this))
                {
                    if (showOnlyWhenChanges)
                        form.ShowDialogWhenChanges(owner);
                    else
                        form.ShowDialog(owner);
                }
                return true;
            };

            return DoActionOnRepo(owner, true, false, PreCommit, PostCommit, action);
        }

        public bool StartCommitDialog(IWin32Window owner)
        {
            return StartCommitDialog(owner, false);
        }

        public bool StartCommitDialog(bool showOnlyWhenChanges)
        {
            return StartCommitDialog(null, showOnlyWhenChanges);
        }

        public bool StartCommitDialog()
        {
            return StartCommitDialog(null, false);
        }

        public bool StartSvnDcommitDialog(IWin32Window owner)
        {
            Func<bool> action = () =>
            {
                return FormProcess.ShowDialog(owner, Module, Settings.GitCommand, GitSvnCommandHelpers.DcommitCmd());
            };

            return DoActionOnRepo(owner, true, true, PreSvnDcommit, PostSvnDcommit, action);
        }

        public bool StartSvnDcommitDialog()
        {
            return StartSvnDcommitDialog(null);
        }

        public bool StartSvnRebaseDialog(IWin32Window owner)
        {
            Func<bool> action = () =>
            {
                FormProcess.ShowDialog(owner, Module, Settings.GitCommand, GitSvnCommandHelpers.RebaseCmd());
                return true;
            };

            return DoActionOnRepo(owner, true, true, PreSvnRebase, PostSvnRebase, action);
        }

        public bool StartSvnRebaseDialog()
        {
            return StartSvnRebaseDialog(null);
        }

        public bool StartSvnFetchDialog(IWin32Window owner)
        {
            Func<bool> action = () =>
            {
                return FormProcess.ShowDialog(owner, Module, Settings.GitCommand, GitSvnCommandHelpers.FetchCmd());
            };

            return DoActionOnRepo(owner, true, true, PreSvnFetch, PostSvnFetch, action);
        }

        public bool StartSvnFetchDialog()
        {
            return StartSvnFetchDialog(null);
        }

        public bool StartInitializeDialog(IWin32Window owner, GitModuleChangedEventHandler GitModuleChanged)
        {
            return StartInitializeDialog(owner, null, GitModuleChanged);
        }

        public bool StartInitializeDialog()
        {
            return StartInitializeDialog((IWin32Window)null, null);
        }

        public bool StartInitializeDialog(IWin32Window owner, string dir, GitModuleChangedEventHandler GitModuleChanged)
        {
            Func<bool> action = () =>
            {
                if (dir == null)
                    dir = Module.IsValidGitWorkingDir() ? Module.WorkingDir : string.Empty;
                using (var frm = new FormInit(dir, GitModuleChanged)) frm.ShowDialog(owner);
                return true;
            };

            return DoActionOnRepo(owner, false, true, PreInitialize, PostInitialize, action);
        }

        public bool StartInitializeDialog(string dir)
        {
            return StartInitializeDialog(null, dir, null);
        }

        /// <summary>
        /// Starts pull dialog
        /// </summary>
        /// <param name="owner">An implementation of IWin32Window that will own the modal dialog box.</param>
        /// <param name="pullOnShow"></param>
        /// <param name="pullCompleted">true if pull completed with no errors</param>
        /// <returns>if revision grid should be refreshed</returns>
        public bool StartPullDialog(IWin32Window owner, bool pullOnShow, string remoteBranch, string remote, out bool pullCompleted, bool fetchAll)
        {
            var pulled = false;

            Func<bool> action = () =>
            {
                using (FormPull formPull = new FormPull(this, remoteBranch, remote))
                {
                    if (fetchAll)
                        formPull.SetForFetchAll();

                    DialogResult dlgResult;
                    if (pullOnShow)
                        dlgResult = formPull.PullAndShowDialogWhenFailed(owner);
                    else
                        dlgResult = formPull.ShowDialog(owner);

                    if (dlgResult == DialogResult.OK)
                    {
                        pulled = !formPull.ErrorOccurred;
                    }

                    return dlgResult == DialogResult.OK;
                }
            };

            bool done = DoActionOnRepo(owner, true, true, PrePull, PostPull, action);

            pullCompleted = pulled;

            return done;
        }

        public bool StartPullDialog(IWin32Window owner, bool pullOnShow, out bool pullCompleted, bool fetchAll)
        {
            return StartPullDialog(owner, pullOnShow, null, null, out pullCompleted, fetchAll);
        }

        public bool StartPullDialog(IWin32Window owner, bool pullOnShow, out bool pullCompleted)
        {
            return StartPullDialog(owner, pullOnShow, out pullCompleted, false);
        }

        public bool StartPullDialog(IWin32Window owner, bool pullOnShow)
        {
            bool errorOccurred;
            return StartPullDialog(owner, pullOnShow, out errorOccurred, false);
        }

        public bool StartPullDialog(bool pullOnShow, out bool pullCompleted)
        {
            return StartPullDialog(null, pullOnShow, out pullCompleted, false);
        }

        public bool StartPullDialog(bool pullOnShow, string remoteBranch, out bool pullCompleted)
        {
            return StartPullDialog(null, pullOnShow, remoteBranch, null, out pullCompleted, false);
        }

        public bool StartPullDialog(bool pullOnShow)
        {
            return StartPullDialog(pullOnShow, null);
        }

        public bool StartPullDialog(bool pullOnShow, string remoteBranch)
        {
            bool errorOccurred;
            return StartPullDialog(pullOnShow, remoteBranch, out errorOccurred);
        }

        public bool StartPullDialog(IWin32Window owner)
        {
            bool errorOccurred;
            return StartPullDialog(owner, false, out errorOccurred, false);
        }

        public bool StartPullDialog()
        {
            return StartPullDialog(false);
        }

        public bool StartViewPatchDialog(IWin32Window owner, string patchFile)
        {
            Func<bool> action = () =>
            {
                using (var viewPatch = new FormViewPatch(this))
                {
                    if (!String.IsNullOrEmpty(patchFile))
                        viewPatch.LoadPatch(patchFile);
                    viewPatch.ShowDialog(owner);
                }
                return true;
            };

            return DoActionOnRepo(owner, false, false, PreViewPatch, PostViewPatch, action);
        }

        public bool StartViewPatchDialog(string patchFile)
        {
            return StartViewPatchDialog(null, patchFile);
        }

        public bool StartViewPatchDialog(IWin32Window owner)
        {
            return StartViewPatchDialog(owner, null);
        }

        public bool StartViewPatchDialog()
        {
            return StartViewPatchDialog(null, null);
        }

        public bool StartFormatPatchDialog(IWin32Window owner)
        {
            Func<bool> action = () =>
            {
                using (var form = new FormFormatPatch(this))
                    form.ShowDialog(owner);

                return true;
            };

            return DoActionOnRepo(owner, true, false, PreFormatPatch, PostFormatPatch, action);
        }

        public bool StartFormatPatchDialog()
        {
            return StartFormatPatchDialog(null);
        }

        public bool StartStashDialog(IWin32Window owner)
        {
            Func<bool> action = () =>
            {
                using (var form = new FormStash(this))
                    form.ShowDialog(owner);

                return true;
            };

            return DoActionOnRepo(owner, true, false, PreStash, PostStash, action);
        }

        public bool StartStashDialog()
        {
            return StartStashDialog(null);
        }

        public bool StartResetChangesDialog(IWin32Window owner)
        {
            var unstagedFiles = Module.GetUnstagedFiles();
            return StartResetChangesDialog(owner, unstagedFiles, false);
        }

        public bool StartResetChangesDialog(IWin32Window owner, IEnumerable<GitItemStatus> unstagedFiles, bool onlyUnstaged)
        {
            // Show a form asking the user if they want to reset the changes.
            FormResetChanges.ActionEnum resetAction = FormResetChanges.ShowResetDialog(owner, unstagedFiles.Any(item => !item.IsNew), unstagedFiles.Any(item => item.IsNew));

            if (resetAction == FormResetChanges.ActionEnum.Cancel)
            {
                return false;
            }

            Func<bool> action = () =>
            {
                if (onlyUnstaged)
                    Module.RunGitCmd("checkout -- .");
                else
                    // Reset all changes.
                    Module.ResetHard("");

                if (resetAction == FormResetChanges.ActionEnum.ResetAndDelete)
                    Module.RunGitCmd("clean -df");

                return true;
            };

            return DoActionOnRepo(owner, true, true, null, null, action);
        }

        public bool StartResetChangesDialog(IWin32Window owner, string fileName)
        {
            // Show a form asking the user if they want to reset the changes.
            FormResetChanges.ActionEnum resetAction = FormResetChanges.ShowResetDialog(owner, true, false);

            if (resetAction == FormResetChanges.ActionEnum.Cancel)
            {
                return false;
        }

            Cursor.Current = Cursors.WaitCursor;

            // Reset all changes.
            Module.ResetFile(fileName);

            // Also delete new files, if requested.
            if (resetAction == FormResetChanges.ActionEnum.ResetAndDelete)
            {
                try
                {
                    string path = Path.Combine(Module.WorkingDir, fileName);
                    if (File.Exists(path))
                        File.Delete(path);
                    else
                        Directory.Delete(path, true);
                }
                catch (System.IO.IOException) { }
                catch (System.UnauthorizedAccessException) { }
            }

            Cursor.Current = Cursors.Default;

            return true;
        }

        public bool StartResetChangesDialog(string fileName)
        {
            return StartResetChangesDialog(null, fileName);
        }

        public bool StartResetChangesDialog()
        {
            return StartResetChangesDialog((IWin32Window) null);
        }

        public bool StartRevertCommitDialog(IWin32Window owner, GitRevision revision)
        {
            Func<bool> action = () =>
            {
                using (var form = new FormRevertCommit(this, revision))
                {
                    return form.ShowDialog(owner) == DialogResult.OK;
                }
            };

            return DoActionOnRepo(owner, true, true, PreRevertCommit, PostRevertCommit, action);
        }

        public bool StartResolveConflictsDialog(IWin32Window owner, bool offerCommit)
        {
            Func<bool> action = () =>
            {
                using (var form = new FormResolveConflicts(this, offerCommit))
                    form.ShowDialog(owner);

                return true;
            };

            return DoActionOnRepo(owner, true, true, PreResolveConflicts, PostResolveConflicts, action);
        }

        public bool StartResolveConflictsDialog(IWin32Window owner)
        {
            return StartResolveConflictsDialog(owner, true);
        }

        public bool StartResolveConflictsDialog(bool offerCommit)
        {
            return StartResolveConflictsDialog(null, offerCommit);
        }

        public bool StartResolveConflictsDialog()
        {
            return StartResolveConflictsDialog(null, true);
        }

        public bool StartCherryPickDialog(IWin32Window owner, GitRevision revision)
        {
            Func<bool> action = () =>
            {
                using (var form = new FormCherryPick(this, revision))
                {
                    return form.ShowDialog(owner) == DialogResult.OK;
                }
            };

            return DoActionOnRepo(owner, true, true, PreCherryPick, PostCherryPick, action);
        }

        public bool StartCherryPickDialog(IWin32Window owner, IEnumerable<GitRevision> revisions)
        {
            if (revisions == null)
                throw new ArgumentNullException("revisions");
            Func<bool> action = () =>
            {
                FormCherryPick prevForm = null;

                try
                {
                    bool repoChanged = false;

                    foreach (var r in revisions)
                    {
                        var frm = new FormCherryPick(this, r);
                        if (prevForm != null)
                        {
                            frm.CopyOptions(prevForm);
                            prevForm.Dispose();
                        }
                        prevForm = frm;
                        if (frm.ShowDialog(owner) == DialogResult.OK)
                            repoChanged = true;
                        else
                            return repoChanged;
                    }

                    return repoChanged;
                }
                finally
                {
                    if (prevForm != null)
                    {
                        prevForm.Dispose();
                    }
                }
            };

            return DoActionOnRepo(owner, true, true, PreCherryPick, PostCherryPick, action);
        }

        public bool StartCherryPickDialog(IWin32Window owner)
        {
            return StartCherryPickDialog(owner, (GitRevision)null);
        }

        public bool StartCherryPickDialog()
        {
            return StartCherryPickDialog(null);
        }

        /// <summary>Start Merge dialog, using the specified branch.</summary>
        /// <param name="owner">Owner of the dialog.</param>
        /// <param name="branch">Branch to merge into the current branch.</param>
        public bool StartMergeBranchDialog(IWin32Window owner, string branch)
        {

            Func<bool> action = () =>
            {
                using (var form = new FormMergeBranch(this, branch))
                    form.ShowDialog(owner);

                return true;
            };

            return DoActionOnRepo(owner, true, false, PreMergeBranch, PostMergeBranch, action);
        }

        /// <summary>Start Merge dialog, using the specified branch.</summary>
        /// <param name="branch">Branch to merge into the current branch.</param>
        public bool StartMergeBranchDialog(string branch)
        {
            return StartMergeBranchDialog(null, branch);
        }

        public bool StartCreateTagDialog(IWin32Window owner)
        {
            Func<bool> action = () =>
            {
                using (var form = new FormCreateTag(this, null))
                {
                    return form.ShowDialog(owner) == DialogResult.OK;
                }
            };

            return DoActionOnRepo(owner, true, true, PreCreateTag, PostCreateTag, action);
        }

        public bool StartCreateTagDialog()
        {
            return StartCreateTagDialog(null);
        }

        public bool StartDeleteTagDialog(IWin32Window owner, string tag)
        {
            Func<bool> action = () =>
            {
                using (var form = new FormDeleteTag(this, tag))
                {
                    return form.ShowDialog(owner) == DialogResult.OK;
                }

            };

            return DoActionOnRepo(owner, true, true, PreDeleteTag, PostDeleteTag, action);
        }

        public bool StartDeleteTagDialog(string tag)
        {
            return StartDeleteTagDialog(null, tag);
        }

        public bool StartDeleteTagDialog()
        {
            return StartDeleteTagDialog(null, "");
        }

        public bool StartEditGitIgnoreDialog(IWin32Window owner)
        {
            Func<bool> action = () =>
            {
                using (var form = new FormGitIgnore(this))
                    form.ShowDialog(owner);

                return true;
            };

            return DoActionOnRepo(owner, true, false, PreEditGitIgnore, PostEditGitIgnore, action);
        }

        public bool StartEditGitIgnoreDialog()
        {
            return StartEditGitIgnoreDialog(null);
        }

        public bool StartAddToGitIgnoreDialog(IWin32Window owner, params string[] filePattern)
        {

            Func<bool> action = () =>
            {
                using (var frm = new FormAddToGitIgnore(this, filePattern))
                    frm.ShowDialog(owner);

                return true;
            };

            return DoActionOnRepo(owner, true, false, PreEditGitIgnore, PostEditGitIgnore, action);
        }

        public bool StartSettingsDialog(IWin32Window owner, SettingsPageReference initialPage = null)
        {
            Func<bool> action = () =>
            {
                FormSettings.ShowSettingsDialog(this, owner, initialPage);

                return true;
            };

            return DoActionOnRepo(owner, false, true, PreSettings, PostSettings, action);
        }

        public bool StartSettingsDialog()
        {
            return StartSettingsDialog(null, null);
        }

        public bool StartSettingsDialog(IGitPlugin gitPlugin)
        {
            // TODO: how to pass the main dialog as owner of the SettingsDialog (first parameter):
            return StartSettingsDialog(null, new SettingsPageReferenceByPlugin(gitPlugin));
        }

        /// <summary>
        /// Open the archive dialog
        /// </summary>
        /// <param name="owner"></param>
        /// <param name="revision">Revision to create an archive from</param>
        /// <param name="revision2">Revision for differencial archive </param>
        /// <param name="path">Files path for archive</param>
        /// <returns></returns>
        public bool StartArchiveDialog(IWin32Window owner = null, GitRevision revision = null, GitRevision revision2 = null, string path = null)
        {
            return DoActionOnRepo(owner, true, false, PreArchive, PostArchive, () =>
                {
                    using (var form = new FormArchive(this))
                    {
                        form.SelectedRevision = revision;
                        form.SetDiffSelectedRevision(revision2);
                        form.SetPathArgument(path);
                        form.ShowDialog(owner);
                    }

                    return true;
                }
            );
        }

        public bool StartArchiveDialog()
        {
            return StartArchiveDialog(null);
        }

        public bool StartMailMapDialog(IWin32Window owner)
        {
            Func<bool> action = () =>
            {
                using (var form = new FormMailMap(this))
                    form.ShowDialog(owner);

                return true;
            };

            return DoActionOnRepo(owner, true, false, PreMailMap, PostMailMap, action);
        }

        public bool StartMailMapDialog()
        {
            return StartMailMapDialog(null);
        }

        public bool StartVerifyDatabaseDialog(IWin32Window owner)
        {
            Func<bool> action = () =>
            {
                using (var form = new FormVerify(this))
                    form.ShowDialog(owner);
                
                return true;
            };

            //TODO: move Notify to FormVerify and friends
            return DoActionOnRepo(owner, true, true, PreVerifyDatabase, PostVerifyDatabase, action);
        }

        public bool StartVerifyDatabaseDialog()
        {
            return StartVerifyDatabaseDialog(null);
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="owner"></param>
        /// <param name="preselectRemote">makes the FormRemotes initialially select the given remote</param>
        /// <returns></returns>
        public bool StartRemotesDialog(IWin32Window owner, string preselectRemote)
        {
            Func<bool> action = () =>
            {
                using (var form = new FormRemotes(this))
                {
                    form.PreselectRemoteOnLoad = preselectRemote;
                    form.ShowDialog(owner);
                }

                return true;
            };

            return DoActionOnRepo(owner, true, true, PreRemotes, PostRemotes, action);
        }

        public bool StartRemotesDialog(IWin32Window owner)
        {
            return StartRemotesDialog(owner, null);
        }

        public bool StartRemotesDialog()
        {
            return StartRemotesDialog(null);
        }

        public bool StartRebaseDialog(IWin32Window owner, string branch)
        {
            return StartRebaseDialog(owner, string.Empty, null, branch);
        }

        public bool StartRebaseDialog(IWin32Window owner, string from, string to, string onto)
        {
            Func<bool> action = () =>
            {
                using (var form = new FormRebase(this, from, to, onto))
                    form.ShowDialog(owner);

                return true;
            };

            return DoActionOnRepo(owner, true, true, PreRebase, PostRebase, action);
        }

        public bool StartRebaseDialog(string branch)
        {
            return StartRebaseDialog(null, branch);
        }


        public bool StartRenameDialog(string branch)
        {
            return StartRenameDialog(null, branch);
        }

        public bool StartRenameDialog(IWin32Window owner, string branch)
        {
            Func<bool> action = () =>
            {
                using (var form = new FormRenameBranch(this, branch))
                {

                    return form.ShowDialog(owner) == DialogResult.OK;
                }

            };

            return DoActionOnRepo(owner, true, true, PreRename, PostRename, action);
        }

        public bool StartSubmodulesDialog(IWin32Window owner)
        {
            Func<bool> action = () =>
            {
                using (var form = new FormSubmodules(this))
                    form.ShowDialog(owner);

                return true;
            };

            return DoActionOnRepo(owner, true, true, PreSubmodulesEdit, PostSubmodulesEdit, action);
        }

        public bool StartSubmodulesDialog()
        {
            return StartSubmodulesDialog(null);
        }

        public bool StartUpdateSubmodulesDialog(IWin32Window owner)
        {
            Func<bool> action = () =>
            {
                return FormProcess.ShowDialog(owner, Module, GitCommandHelpers.SubmoduleUpdateCmd(""));
            };

            return DoActionOnRepo(owner, true, true, PreUpdateSubmodules, PostUpdateSubmodules, action);
        }

        public bool StartUpdateSubmodulesDialog()
        {
            return StartUpdateSubmodulesDialog(null);
        }

        public bool StartSyncSubmodulesDialog(IWin32Window owner)
        {
            Func<bool> action = () =>
            {
                return FormProcess.ShowDialog(owner, Module, GitCommandHelpers.SubmoduleSyncCmd(""));
            };

            return DoActionOnRepo(owner, true, true, PreSyncSubmodules, PostSyncSubmodules, action);
        }

        public bool StartSyncSubmodulesDialog()
        {
            return StartSyncSubmodulesDialog(null);
        }

        public void UpdateSubmodules(IWin32Window win)
        {
            if (!Module.HasSubmodules())
                return;

            var updateSubmodules = AppSettings.UpdateSubmodulesOnCheckout ?? MessageBoxes.ConfirmUpdateSubmodules(win);

            if (updateSubmodules)
                StartUpdateSubmodulesDialog(win);
        }

        public bool StartPluginSettingsDialog(IWin32Window owner)
        {
            return StartSettingsDialog(owner, PluginsSettingsGroup.GetPageReference());
        }

        public bool StartPluginSettingsDialog()
        {
            return StartPluginSettingsDialog(null);
        }

        public bool StartRepoSettingsDialog(IWin32Window owner)
        {
            return StartSettingsDialog(owner, GitUI.CommandsDialogs.SettingsDialog.Pages.GitConfigSettingsPage.GetPageReference());
        }

        public bool StartBrowseDialog(IWin32Window owner, string filter)
        {
            if (!InvokeEvent(owner, PreBrowse))
                return false;

            var form = new FormBrowse(this, filter);
            Application.Run(form);

            InvokeEvent(owner, PostBrowse);

            return true;
        }

        public bool StartBrowseDialog(string filter)
        {
            return StartBrowseDialog(null, filter);
        }

        public void StartFileHistoryDialog(IWin32Window owner, string fileName, GitRevision revision, bool filterByRevision, bool showBlame)
        {
            Func<Form> provideForm = () =>
                {
                    var form = new FormFileHistory(this, fileName, revision, filterByRevision);

                    if (showBlame)
                        form.SelectBlameTab();

                    return form;
                };

            ShowModelessForm(owner, true, PreFileHistory, PostFileHistory, provideForm);
        }

        public void StartFileHistoryDialog(IWin32Window owner, string fileName, GitRevision revision, bool filterByRevision)
        {
            StartFileHistoryDialog(owner, fileName, revision, filterByRevision, false);
        }

        public void StartFileHistoryDialog(IWin32Window owner, string fileName, GitRevision revision)
        {
            StartFileHistoryDialog(owner, fileName, revision, false);
        }

        public void StartFileHistoryDialog(IWin32Window owner, string fileName)
        {
            StartFileHistoryDialog(owner, fileName, null, false);
        }

        public void StartFileHistoryDialog(string fileName, GitRevision revision)
        {
            StartFileHistoryDialog(null, fileName, revision, false);
        }

        public void StartFileHistoryDialog(string fileName)
        {
            StartFileHistoryDialog(fileName, null);
        }

        public bool StartPushDialog()
        {
    …

Large files files are truncated, but you can click here to view the full file