public void ResolveAs(Side side)
{
ResultBlock result;
if (!HasSide(side))
{
result = new ResultBlock(string.Empty, PrevBlock);
}
else if (side == Side.Left)
{
result = new ResultBlock(left, PrevBlock);
}
else
{
result = new ResultBlock(right, PrevBlock);
}
result.NextBlock = NextBlock;
if (NextBlock != null)
{
NextBlock.PrevBlock = result;
}
RebuildRequested?.Invoke(this, new RebuildRequestEventArgs(result));
}
public ResultBlock(string both, ResultBlock previous)
: this(previous)
{
left = right = effectiveLeft = effectiveRight = effectiveResult = both;
IsEqual = hasLeft = hasRight = true;
IsWhiteSpace = String.IsNullOrWhiteSpace(both);
}
private void Result_RebuildRequested(object sender, RebuildRequestEventArgs e)
{
if (Root == sender)
{
Root = e.First;
}
(sender as ResultBlock).RebuildRequested -= Result_RebuildRequested;
RebuildRequested?.Invoke(sender, e);
}
public Comparison(List <Diff> source)
{
ResultBlock current = null;
ResultBlock result;
int i = 0;
for (; i < source.Count - 1; i++)
{
if (source[i].Operation.IsEqual)
{
result = new ResultBlock(source[i].Text, current);
}
else if (!source[i + 1].Operation.IsEqual)
{
var left = source[i].Operation.IsDelete ? source[i].Text : source[i + 1].Text;
var right = source[i].Operation.IsDelete ? source[i + 1].Text : source[i].Text;
result = new ResultBlock(left, right, current);
i += 1;
}
else
{
result = new ResultBlock(source[i].Text, source[i].Operation.IsDelete, current);
}
if (current == null)
{
Root = result;
}
current = result;
result.RebuildRequested += Result_RebuildRequested;
result.RedrawRequested += Result_RedrawRequested;
}
if (i < source.Count)
{
if (source.Last().Operation.IsEqual)
{
result = new ResultBlock(source[i].Text, current);
}
else
{
result = new ResultBlock(source[i].Text, source[i].Operation.IsDelete, current);
}
if (current == null)
{
Root = result;
}
result.RebuildRequested += Result_RebuildRequested;
result.RedrawRequested += Result_RedrawRequested;
}
}
internal void Append(string insertedText)
{
var block = Root;
while (block?.NextBlock != null)
{
block = block.NextBlock;
}
var newBlock = new ResultBlock(insertedText, block);
}
private ResultBlock(ResultBlock previous)
{
TakeLeft = ReactiveCommand.Create(() => ResolveAs(Side.Left));
TakeRight = ReactiveCommand.Create(() => ResolveAs(Side.Right));
TakeLeftThenRight = ReactiveCommand.Create(() => ResolveAs(Side.Left, Side.Right));
TakeRightThenLeft = ReactiveCommand.Create(() => ResolveAs(Side.Right, Side.Left));
PrevBlock = previous;
if (PrevBlock != null)
{
PrevBlock.NextBlock = this;
}
}
private bool AreAllConflictsResolved()
{
ResultBlock block = Comparison.Root;
while (block != null)
{
if (block.IsConflict &&
!(HideWhiteSpace && block.IsWhiteSpace))
{
return(false);
}
block = block.NextBlock;
}
return(true);
}
internal int GetOffsetToBlock(ResultBlock block, Side side)
{
var current = Root;
var start = 0;
while (current != null)
{
if (current == block)
{
return(start);
}
start += current.Length(side);
current = current.NextBlock;
}
return(-1);
}
public ResultBlock(string left, string right, ResultBlock previous)
: this(previous)
{
var totalLen = Math.Max(left.Length, right.Length);
var leftLines = left.Split(new[] { Environment.NewLine }, StringSplitOptions.None);
var rightLines = right.Split(new[] { Environment.NewLine }, StringSplitOptions.None);
effectiveLeft = left;
effectiveRight = right;
if (leftLines.Length < rightLines.Length)
{
var contents = string.Join(Environment.NewLine, rightLines.Skip(leftLines.Length).Select(s => new string(' ', s.Length)));
effectiveLeft = $"{effectiveLeft}{Environment.NewLine}{contents}";
}
else if (leftLines.Length > rightLines.Length)
{
var contents = string.Join(Environment.NewLine, leftLines.Skip(rightLines.Length).Select(s => new string(' ', s.Length)));
effectiveRight = $"{effectiveRight}{Environment.NewLine}{contents}";
}
effectiveResult = string.Empty;
var lineCount = Math.Max(leftLines.Length, rightLines.Length);
for (int i = 0; i < lineCount; i++)
{
var l = i < leftLines.Length ? leftLines[i] : string.Empty;
var r = i < rightLines.Length ? rightLines[i] : string.Empty;
var ll = Math.Max(l.Length, r.Length);
effectiveResult += string.Concat(new string(' ', ll), Environment.NewLine);
}
this.left = left;
this.right = right;
hasLeft = hasRight = true;
IsConflict = true;
IsWhiteSpace = String.IsNullOrWhiteSpace(left) && String.IsNullOrWhiteSpace(right);
}
public ResultBlock(string either, bool isAdd, ResultBlock previous)
: this(previous)
{
if (isAdd)
{
left = effectiveLeft = effectiveResult = either;
var rightLines = left.Split(new[] { Environment.NewLine }, StringSplitOptions.None);
right = effectiveRight = string.Join(Environment.NewLine, rightLines.Select(l => new string(' ', l.Length)));
hasLeft = true;
}
else
{
right = effectiveRight = effectiveResult = either;
var leftLines = right.Split(new[] { Environment.NewLine }, StringSplitOptions.None);
left = effectiveLeft = string.Join(Environment.NewLine, leftLines.Select(l => new string(' ', l.Length)));
hasRight = true;
}
IsWhiteSpace = String.IsNullOrWhiteSpace(either);
}
protected override void OnPreviewMouseUp(MouseButtonEventArgs e)
{
var vpos = e.GetPosition(this);
var pos = this.GetPositionFromPoint(vpos);
if (pos != null)
{
if (selectedBlock != null)
{
selectedBlock.IsSelected = false;
}
var offs = Document.GetOffset(pos.Value.Location);
var block = Contents.GetBlockContainingOffset(offs, Side);
if (block != null && !block.Block.IsEqual)
{
selectedBlock = block.Block;
selectedBlock.IsSelected = true;
}
}
base.OnMouseUp(e);
}
public RebuildRequestEventArgs(ResultBlock first)
{
First = first;
}
public RebuildRequestEventArgs(ResultBlock first, ResultBlock second)
{
First = first;
Second = second;
}
public void ResolveAs(Side first, Side second)
{
RebuildRequestEventArgs args;
ResultBlock firstBlock = null;
ResultBlock secondBlock = null;
var current = this;
if (HasSide(first))
{
ResultBlock result;
if (first == Side.Left)
{
result = new ResultBlock(left, PrevBlock);
}
else
{
result = new ResultBlock(right, PrevBlock);
}
result.NextBlock = NextBlock;
if (NextBlock != null)
{
current.NextBlock.PrevBlock = result;
}
firstBlock = current = result;
}
if (HasSide(second))
{
ResultBlock result;
var prev = HasSide(first) ? current : PrevBlock;
if (second == Side.Left)
{
result = new ResultBlock(left, prev);
}
else
{
result = new ResultBlock(right, prev);
}
result.NextBlock = NextBlock;
if (NextBlock != null)
{
current.NextBlock.PrevBlock = result;
}
if (current == this)
{
firstBlock = current = result;
}
else
{
secondBlock = result;
}
}
args = new RebuildRequestEventArgs(firstBlock, secondBlock);
RebuildRequested?.Invoke(this, args);
RebuildRequested = null;
}
