private void OnProjectionBufferSourceSpansChanged(
object sender,
ProjectionSourceSpansChangedEventArgs e
)
{
UpdateSourceSpans();
}
private void SourceSpansChanged(object sender, ProjectionSourceSpansChangedEventArgs e)
{
if (e.Changes.Count == 0)
{
// If there weren't text changes, but there were span changes, then
// send out a classification changed event over the spans that changed.
ProjectionSpanDifference difference = ProjectionSpanDiffer.DiffSourceSpans(this.diffService, e.Before, e.After);
int pos = 0;
int start = int.MaxValue;
int end = int.MinValue;
foreach (var diff in difference.DifferenceCollection)
{
pos += GetMatchSize(difference.DeletedSpans, diff.Before);
start = Math.Min(start, pos);
// Now, for every span added in the new snapshot that replaced
// the deleted spans, add it to our span to raise changed events
// over.
for (int i = diff.Right.Start; i < diff.Right.End; i++)
{
pos += difference.InsertedSpans[i].Length;
}
end = Math.Max(end, pos);
}
if (start != int.MaxValue && end != int.MinValue)
{
RaiseTagsChangedEvent(new SnapshotSpan(e.After, Span.FromBounds(start, end)));
}
}
}
private void SourceSpansChanged(object sender, ProjectionSourceSpansChangedEventArgs e)
{
var handler = TagsChanged;
if ((handler != null) && (e.Changes.Count == 0))
{
// If there weren't text changes, but there were span changes, then
// send out a classification changed event over the spans that changed.
//
// We're raising a single event here so all we need is the start of the first changed span
// to the end of the last changed span (or, as we calculate it, the end of the first identical
// spans to the start of the last identical spans).
//
// Note that we are being generous in the span we raise. For example if I change the projection buffer
// from projecting (V0:[0,10)) and (V0:[10,15)) to projecting (V0:[0,5)) and (V0:[5,15)) we'll raise a snapshot changed
// event over the entire buffer even though neither the projected text nor the content type of its buffer
// changed. This case shouldn't happen very often and the cost of (falsely) raising a classification changed
// event is pretty small so this is a net perf win compared to doing a more expensive diff to get the actual
// changed span.
var leftSpans = e.Before.GetSourceSpans();
var rightSpans = e.After.GetSourceSpans();
var spansToCompare = Math.Min(leftSpans.Count, rightSpans.Count);
int start = 0;
int identicalSpansAtStart = 0;
while ((identicalSpansAtStart < spansToCompare) && (leftSpans[identicalSpansAtStart] == rightSpans[identicalSpansAtStart]))
{
start += rightSpans[identicalSpansAtStart].Length;
++identicalSpansAtStart;
}
if ((identicalSpansAtStart < leftSpans.Count) || (identicalSpansAtStart < rightSpans.Count))
{
// There are at least some span differences between leftSpans and rightSpans so we don't need to worry about running over.
spansToCompare -= identicalSpansAtStart; //No need to compare spans in the starting identical block.
int end = e.After.Length;
int identicalSpansAtEndPlus1 = 1;
while ((identicalSpansAtEndPlus1 <= spansToCompare) && (leftSpans[leftSpans.Count - identicalSpansAtEndPlus1] == rightSpans[rightSpans.Count - identicalSpansAtEndPlus1]))
{
end -= rightSpans[rightSpans.Count - identicalSpansAtEndPlus1].Length;
++identicalSpansAtEndPlus1;
}
handler(this, new SnapshotSpanEventArgs(new SnapshotSpan(e.After, Span.FromBounds(start, end))));
}
}
}
private void OnSourceSpansChanged(object sender, ProjectionSourceSpansChangedEventArgs e)
{
_projectionsChanged = true;
Dispatcher.CurrentDispatcher.BeginInvoke(new Action(ResoreHighlight));
}
private void OnSourceSpansChanged(object sender, ProjectionSourceSpansChangedEventArgs e)
{
_projectionsChanged = true;
Dispatcher.CurrentDispatcher.BeginInvoke(new Action(ResoreHighlight));
}
private void OnProjectionBufferSourceSpansChanged(object sender, ProjectionSourceSpansChangedEventArgs e)
{
UpdateSourceSpans();
}
private void OnProjectionSourceSpansChanged(object sender, ProjectionSourceSpansChangedEventArgs e)
{
UpdateSpans(e.After);
}