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 (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 void Reset(int n, AnkhDiffArgs args)
{
_nFrame = n;
Clear();
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);
//Ankh.Diff.FileName fnA = new Ankh.Diff.FileName(mine);
//Ankh.Diff.FileName fnB = new Ankh.Diff.FileName(theirs);
diffControl1.SetData(A, B, Script, strCaptionA, strCaptionB);
ToolWindowHost.Title = Path.GetFileName(args.MineFile) + " - Diff";
}
private bool RunInternalDiff(AnkhDiffArgs args)
{
IAnkhPackage pkg = GetService<IAnkhPackage>();
int nWnd;
if (_freeDiffs.Count > 0)
{
nWnd = _freeDiffs[0];
_freeDiffs.RemoveAt(0);
}
else
nWnd = _nNext++;
pkg.ShowToolWindow(AnkhToolWindow.Diff, nWnd, true);
DiffToolWindowControl twc = GetService<ISelectionContext>().ActiveFrameControl as DiffToolWindowControl;
if (twc != null)
twc.Reset(nWnd, args);
return false;
}
private static string DoExternalDiff(IAnkhServiceProvider context, PathSelectorResult info)
{
foreach (SvnItem item in info.Selection)
{
// skip unmodified for a diff against the textbase
if (info.RevisionStart == SvnRevision.Base &&
info.RevisionEnd == SvnRevision.Working && !item.IsModified)
continue;
string tempDir = context.GetService<IAnkhTempDirManager>().GetTempDir();
AnkhDiffArgs da = new AnkhDiffArgs();
da.BaseFile = GetPath(context, info.RevisionStart, item, tempDir);
da.MineFile = GetPath(context, info.RevisionEnd, item, tempDir);
context.GetService<IAnkhDiffHandler>().RunDiff(da);
}
return null;
}
public Replacer(AnkhDiff context, AnkhDiffToolArgs args, DiffToolMode toolMode)
{
if (context == null)
throw new ArgumentNullException("context");
else if (args == null)
throw new ArgumentNullException("args");
_context = context;
_toolArgs = args;
_diffArgs = args as AnkhDiffArgs;
_mergeArgs = args as AnkhMergeArgs;
_patchArgs = args as AnkhPatchArgs;
_toolMode = toolMode;
}
public bool RunDiff(AnkhDiffArgs args)
{
if (args == null)
throw new ArgumentNullException("args");
else if (!args.Validate())
throw new ArgumentException("Arguments not filled correctly", "args");
string diffApp = this.GetDiffPath(args.Mode);
if (string.IsNullOrEmpty(diffApp))
return RunInternalDiff(args);
string program;
string arguments;
if (!Substitute(diffApp, args, DiffToolMode.Diff, out program, out arguments))
{
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);
p.EnableRaisingEvents = true;
monitor.Register(p);
}
bool started = false;
try
{
return started = p.Start();
}
finally
{
if (!started)
{
if (monitor != null)
monitor.Dispose();
}
}
}
public override void OnExecute(CommandEventArgs e)
{
List<SvnItem> selectedFiles = new List<SvnItem>();
bool selectionHasDeleted = false;
if (e.Command == AnkhCommand.DocumentShowChanges)
{
SvnItem item = e.Selection.ActiveDocumentItem;
if(item == null)
return;
selectedFiles.Add(item);
}
else
foreach (SvnItem item in e.Selection.GetSelectedSvnItems(false))
{
if (!item.IsVersioned || (item.Status.CombinedStatus == 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)
{
selectionHasDeleted |= !NotDeletedFilter(item);
}
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)
{
PathSelectorInfo info = new PathSelectorInfo("Select item for Diff", selectedFiles);
info.SingleSelection = false;
info.RevisionStart = revRange == null ? SvnRevision.Base : revRange.StartRevision;
info.RevisionEnd = revRange == null ? SvnRevision.Working : revRange.EndRevision;
if (selectionHasDeleted)
{
// do not allow selecting deleted items if the revision combination includes SvnRevision.Working
info.CheckableFilter += new PathSelectorInfo.SelectableFilter(delegate(SvnItem item, SvnRevision from, SvnRevision to)
{
if (item != null
&& (from == SvnRevision.Working
|| to == SvnRevision.Working
)
)
{
return NotDeletedFilter(item);
}
return true;
});
}
info.EnableRecursive = false;
info.Depth = SvnDepth.Infinity;
PathSelectorResult result;
// should we show the path selector?
if (e.PromptUser || !Shift)
{
IUIShell ui = e.GetService<IUIShell>();
result = ui.ShowPathSelector(info);
if (!result.Succeeded)
return;
}
else
result = info.DefaultResult;
selectedFiles.Clear();
selectedFiles.AddRange(result.Selection);
revRange = new SvnRevisionRange(result.RevisionStart, result.RevisionEnd);
}
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);
}
}
