public override void OnExecute(CommandEventArgs e)
{
if (!SmartListView.SupportsGrouping)
return;
base.OnExecute(e);
}
public override void OnExecute(CommandEventArgs e)
{
WorkingCopyExplorerControl ctrl = e.Selection.ActiveDialogOrFrameControl as WorkingCopyExplorerControl;
if (ctrl != null)
ctrl.RemoveRoot();
}
public int Exec(ref Guid pguidCmdGroup, uint nCmdID, uint nCmdexecopt, IntPtr pvaIn, IntPtr pvaOut)
{
CommandID cd = new CommandID(pguidCmdGroup, unchecked((int)nCmdID));
List<CommandData> items;
if (!_data.TryGetValue(cd, out items))
return (int)Constants.OLECMDERR_E_NOTSUPPORTED;
foreach (CommandData d in items)
{
if (!d.Control.ContainsFocus)
continue;
CommandEventArgs ce = new CommandEventArgs((VisualGitCommand)cd.ID, GetService<VisualGitContext>());
if (d.UpdateHandler != null)
{
CommandUpdateEventArgs ud = new CommandUpdateEventArgs(ce.Command, ce.Context);
d.UpdateHandler(d.Control, ud);
if (!ud.Enabled)
return (int)Constants.OLECMDERR_E_DISABLED;
}
d.Handler(d.Control, ce);
return VSConstants.S_OK;
}
return (int)Constants.OLECMDERR_E_NOTSUPPORTED;
}
public override void OnExecute(CommandEventArgs e)
{
switch (e.Command)
{
case VisualGitCommand.ItemResolveMerge:
Resolved(e);
break;
case VisualGitCommand.ItemResolveMergeTool:
throw new NotSupportedException();
case VisualGitCommand.ItemResolveMineFull:
Resolve(e, GitAccept.MineFull);
break;
case VisualGitCommand.ItemResolveTheirsFull:
Resolve(e, GitAccept.TheirsFull);
break;
case VisualGitCommand.ItemResolveWorking:
Resolve(e, GitAccept.Merged);
break;
case VisualGitCommand.ItemResolveBase:
Resolve(e, GitAccept.Base);
break;
case VisualGitCommand.ItemResolveMineConflict:
throw new NotSupportedException();
//Resolve(e, GitAccept.Mine);
//break;
case VisualGitCommand.ItemResolveTheirsConflict:
throw new NotSupportedException();
//Resolve(e, GitAccept.Theirs);
//break;
default:
throw new NotSupportedException();
}
}
public override void OnExecute(CommandEventArgs e)
{
using (ProjectCommitDialog pcd = new ProjectCommitDialog())
{
pcd.Context = e.Context;
pcd.LogMessageText = storedLogMessage;
pcd.AmendLastCommit = storedAmendCommit;
pcd.PreserveWindowPlacement = true;
pcd.LoadItems(e.Selection.GetSelectedGitItems(true));
DialogResult dr = pcd.ShowDialog(e.Context);
storedLogMessage = pcd.LogMessageText;
storedAmendCommit = pcd.AmendLastCommit;
if (dr != DialogResult.OK)
return;
PendingChangeCommitArgs pca = new PendingChangeCommitArgs();
pca.StoreMessageOnError = true;
// TODO: Commit it!
List<PendingChange> toCommit = new List<PendingChange>(pcd.GetSelection());
pcd.FillArgs(pca);
e.GetService<IPendingChangeHandler>().Commit(toCommit, pca);
}
// not in the finally, because we want to preserve the message for a
// non-successful commit
storedLogMessage = null;
storedAmendCommit = false;
}
public void OnExecute(CommandEventArgs e)
{
PendingCommitsPage page = e.Context.GetService<PendingCommitsPage>();
if (page != null)
page.LogMessageVisible = !page.LogMessageVisible;
}
public override void OnExecute(CommandEventArgs e)
{
using (ProjectCommitDialog dlg = new ProjectCommitDialog())
{
dlg.Context = e.Context;
dlg.PreserveWindowPlacement = true;
dlg.LoadChanges(GetChanges(e));
dlg.LogMessageText = logMessage ?? "";
DialogResult dr = dlg.ShowDialog(e.Context);
logMessage = dlg.LogMessageText;
if (dr == DialogResult.OK)
{
PendingChangeCommitArgs pca = new PendingChangeCommitArgs();
pca.StoreMessageOnError = true;
// TODO: Commit it!
List<PendingChange> toCommit = new List<PendingChange>(dlg.GetSelection());
dlg.FillArgs(pca);
if (e.GetService<IPendingChangeHandler>().Commit(toCommit, pca))
{
logMessage = null;
}
}
}
}
protected override void OnExecute(SmartListView list, CommandEventArgs e)
{
bool extend = ((Control.ModifierKeys & Keys.Shift) != 0);
int n = (int)(e.Command - VisualGitCommand.ListViewSort0);
SmartColumn column = list.AllColumns[n];
if (list.SortColumns.Contains(column))
{
list.SortColumns.Remove(column);
list.UpdateSortGlyphs();
if (list.SortColumns.Count > 0)
list.Sort();
}
else if (!extend)
{
list.SortColumns.Clear();
list.SortColumns.Add(column);
list.UpdateSortGlyphs();
list.Sort();
}
else
{
list.SortColumns.Add(column);
list.UpdateSortGlyphs();
list.Sort();
}
}
public void OnExecute(CommandEventArgs e)
{
GitItem item = e.Argument as GitItem;
if (item == null)
return;
using(EditReadOnlyFileDialog dialog = new EditReadOnlyFileDialog(item))
{
switch(dialog.ShowDialog(e.Context))
{
case DialogResult.Yes:
// make writable and allow
FileAttributes attr = File.GetAttributes(item.FullPath);
File.SetAttributes(item.FullPath, attr & ~FileAttributes.ReadOnly);
e.Result = true;
break;
case DialogResult.No:
// Don't make writable but allow
e.Result = true;
break;
default:
// Don't make writeable and don't allow
e.Result = false;
break;
}
}
}
public void OnExecute(CommandEventArgs e)
{
PendingChangesPage page = GetPage(e);
if(page != null && page.CanRefreshList)
page.RefreshList();
}
public override void OnExecute(CommandEventArgs e)
{
List<GitOrigin> selected = new List<GitOrigin>();
IFileStatusCache cache = e.GetService<IFileStatusCache>();
switch (e.Command)
{
case VisualGitCommand.Log:
IVisualGitDiffHandler diffHandler = e.GetService<IVisualGitDiffHandler>();
List<GitOrigin> items = new List<GitOrigin>();
foreach (GitItem i in e.Selection.GetSelectedGitItems(false))
{
Debug.Assert(i.IsVersioned);
if (i.IsAdded)
{
if (!i.HasCopyableHistory)
continue;
items.Add(new GitOrigin(diffHandler.GetCopyOrigin(i), i.WorkingCopy.RepositoryRoot));
continue;
}
items.Add(new GitOrigin(i));
}
PerformLog(e.Context, items, null, null);
break;
case VisualGitCommand.SolutionHistory:
IVisualGitSolutionSettings settings = e.GetService<IVisualGitSolutionSettings>();
PerformLog(e.Context, new GitOrigin[] { new GitOrigin(cache[settings.ProjectRoot]) }, null, null);
break;
case VisualGitCommand.ProjectHistory:
IProjectFileMapper mapper = e.GetService<IProjectFileMapper>();
foreach (GitProject p in e.Selection.GetSelectedProjects(false))
{
IGitProjectInfo info = mapper.GetProjectInfo(p);
if (info != null)
selected.Add(new GitOrigin(cache[info.ProjectDirectory]));
}
PerformLog(e.Context, selected, null, null);
break;
case VisualGitCommand.DocumentHistory:
GitItem docItem = e.Selection.ActiveDocumentItem;
Debug.Assert(docItem != null);
PerformLog(e.Context, new GitOrigin[] { new GitOrigin(docItem) }, null, null);
break;
case VisualGitCommand.AnnotateShowLog:
IAnnotateSection section = EnumTools.GetSingle(e.Selection.GetSelection<IAnnotateSection>());
if (section == null)
return;
PerformLog(e.Context, new GitOrigin[] { section.Origin }, section.Revision, null);
break;
}
}
public override void OnExecute(CommandEventArgs e)
{
GitPushArgs args = new GitPushArgs();
string repositoryRoot;
var repositoryRoots = new HashSet<string>(FileSystemUtil.StringComparer);
foreach (var projectRoot in GetAllRoots(e))
{
if (
GitTools.TryGetRepositoryRoot(projectRoot.FullPath, out repositoryRoot) &&
!repositoryRoots.Contains(repositoryRoot)
)
repositoryRoots.Add(repositoryRoot);
}
if (repositoryRoots.Count > 1)
{
throw new InvalidOperationException("Pushing of multiple repository roots is not supported");
}
repositoryRoot = repositoryRoots.Single();
switch (e.Command)
{
case VisualGitCommand.PendingChangesPushSpecificBranch:
case VisualGitCommand.PendingChangesPushSpecificTag:
if (!QueryParameters(e, repositoryRoot, args))
return;
break;
}
ProgressRunnerArgs pa = new ProgressRunnerArgs();
pa.CreateLog = true;
pa.TransportClientArgs = args;
GitException exception = null;
e.GetService<IProgressRunner>().RunModal(CommandStrings.PushingSolution, pa,
delegate(object sender, ProgressWorkerArgs a)
{
using (var client = e.GetService<IGitClientPool>().GetNoUIClient())
{
try
{
client.Push(repositoryRoot, args);
}
catch (GitException ex)
{
exception = ex;
}
}
});
if (exception != null)
{
e.GetService<IVisualGitErrorHandler>().OnWarning(exception);
}
}
public void OnExecute(CommandEventArgs e)
{
ILogControl logWindow = e.Selection.GetActiveControl<ILogControl>();
if (PerformRevisionChanges(logWindow, e))
return;
PerformFileChanges(e);
}
public void OnExecute(CommandEventArgs e)
{
if(_skip) // Only show this message once!
return;
_skip = true;
VisualGitMessageBox mb = new VisualGitMessageBox(e.Context);
mb.Show(string.Format(Resources.UnsupportedWorkingCopyFound, e.Argument));
}
public void OnExecute(CommandEventArgs e)
{
ILogControl lc = e.Selection.GetActiveControl<ILogControl>();
if (lc == null)
return;
lc.FetchAll();
}
public virtual void OnExecute(CommandEventArgs e)
{
SmartListView list = GetListView(e);
if (list == null)
return;
OnExecute(list, e);
}
public void OnExecute(CommandEventArgs e)
{
ILogControl lc = e.Selection.GetActiveControl<ILogControl>();
if (lc == null)
return;
lc.ShowLogMessage = !lc.ShowLogMessage;
}
public override void OnExecute(CommandEventArgs e)
{
List<GitItem> toResolve = new List<GitItem>();
foreach (GitItem item in e.Selection.GetSelectedGitItems(false))
{
if (item.IsCasingConflicted)
{
toResolve.Add(item);
}
}
try
{
foreach (GitItem item in toResolve)
{
string svnPath = GetGitCasing(e, item);
string actualPath = GitTools.GetTruePath(item.FullPath);
if (svnPath == null || actualPath == null)
continue; // not found
if (!string.Equals(svnPath, actualPath, StringComparison.OrdinalIgnoreCase))
continue; // More than casing rename
string svnName = Path.GetFileName(svnPath);
string actualName = Path.GetFileName(actualPath);
if (svnName == actualName)
continue; // Can't fix directories!
IVisualGitOpenDocumentTracker odt = e.GetService<IVisualGitOpenDocumentTracker>();
using (odt.LockDocument(svnPath, DocumentLockType.NoReload))
using (odt.LockDocument(actualPath, DocumentLockType.NoReload))
{
try
{
// Try the actual rename
File.Move(actualPath, svnPath);
}
catch { }
try
{
// And try to fix the project+document system
VsShellUtilities.RenameDocument(e.Context, actualPath, svnPath);
}
catch
{ }
}
}
}
finally
{
e.GetService<IFileStatusMonitor>().ScheduleGitStatus(GitItem.GetPaths(toResolve));
}
}
public void OnExecute(CommandEventArgs e)
{
if (_commandService == null)
_commandService = e.GetService<IVisualGitCommandService>();
if (_pendingChanges == null)
_pendingChanges = e.GetService<PendingChangeManager>(typeof(IPendingChangesManager));
_commandService.TockCommand(e.Command);
_pendingChanges.OnTickRefresh();
}
public void OnExecute(CommandEventArgs e)
{
if (_commandService == null)
_commandService = e.GetService<IVisualGitCommandService>();
if (_projectNotifier == null)
_projectNotifier = e.GetService<ProjectNotifier>(typeof(IFileStatusMonitor));
_commandService.TockCommand(e.Command);
_projectNotifier.HandleEvent(e.Command);
}
public override void OnExecute(CommandEventArgs e)
{
IFileStatusCache cache = e.GetService<IFileStatusCache>();
if (cache == null || e.Selection.SolutionFilename == null)
return;
GitItem item = cache[e.Selection.SolutionFilename];
HandleUnmanagedOrUnversionedSolution(e, item);
}
protected override void OnExecute(SmartListView list, CommandEventArgs e)
{
bool value = (e.Command == VisualGitCommand.ListViewSortDescending);
foreach (SmartColumn sc in list.SortColumns)
{
sc.ReverseSort = value;
}
list.UpdateSortGlyphs();
list.Sort();
}
void OnPasteList(CommandEventArgs e, LogMessageEditor lme)
{
StringBuilder sb = new StringBuilder();
foreach (PendingChange pci in lme.PasteSource.PendingChanges)
{
sb.AppendFormat("* {0}", pci.RelativePath);
sb.AppendLine();
}
lme.PasteText(sb.ToString());
}
public override void OnExecute(CommandEventArgs e)
{
GitItem node = EnumTools.GetFirst(e.Selection.GetSelectedGitItems(false));
IVisualGitCommandService cmd = e.GetService<IVisualGitCommandService>();
switch (e.Command)
{
case VisualGitCommand.ItemSelectInWorkingCopyExplorer:
if (node == null || !node.Exists)
return;
if (cmd != null)
cmd.DirectlyExecCommand(VisualGitCommand.WorkingCopyBrowse, node.FullPath);
break;
case VisualGitCommand.ItemSelectInSolutionExplorer:
if (node == null)
return;
IVsUIHierarchyWindow hierWindow = VsShellUtilities.GetUIHierarchyWindow(e.Context, new Guid(ToolWindowGuids80.SolutionExplorer));
IVsProject project = VsShellUtilities.GetProject(e.Context, node.FullPath) as IVsProject;
if (hierWindow != null)
{
int found;
uint id;
VSDOCUMENTPRIORITY[] prio = new VSDOCUMENTPRIORITY[1];
if (project != null && ErrorHandler.Succeeded(project.IsDocumentInProject(node.FullPath, out found, prio, out id)) && found != 0)
{
hierWindow.ExpandItem(project as IVsUIHierarchy, id, EXPANDFLAGS.EXPF_SelectItem);
}
else if (string.Equals(node.FullPath, e.Selection.SolutionFilename, StringComparison.OrdinalIgnoreCase))
hierWindow.ExpandItem(e.GetService<IVsUIHierarchy>(typeof(SVsSolution)), VSConstants.VSITEMID_ROOT, EXPANDFLAGS.EXPF_SelectItem);
// Now try to activate the solution explorer
IVsWindowFrame solutionExplorer;
Guid solutionExplorerGuid = new Guid(ToolWindowGuids80.SolutionExplorer);
IVsUIShell shell = e.GetService<IVsUIShell>(typeof(SVsUIShell));
if (shell != null)
{
shell.FindToolWindow((uint)__VSFINDTOOLWIN.FTW_fForceCreate, ref solutionExplorerGuid, out solutionExplorer);
if (solutionExplorer != null)
solutionExplorer.Show();
}
}
break;
}
}
public void OnExecute(CommandEventArgs e)
{
if (_commandService == null)
_commandService = e.GetService<IVisualGitCommandService>();
if (_projectTracker == null)
_projectTracker = e.GetService<ProjectTracker>(typeof(IVisualGitProjectDocumentTracker));
if(_sccProvider == null)
_sccProvider = e.GetService<VisualGitSccProvider>(typeof(IVisualGitSccService));
_commandService.TockCommand(e.Command);
_projectTracker.OnSccCleanup(e);
_sccProvider.OnSccCleanup(e);
}
public void OnExecute(CommandEventArgs e)
{
PendingCommitsPage page = e.Context.GetService<PendingCommitsPage>();
if (page != null)
{
string fileName = GetFileName(e.Context.DialogOwner);
if (!string.IsNullOrEmpty(fileName))
{
page.DoCreatePatch(fileName);
}
}
}
public override void OnExecute(CommandEventArgs e)
{
string info;
if (e.Argument is string)
{
// Allow opening from
info = (string)e.Argument;
}
else if (e.Command == VisualGitCommand.WorkingCopyAdd)
{
using (AddWorkingCopyExplorerRootDialog dlg = new AddWorkingCopyExplorerRootDialog())
{
DialogResult dr = dlg.ShowDialog(e.Context);
if (dr != DialogResult.OK || string.IsNullOrEmpty(dlg.NewRoot))
return;
info = dlg.NewRoot;
}
}
else
throw new InvalidOperationException("WorkingCopyBrowse was called without a path");
if (!string.IsNullOrEmpty(info))
{
WorkingCopyExplorerControl ctrl = e.Selection.ActiveDialogOrFrameControl as WorkingCopyExplorerControl;
if (ctrl == null)
{
IVisualGitPackage pkg = e.GetService<IVisualGitPackage>();
pkg.ShowToolWindow(VisualGitToolWindow.WorkingCopyExplorer);
}
ctrl = e.Selection.ActiveDialogOrFrameControl as WorkingCopyExplorerControl;
if (ctrl != null)
{
switch (e.Command)
{
case VisualGitCommand.WorkingCopyAdd:
ctrl.AddRoot(info);
break;
case VisualGitCommand.WorkingCopyBrowse:
ctrl.BrowsePath(e.Context, info);
break;
}
}
}
}
public void OnExecute(CommandEventArgs e)
{
if (_commandService == null)
_commandService = e.GetService<IVisualGitCommandService>();
if (_fileCache == null)
_fileCache = e.GetService<FileStatusCache>(typeof(IFileStatusCache));
_commandService.TockCommand(e.Command);
if (e.Command == VisualGitCommand.FileCacheFinishTasks)
_fileCache.OnCleanup();
else
_fileCache.BroadcastChanges();
}
void OnPasteRecent(CommandEventArgs e, LogMessageEditor lme)
{
using (RecentMessageDialog rmd = new RecentMessageDialog())
{
rmd.Context = e.Context;
if (DialogResult.OK != rmd.ShowDialog(e.Context))
return;
string text = rmd.SelectedText;
if (!string.IsNullOrEmpty(text))
lme.PasteText(text);
}
}
public override void OnExecute(CommandEventArgs e)
{
PathSelectorResult result = ShowDialog(e);
if (!result.Succeeded)
return;
GitRevisionRange revRange = new GitRevisionRange(result.RevisionStart, result.RevisionEnd);
IVisualGitTempFileManager tempfiles = e.GetService<IVisualGitTempFileManager>();
string tempFile = tempfiles.GetTempFile(".patch");
IVisualGitSolutionSettings ss = e.GetService<IVisualGitSolutionSettings>();
string slndir = ss.ProjectRoot;
string slndirP = slndir + "\\";
GitDiffArgs args = new GitDiffArgs();
args.IgnoreAncestry = true;
args.NoDeleted = false;
args.Depth = result.Depth;
using (MemoryStream stream = new MemoryStream())
{
e.Context.GetService<IProgressRunner>().RunModal("Diffing",
delegate(object sender, ProgressWorkerArgs ee)
{
foreach (GitItem item in result.Selection)
{
GitWorkingCopy wc;
if (!string.IsNullOrEmpty(slndir) &&
item.FullPath.StartsWith(slndirP, StringComparison.OrdinalIgnoreCase))
args.RelativeToPath = slndir;
else if ((wc = item.WorkingCopy) != null)
args.RelativeToPath = wc.FullPath;
else
args.RelativeToPath = null;
ee.Client.Diff(item.FullPath, revRange, args, stream);
}
stream.Flush();
stream.Position = 0;
});
using (StreamReader sr = new StreamReader(stream))
{
File.WriteAllText(tempFile, sr.ReadToEnd(), Encoding.UTF8);
VsShellUtilities.OpenDocument(e.Context, tempFile);
}
}
}
