void ExecuteDiff(CommandEventArgs e, ICollection <SvnOrigin> targets, SvnRevisionRange range)
{
if (targets.Count != 1)
{
return;
}
SvnTarget diffTarget = EnumTools.GetSingle(targets).Target;
IAnkhDiffHandler diff = e.GetService <IAnkhDiffHandler>();
AnkhDiffArgs da = new AnkhDiffArgs();
string[] files = diff.GetTempFiles(diffTarget, range.StartRevision, range.EndRevision, true);
if (files == null)
{
return;
}
da.BaseFile = files[0];
da.MineFile = files[1];
da.BaseTitle = diff.GetTitle(diffTarget, range.StartRevision);
da.MineTitle = diff.GetTitle(diffTarget, range.EndRevision);
da.ReadOnly = true;
diff.RunDiff(da);
}
public override void OnExecute(CommandEventArgs e)
{
IAnkhDiffHandler diff = e.GetService <IAnkhDiffHandler>();
ISvnRepositoryItem reposItem = EnumTools.GetSingle(e.Selection.GetSelection <ISvnRepositoryItem>());
if (reposItem == null)
{
return;
}
SvnRevision from;
SvnRevision to;
if (reposItem.Revision == SvnRevision.Working)
{
from = SvnRevision.Base;
to = SvnRevision.Working;
}
else if (e.Command == AnkhCommand.RepositoryCompareWithWc)
{
from = reposItem.Revision;
to = SvnRevision.Working;
}
else
{
from = reposItem.Revision.Revision - 1;
to = reposItem.Revision;
}
AnkhDiffArgs da = new AnkhDiffArgs();
if (to == SvnRevision.Working)
{
da.BaseFile = diff.GetTempFile(reposItem.Origin.Target, from, true);
if (da.BaseFile == null)
{
return; // User canceled
}
da.MineFile = ((SvnPathTarget)reposItem.Origin.Target).FullPath;
}
else
{
string[] files = diff.GetTempFiles(reposItem.Origin.Target, from, to, true);
if (files == null)
{
return; // User canceled
}
da.BaseFile = files[0];
da.MineFile = files[1];
System.IO.File.SetAttributes(da.MineFile, System.IO.FileAttributes.ReadOnly | System.IO.FileAttributes.Normal);
}
da.BaseTitle = diff.GetTitle(reposItem.Origin.Target, from);
da.MineTitle = diff.GetTitle(reposItem.Origin.Target, to);
diff.RunDiff(da);
}
public bool RunDiff(AnkhDiffArgs args)
{
ThreadHelper.ThrowIfNotOnUIThread();
if (args == null)
{
throw new ArgumentNullException("args");
}
else if (!HasDiff)
{
throw new InvalidOperationException();
}
if (_ocw2 == null)
{
_ocw2 = GetInterfaceDelegate <OpenComparisonWindow2>(_type_IVsDifferenceService, _vsDifferenceService);
}
if (_ocw2 == null)
{
return(false);
}
uint flags = VSDIFFOPT_DetectBinaryFiles;
if (TempPath != null)
{
if (SvnItem.IsBelowRoot(args.BaseFile, TempPath))
{
flags |= VSDIFFOPT_LeftFileIsTemporary;
}
if (SvnItem.IsBelowRoot(args.MineFile, TempPath))
{
flags |= VSDIFFOPT_RightFileIsTemporary;
}
}
IVsWindowFrame frame = _ocw2(args.BaseFile, args.MineFile, args.Caption ?? args.MineTitle, "", args.BaseTitle, args.MineTitle, args.Label ?? "", null, flags);
if (frame != null)
{
GC.KeepAlive(new DiffMergeInstance(this, frame));
if (!args.ShowDiffAsDocument)
{
frame.SetProperty((int)__VSFPROPID.VSFPROPID_FrameMode, (int)VSFRAMEMODE.VSFM_Float);
}
return(true);
}
return(false);
}
private bool RunInternalDiff(AnkhDiffArgs args)
{
DiffEditorControl diffEditor = new DiffEditorControl();
IAnkhEditorResolver er = GetService <IAnkhEditorResolver>();
diffEditor.CreateDiffEditor(this, args);
if (diffEditor.WindowFrame != null && !args.ShowDiffAsDocument && VSVersion.VS2010OrLater)
{
diffEditor.WindowFrame.SetProperty((int)__VSFPROPID.VSFPROPID_FrameMode, (int)VSFRAMEMODE.VSFM_Float);
}
return(true);
}
internal void CreateDiffEditor(IAnkhServiceProvider context, AnkhDiffArgs args)
{
Context = context;
DynamicFactory.CreateEditor(args.BaseFile, this);
OnFrameCreated(EventArgs.Empty);
Collection <string> A, B;
GetFileLines(args.BaseFile, args.MineFile, out A, out B);
TextDiff Diff = new TextDiff(HashType.HashCode, false, false);
EditScript Script = Diff.Execute(A, B);
string strCaptionA = args.BaseTitle ?? Path.GetFileName(args.BaseFile);
string strCaptionB = args.MineTitle ?? Path.GetFileName(args.MineFile);
diffControl1.SetData(A, B, Script, strCaptionA, strCaptionB);
}
public Replacer(AnkhDiff context, AnkhDiffToolArgs args, DiffToolMode toolMode)
: base(context)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
else if (args == null)
{
throw new ArgumentNullException("args");
}
_diff = context;
_toolArgs = args;
_diffArgs = args as AnkhDiffArgs;
_mergeArgs = args as AnkhMergeArgs;
_patchArgs = args as AnkhPatchArgs;
_toolMode = toolMode;
}
public void OnExecute(CommandEventArgs e)
{
// All checked in OnUpdate
ILogControl logWindow = e.Selection.GetActiveControl <ILogControl>();
SvnOrigin origin = EnumTools.GetSingle(logWindow.Origins);
ISvnLogItem item = EnumTools.GetSingle(e.Selection.GetSelection <ISvnLogItem>());
IAnkhDiffHandler diff = e.GetService <IAnkhDiffHandler>();
AnkhDiffArgs da = new AnkhDiffArgs();
da.BaseFile = diff.GetTempFile(origin.Target, item.Revision, true);
if (da.BaseFile == null)
{
return; // User cancel
}
da.MineFile = ((SvnPathTarget)origin.Target).FullPath;
da.BaseTitle = string.Format("Base (r{0})", item.Revision);
da.MineTitle = "Working";
diff.RunDiff(da);
}
private static string DoExternalDiff(IAnkhServiceProvider context, IEnumerable <SvnItem> selection, SvnRevision start, SvnRevision end)
{
foreach (SvnItem item in selection)
{
// skip unmodified for a diff against the textbase
if (start == SvnRevision.Base && end == SvnRevision.Working && !item.IsModified)
{
continue;
}
string tempDir = context.GetService <IAnkhTempDirManager>().GetTempDir();
AnkhDiffArgs da = new AnkhDiffArgs();
da.BaseFile = GetPath(context, start, item, tempDir);
da.MineFile = GetPath(context, end, item, tempDir);
context.GetService <IAnkhDiffHandler>().RunDiff(da);
}
return(null);
}
public bool RunDiff(AnkhDiffArgs args)
{
if (args == null)
{
throw new ArgumentNullException("args");
}
else if (!args.Validate())
{
throw new ArgumentException("Arguments not filled correctly", "args");
}
SetFloat(args);
string diffApp = this.GetDiffPath(args.Mode, args.MineFile);
if (string.IsNullOrEmpty(diffApp))
{
IAnkhInternalDiff internalDiff = GetService <IAnkhInternalDiff>();
if (internalDiff == null || !internalDiff.HasDiff)
{
throw new InvalidOperationException("Internal diff not available");
}
return(internalDiff.RunDiff(args));
}
string program;
string arguments;
if (!Substitute(diffApp, args, DiffToolMode.Diff, out program, out arguments) ||
!File.Exists(program))
{
new AnkhMessageBox(Context).Show(string.Format("Can't find diff program '{0}'", program ?? diffApp));
return(false);
}
Process p = new Process();
p.StartInfo = new ProcessStartInfo(program, arguments);
string mergedFile = args.MineFile;
DiffToolMonitor monitor = null;
if (!string.IsNullOrEmpty(mergedFile))
{
monitor = new DiffToolMonitor(Context, mergedFile, false, null);
p.EnableRaisingEvents = true;
monitor.Register(p);
}
bool started = false;
try
{
return(started = p.Start());
}
finally
{
if (!started)
{
if (monitor != null)
{
monitor.Dispose();
}
}
}
}
public bool RunDiff(AnkhDiffArgs args)
{
return(RunInternalDiff(args));
}
public override void OnExecute(CommandEventArgs e)
{
List <SvnItem> selectedFiles = new List <SvnItem>();
if (e.Command == AnkhCommand.DocumentShowChanges)
{
SvnItem item = e.Selection.ActiveDocumentSvnItem;
if (item == null)
{
return;
}
selectedFiles.Add(item);
}
else
{
foreach (SvnItem item in e.Selection.GetSelectedSvnItems(false))
{
if (!item.IsVersioned || (item.Status.LocalNodeStatus == SvnStatus.Added && !item.Status.IsCopied))
{
continue;
}
if (e.Command == AnkhCommand.ItemCompareBase ||
e.Command == AnkhCommand.ItemShowChanges)
{
if (!(item.IsModified || item.IsDocumentDirty) ||
!item.IsLocalDiffAvailable // exclude if local diff is not available
)
{
continue;
}
}
if (e.Command == AnkhCommand.DiffLocalItem &&
!NotDeletedFilter(item))
{
continue;
}
selectedFiles.Add(item);
}
}
SvnRevisionRange revRange = null;
switch (e.Command)
{
case AnkhCommand.DiffLocalItem:
break; // revRange null -> show selector
case AnkhCommand.ItemCompareBase:
case AnkhCommand.ItemShowChanges:
case AnkhCommand.DocumentShowChanges:
revRange = new SvnRevisionRange(SvnRevision.Base, SvnRevision.Working);
break;
case AnkhCommand.ItemCompareCommitted:
revRange = new SvnRevisionRange(SvnRevision.Committed, SvnRevision.Working);
break;
case AnkhCommand.ItemCompareLatest:
revRange = new SvnRevisionRange(SvnRevision.Head, SvnRevision.Working);
break;
case AnkhCommand.ItemComparePrevious:
revRange = new SvnRevisionRange(SvnRevision.Previous, SvnRevision.Working);
break;
}
if (e.PromptUser || selectedFiles.Count > 1 || revRange == null)
{
SvnRevision start = revRange == null ? SvnRevision.Base : revRange.StartRevision;
SvnRevision end = revRange == null ? SvnRevision.Working : revRange.EndRevision;
// should we show the path selector?
if (e.PromptUser || !Shift)
{
using (CommonFileSelectorDialog dlg = new CommonFileSelectorDialog())
{
dlg.Text = CommandStrings.CompareFilesTitle;
dlg.Items = selectedFiles;
dlg.RevisionStart = start;
dlg.RevisionEnd = end;
if (dlg.ShowDialog(e.Context) != DialogResult.OK)
{
return;
}
selectedFiles.Clear();
selectedFiles.AddRange(dlg.GetCheckedItems());
start = dlg.RevisionStart;
end = dlg.RevisionEnd;
}
}
revRange = new SvnRevisionRange(start, end);
}
if (revRange.EndRevision.RevisionType == SvnRevisionType.Working ||
revRange.StartRevision.RevisionType == SvnRevisionType.Working)
{
// Save only the files needed
IAnkhOpenDocumentTracker tracker = e.GetService <IAnkhOpenDocumentTracker>();
if (tracker != null)
{
tracker.SaveDocuments(SvnItem.GetPaths(selectedFiles));
}
}
IAnkhDiffHandler diff = e.GetService <IAnkhDiffHandler>();
foreach (SvnItem item in selectedFiles)
{
AnkhDiffArgs da = new AnkhDiffArgs();
if ((item.Status.IsCopied || item.IsReplaced) &&
(!revRange.StartRevision.RequiresWorkingCopy || !revRange.EndRevision.RequiresWorkingCopy))
{
// The file is copied, use its origins history instead of that of the new file
SvnUriTarget copiedFrom = diff.GetCopyOrigin(item);
// TODO: Maybe handle Previous/Committed as history
if (copiedFrom != null && !revRange.StartRevision.RequiresWorkingCopy)
{
if (null == (da.BaseFile = diff.GetTempFile(copiedFrom, revRange.StartRevision, true)))
{
return; // Canceled
}
da.BaseTitle = diff.GetTitle(copiedFrom, revRange.StartRevision);
}
if (copiedFrom != null && !revRange.EndRevision.RequiresWorkingCopy)
{
if (null == (da.MineFile = diff.GetTempFile(copiedFrom, revRange.EndRevision, true)))
{
return; // Canceled
}
da.MineTitle = diff.GetTitle(copiedFrom, revRange.EndRevision);
}
}
if (da.BaseFile == null)
{
if (null == (da.BaseFile = (revRange.StartRevision == SvnRevision.Working) ? item.FullPath :
diff.GetTempFile(item, revRange.StartRevision, true)))
{
return; // Canceled
}
da.BaseTitle = diff.GetTitle(item, revRange.StartRevision);
}
if (da.MineFile == null)
{
if (null == (da.MineFile = (revRange.EndRevision == SvnRevision.Working) ? item.FullPath :
diff.GetTempFile(item, revRange.EndRevision, true)))
{
return; // Canceled
}
da.MineTitle = diff.GetTitle(item, revRange.EndRevision);
}
if (!String.Equals(da.MineFile, item.FullPath, StringComparison.OrdinalIgnoreCase))
{
da.ReadOnly = true;
}
diff.RunDiff(da);
}
}
public bool RunDiff(AnkhDiffArgs args)
{
ThreadHelper.ThrowIfNotOnUIThread();
return(RunInternalDiff(args));
}
