public ITrackingSpan CreateTrackingSpan(Span span, SpanTrackingMode trackingMode, TrackingFidelityMode trackingFidelity) {
if (trackingMode == SpanTrackingMode.Custom)
throw new NotSupportedException();
if (trackingFidelity == TrackingFidelityMode.UndoRedo)
throw new NotSupportedException();
return new TrackingSpan(this, span, trackingMode, trackingFidelity);
}
public MappingSpan(IBufferGraph bufferGraph, SnapshotSpan snapshotSpan, SpanTrackingMode trackingMode) {
if (bufferGraph == null)
throw new ArgumentNullException(nameof(bufferGraph));
if (snapshotSpan.Snapshot == null)
throw new ArgumentException();
BufferGraph = bufferGraph;
this.snapshotSpan = snapshotSpan;
spanTrackingMode = trackingMode;
}
public TrackingSpanMock(ITextBuffer textBuffer, Span span, SpanTrackingMode trackingMode, TrackingFidelityMode trackingFidelity)
{
_span = span;
TextBuffer = textBuffer;
TrackingMode = trackingMode;
TrackingFidelity = trackingFidelity;
var mock = textBuffer as TextBufferMock;
mock.BeforeChanged += OnBeforeTextBufferChanged;
}
public TrackingSpan(ITextVersion textVersion, Span span, SpanTrackingMode trackingMode, TrackingFidelityMode trackingFidelity) {
if (textVersion == null)
throw new ArgumentNullException(nameof(textVersion));
if ((uint)span.End > (uint)textVersion.Length)
throw new ArgumentOutOfRangeException(nameof(span));
TextBuffer = textVersion.TextBuffer;
TrackingFidelity = trackingFidelity;
TrackingMode = trackingMode;
this.textVersion = textVersion;
this.span = span;
}
private static SnapshotSpan MapTo(IBufferGraphFactoryService bufferGraphFactoryService, SnapshotSpan span, ITextSnapshot snapshot, SpanTrackingMode spanTrackingMode)
{
if (span.Snapshot.TextBuffer == snapshot.TextBuffer)
return span.TranslateTo(snapshot, spanTrackingMode);
var graph = bufferGraphFactoryService.CreateBufferGraph(snapshot.TextBuffer);
var mappingSpan = graph.CreateMappingSpan(span, spanTrackingMode);
var mapped = mappingSpan.GetSpans(snapshot);
if (mapped.Count == 1)
return mapped[0];
return new SnapshotSpan(mapped[0].Start, mapped[mapped.Count - 1].End);
}
/// <summary>
/// Initializes a new instance of the <see cref="VersionedTextSpan"/> class.
/// </summary>
/// <exception cref="ArgumentNullException">
/// <para><paramref name="buffer"/> is <see langword="null"/>.</para>
/// -or-
/// <para><paramref name="span"/> is <see langword="null"/>.</para>
/// </exception>
public VersionedTextSpan(TextBuffer buffer, Span span, SpanTrackingMode trackingMode)
{
if (buffer == null)
{
throw new ArgumentNullException("buffer");
}
if (span == null)
{
throw new ArgumentNullException("span");
}
this.Construct(buffer, buffer.Version, span.Start, span.Length, trackingMode);
}
public MockTrackingSpan(MockTextSnapshot snapshot, int start, int length, SpanTrackingMode trackingMode = SpanTrackingMode.EdgeExclusive) {
_start = start;
_length = length;
_snapshot = snapshot;
_trackingMode = trackingMode;
switch(_trackingMode) {
case SpanTrackingMode.EdgeExclusive:
_startPoint = new MockTrackingPoint(snapshot, start, PointTrackingMode.Positive);
_endPoint = new MockTrackingPoint(snapshot, start + length, PointTrackingMode.Negative);
break;
case SpanTrackingMode.EdgeInclusive:
_startPoint = new MockTrackingPoint(snapshot, start, PointTrackingMode.Negative);
_endPoint = new MockTrackingPoint(snapshot, start + length, PointTrackingMode.Positive);
break;
case SpanTrackingMode.EdgeNegative:
_startPoint = new MockTrackingPoint(snapshot, start, PointTrackingMode.Negative);
_endPoint = new MockTrackingPoint(snapshot, start + length, PointTrackingMode.Negative);
break;
case SpanTrackingMode.EdgePositive:
_startPoint = new MockTrackingPoint(snapshot, start, PointTrackingMode.Positive);
_endPoint = new MockTrackingPoint(snapshot, start + length, PointTrackingMode.Positive);
break;
}
}
public NormalizedSnapshotSpanCollection MapDownToFirstMatch(SnapshotSpan span, SpanTrackingMode trackingMode, Predicate <ITextSnapshot> match)
{
if (span.Snapshot == null)
{
throw new ArgumentNullException(nameof(span));
}
if (trackingMode < SpanTrackingMode.EdgeExclusive || trackingMode > SpanTrackingMode.EdgeNegative)
{
throw new ArgumentOutOfRangeException(nameof(trackingMode));
}
if (match == null)
{
throw new ArgumentNullException(nameof(match));
}
if (!this.importingProjectionBufferMap.ContainsKey(span.Snapshot.TextBuffer))
{
return(NormalizedSnapshotSpanCollection.Empty);
}
ITextBuffer currentBuffer = span.Snapshot.TextBuffer;
SnapshotSpan currentTopSpan = span.TranslateTo(currentBuffer.CurrentSnapshot, trackingMode);
if (match(currentBuffer.CurrentSnapshot))
{
return(new NormalizedSnapshotSpanCollection(currentTopSpan));
}
else if (!(currentBuffer is IProjectionBufferBase))
{
return(NormalizedSnapshotSpanCollection.Empty);
}
else
{
FrugalList <Span> targetSpans = new FrugalList <Span>();
FrugalList <SnapshotSpan> spans = new FrugalList <SnapshotSpan>()
{
currentTopSpan
};
ITextSnapshot chosenSnapshot = null;
do
{
spans = MapDownOneLevel(spans, match, ref chosenSnapshot, ref targetSpans);
} while (spans.Count > 0);
return(chosenSnapshot == null ? NormalizedSnapshotSpanCollection.Empty : new NormalizedSnapshotSpanCollection(chosenSnapshot, targetSpans));
}
}
private static IList <ReadOnlySpan> NormalizeSpans(TextVersion version, IEnumerable <IReadOnlyRegion> regions)
{
List <IReadOnlyRegion> sorted = new List <IReadOnlyRegion>(regions.Where(region => region.QueryCallback == null));
if (sorted.Count == 0)
{
return(new FrugalList <ReadOnlySpan>());
}
else if (sorted.Count == 1)
{
return(new FrugalList <ReadOnlySpan>()
{
new ReadOnlySpan(version, sorted[0])
});
}
else
{
sorted.Sort((s1, s2) => s1.Span.GetSpan(version).Start.CompareTo(s2.Span.GetSpan(version).Start));
List <ReadOnlySpan> normalized = new List <ReadOnlySpan>(sorted.Count);
int oldStart = sorted[0].Span.GetSpan(version).Start;
int oldEnd = sorted[0].Span.GetSpan(version).End;
EdgeInsertionMode oldStartEdgeInsertionMode = sorted[0].EdgeInsertionMode;
EdgeInsertionMode oldEndEdgeInsertionMode = sorted[0].EdgeInsertionMode;
SpanTrackingMode oldSpanTrackingMode = sorted[0].Span.TrackingMode;
for (int i = 1; (i < sorted.Count); ++i)
{
int newStart = sorted[i].Span.GetSpan(version).Start;
int newEnd = sorted[i].Span.GetSpan(version).End;
// Since the new span's start occurs after the old span's end, we can just add the old span directly.
if (oldEnd < newStart)
{
normalized.Add(new ReadOnlySpan(version, new Span(oldStart, oldEnd - oldStart), oldSpanTrackingMode, oldStartEdgeInsertionMode, oldEndEdgeInsertionMode));
oldStart = newStart;
oldEnd = newEnd;
oldStartEdgeInsertionMode = sorted[i].EdgeInsertionMode;
oldEndEdgeInsertionMode = sorted[i].EdgeInsertionMode;
oldSpanTrackingMode = sorted[i].Span.TrackingMode;
}
else
{
// The two read only regions start at the same position
if (newStart == oldStart)
{
// If one read only region denies edge insertions, combined they do as well
if (sorted[i].EdgeInsertionMode == EdgeInsertionMode.Deny)
{
oldStartEdgeInsertionMode = EdgeInsertionMode.Deny;
}
// This is tricky. We want one span that will be inclusive tracking, and one that won't.
if (oldSpanTrackingMode != sorted[i].Span.TrackingMode)
{
// Since the read only regions cover the same exact span, the combined one will be edge inclusive tracking
if (oldEnd == newEnd)
{
oldSpanTrackingMode = SpanTrackingMode.EdgeInclusive;
}
else if (oldEnd < newEnd)
{
// Since the old span and new span don't have the same span tracking mode and don't end in the same position, we need to create a new span that is edge inclusive
// and deny inserts between it and the next span.
normalized.Add(new ReadOnlySpan(version, new Span(oldStart, oldEnd - oldStart), SpanTrackingMode.EdgeInclusive, oldStartEdgeInsertionMode, EdgeInsertionMode.Deny));
oldStart = oldEnd; // Explicitly use the old end here since we want these spans to be adjacent
oldEnd = newEnd;
oldStartEdgeInsertionMode = sorted[i].EdgeInsertionMode;
oldEndEdgeInsertionMode = sorted[i].EdgeInsertionMode;
oldSpanTrackingMode = sorted[i].Span.TrackingMode;
}
else
{
// Since the new span ends first, create a span that is edge inclusive tracking that ends at the the new span's end.
normalized.Add(new ReadOnlySpan(version, new Span(newStart, newEnd - newStart), SpanTrackingMode.EdgeInclusive, oldStartEdgeInsertionMode, EdgeInsertionMode.Deny));
oldStart = newEnd; // Explicitly use the new end here since we want these spans to be adjacent
}
}
}
if (oldEnd < newEnd)
{
// If the tracking modes are different then we need to create a new span
// with the old tracking mode, and start a new span with the new span tracking mode.
// Also, if the old end and the new start are identical and both edge insertion mode's
// are allow, then we need to create a new span.
if (((oldEnd == newStart)
&&
((oldEndEdgeInsertionMode == EdgeInsertionMode.Allow) && (sorted[i].EdgeInsertionMode == EdgeInsertionMode.Allow)))
||
(oldSpanTrackingMode != sorted[i].Span.TrackingMode))
{
normalized.Add(new ReadOnlySpan(version, new Span(oldStart, oldEnd - oldStart), oldSpanTrackingMode, oldStartEdgeInsertionMode, oldEndEdgeInsertionMode));
oldStart = oldEnd; // Explicitly use the old end here since we want these spans to be adjacent.
oldEnd = newEnd;
// If we are splitting up the spans because of a change in tracking mode, then explicitly deny inserting between them
if (oldSpanTrackingMode != sorted[i].Span.TrackingMode)
{
oldStartEdgeInsertionMode = EdgeInsertionMode.Deny; // Explicitly use deny here since we don't want to allow insertions between these spans
}
else
{
oldStartEdgeInsertionMode = EdgeInsertionMode.Allow;
}
oldEndEdgeInsertionMode = sorted[i].EdgeInsertionMode;
oldSpanTrackingMode = sorted[i].Span.TrackingMode;
}
else
{
oldEnd = newEnd;
oldEndEdgeInsertionMode = sorted[i].EdgeInsertionMode;
}
}
else if (oldEnd == newEnd)
{
if (sorted[i].EdgeInsertionMode == EdgeInsertionMode.Deny)
{
oldEndEdgeInsertionMode = EdgeInsertionMode.Deny;
}
if (oldSpanTrackingMode != sorted[i].Span.TrackingMode)
{
normalized.Add(new ReadOnlySpan(version, new Span(oldStart, oldEnd - oldStart), oldSpanTrackingMode, oldStartEdgeInsertionMode, oldEndEdgeInsertionMode));
oldStart = newEnd;
oldEnd = newEnd;
oldStartEdgeInsertionMode = sorted[i].EdgeInsertionMode;
oldEndEdgeInsertionMode = sorted[i].EdgeInsertionMode;
oldSpanTrackingMode = sorted[i].Span.TrackingMode;
}
}
}
}
normalized.Add(new ReadOnlySpan(version, new Span(oldStart, oldEnd - oldStart), oldSpanTrackingMode, oldStartEdgeInsertionMode, oldEndEdgeInsertionMode));
return(normalized);
}
}
public ITrackingSpan CreateTrackingSpan(Span span, SpanTrackingMode trackingMode, TrackingFidelityMode trackingFidelity)
{
return(this.version.CreateTrackingSpan(span, trackingMode, trackingFidelity));
}
public ITrackingSpan CreateTrackingSpan(int start, int length, SpanTrackingMode trackingMode, TrackingFidelityMode trackingFidelity) => Version.CreateTrackingSpan(start, length, trackingMode, trackingFidelity);
public NormalizedSnapshotSpanCollection MapDownToFirstMatch(SnapshotSpan span, SpanTrackingMode trackingMode, Predicate<ITextSnapshot> match) {
throw new NotImplementedException();
}
public ITrackingSpan CreateTrackingSpan(Span span, SpanTrackingMode trackingMode) {
return new MockTrackingSpan(this, span.Start, span.Length);
}
public ITrackingSpan CreateTrackingSpan(Int32 start, Int32 length, SpanTrackingMode trackingMode)
{
throw new NotImplementedException();
}
public static Result <SnapshotSpan> SafeTranslateTo(this SnapshotSpan span, ITextSnapshot snapshot, SpanTrackingMode mode)
{
try
{
return(span.TranslateTo(snapshot, mode));
}
catch (Exception ex)
{
return(Result.CreateError(ex));
}
}
public static ITrackingSpan CreateFullTrackingSpan(this ITextSnapshot textSnapshot, SpanTrackingMode trackingMode) => textSnapshot.CreateTrackingSpan(Span.FromBounds(0, textSnapshot.Length), trackingMode);
public static ITrackingSpan CreateTrackingSpanFromStartToIndex(this ITextSnapshot textSnapshot, int index, SpanTrackingMode trackingMode) => textSnapshot.CreateTrackingSpan(Span.FromBounds(0, index), trackingMode);
public static ITrackingSpan CreateTrackingSpanFromIndexToEnd(this ITextSnapshot textSnapshot, int index, SpanTrackingMode trackingMode) => textSnapshot.CreateTrackingSpan(Span.FromBounds(index, textSnapshot.Length), trackingMode);
public IMappingSpan CreateMappingSpan(SnapshotSpan span, SpanTrackingMode trackingMode)
{
return(new MappingSpan(span, trackingMode, this));
}
public NormalizedSnapshotSpanCollection CheckedMapUpToBuffer(SnapshotSpan span, SpanTrackingMode trackingMode, Predicate <ITextSnapshot> match)
{
if (span.Snapshot == null)
{
throw new ArgumentNullException(nameof(span));
}
if (trackingMode < SpanTrackingMode.EdgeExclusive || trackingMode > SpanTrackingMode.EdgeNegative)
{
throw new ArgumentOutOfRangeException(nameof(trackingMode));
}
ITextBuffer buffer = span.Snapshot.TextBuffer;
if (!this.importingProjectionBufferMap.ContainsKey(buffer))
{
return(NormalizedSnapshotSpanCollection.Empty);
}
SnapshotSpan currentSpan = span.TranslateTo(buffer.CurrentSnapshot, trackingMode);
if (match(buffer.CurrentSnapshot))
{
return(new NormalizedSnapshotSpanCollection(currentSpan));
}
ITextSnapshot chosenSnapshot = null;
FrugalList <Span> result = new FrugalList <Span>();
FrugalList <SnapshotSpan> spans = new FrugalList <SnapshotSpan>()
{
currentSpan
};
do
{
spans = MapUpOneLevel(spans, ref chosenSnapshot, match, result);
} while (spans.Count > 0);
if (chosenSnapshot == null)
{
return(NormalizedSnapshotSpanCollection.Empty);
}
else
{
return(new NormalizedSnapshotSpanCollection(chosenSnapshot, result));
}
}
/// <summary>
/// Initializes a new instance of the <see cref="TextSpan"/> class.
/// </summary>
/// <exception cref="ArgumentNullException"><paramref name="span"/> is <see langword="null"/>.</exception>
public TextSpan(TextBuffer textBuffer, Span span, SpanTrackingMode trackingMode)
: base(span)
{
this.Initialize(textBuffer, trackingMode);
}
private Anchor CreateAnchor(ParserRuleContext context, int start, int stop, SpanTrackingMode trackingMode, int rule)
{
ITrackingSpan trackingSpan = _snapshot.CreateTrackingSpan(start, stop - start, trackingMode);
if (rule == GrammarParser.RULE_grammarType)
{
return(new GrammarTypeAnchor((GrammarParser.GrammarTypeContext)context, trackingSpan));
}
else
{
return(new GrammarAnchor(rule, trackingSpan));
}
}
public ITrackingSpan CreateTrackingSpan(int start, int length, SpanTrackingMode trackingMode) {
return new MockTrackingSpan(this, start, length);
}
public ITrackingSpan CreateTrackingSpan(int start, int length, SpanTrackingMode trackingMode) => CreateTrackingSpan(new Span(start, length), trackingMode);
public IMappingSpan CreateMappingSpan(SnapshotSpan span, SpanTrackingMode trackingMode) {
throw new NotImplementedException();
}
public ITrackingSpan CreateTrackingSpan(Span span, SpanTrackingMode trackingMode) => CreateTrackingSpan(span, trackingMode, TrackingFidelityMode.Forward);
public ITrackingSpan CreateTrackingSpan(Span span, SpanTrackingMode trackingMode, TrackingFidelityMode trackingFidelity) => Version.CreateTrackingSpan(span, trackingMode, trackingFidelity);
public ITrackingSpan CreateTrackingSpan(int start, int length, SpanTrackingMode trackingMode, TrackingFidelityMode trackingFidelity) => CreateTrackingSpan(new Span(start, length), trackingMode, trackingFidelity);
public FakeTrackingSpan(Span span, SpanTrackingMode trackingMode)
{
this.span = span;
this.trackingMode = trackingMode;
}
public ITrackingSpan CreateTrackingSpan(Span span, SpanTrackingMode trackingMode)
{
return TextBuffer.CurrentSnapshot.CreateTrackingSpan(span, trackingMode);
}
public static IMappingSpan Create(ITextSnapshot root, SnapshotSpan anchor, SpanTrackingMode trackingMode, IBufferGraph graph)
{
return(new MappingSpanSnapshot(root, anchor, trackingMode, graph));
}
/// <summary>
/// Initializes a new instance of the <see cref="VersionedTextSpan"/> class.
/// </summary>
/// <exception cref="ArgumentNullException">
/// <para><paramref name="buffer"/> is <see langword="null"/>.</para>
/// -or-
/// <para><paramref name="version"/> is <see langword="null"/>.</para>
/// </exception>
/// <exception cref="ArgumentException">
/// <para>The specified <paramref name="version"/> does not belong to the specified <paramref name="buffer"/>.</para>
/// </exception>
public VersionedTextSpan(TextBuffer buffer, ITextVersion version, Int32 start, Int32 length, SpanTrackingMode trackingMode)
{
if (buffer == null)
{
throw new ArgumentNullException("buffer");
}
if (version == null)
{
throw new ArgumentNullException("version");
}
if (!buffer.VersionBelongsToBuffer(version))
{
throw new ArgumentException("The specified TextVersion does not belong to the specified TextBuffer.");
}
this.Construct(buffer, version, start, length, trackingMode);
}
public ITrackingSpan CreateTrackingSpan(Span span, SpanTrackingMode trackingMode) => Version.CreateTrackingSpan(span, trackingMode);
public ITrackingSpan CreateTrackingSpan(Int32 start, Int32 length, SpanTrackingMode trackingMode)
{
throw new NotImplementedException();
}
public ITrackingSpan CreateTrackingSpan(int start, int length, SpanTrackingMode trackingMode)
{
return TextBuffer.CurrentSnapshot.CreateTrackingSpan(start, length, trackingMode);
}
public ITrackingSpan CreateTrackingSpan(Span span, SpanTrackingMode trackingMode, TrackingFidelityMode trackingFidelity) => Version.CreateTrackingSpan(span, trackingMode, trackingFidelity);
/// <summary>
/// Initializes a new instance of the <see cref="VersionedTextSpan"/> class.
/// </summary>
/// <exception cref="ArgumentNullException">
/// <para><paramref name="buffer"/> is <see langword="null"/>.</para>
/// </exception>
public VersionedTextSpan(TextBuffer buffer, Int32 start, Int32 length, SpanTrackingMode trackingMode)
{
if (buffer == null)
{
throw new ArgumentNullException("buffer");
}
this.Construct(buffer, buffer.Version, start, length, trackingMode);
}
public ITrackingSpan CreateTrackingSpan(int start, int length, SpanTrackingMode trackingMode) => Version.CreateTrackingSpan(start, length, trackingMode);
private void Construct(TextBuffer buffer, ITextVersion version, Int32 start, Int32 length, SpanTrackingMode trackingMode)
{
Int32 lengthOfVersion = buffer.GetLengthOfVersion(version);
if ((start < 0) || (start > lengthOfVersion))
{
throw new ArgumentOutOfRangeException("start");
}
if ((length < 0) || ((start + length) > lengthOfVersion))
{
throw new ArgumentOutOfRangeException("length");
}
_buffer = buffer;
_version = version;
_start = start;
_length = length;
_trackingMode = trackingMode;
}
public ITrackingSpan CreateTrackingSpan(int start, int length, SpanTrackingMode trackingMode, TrackingFidelityMode trackingFidelity) => Version.CreateTrackingSpan(start, length, trackingMode, trackingFidelity);
private void Initialize(TextBuffer textBuffer, SpanTrackingMode trackingMode)
{
if (textBuffer == null)
{
throw new ArgumentNullException("textBuffer");
}
if (base.Start > textBuffer.Length)
{
throw new ArgumentOutOfRangeException("start");
}
if ((base.Start + base.Length) > textBuffer.Length)
{
throw new ArgumentOutOfRangeException("length");
}
this.TextBuffer = textBuffer;
_version = textBuffer.Version;
this.TrackingMode = trackingMode;
}
public ITrackingSpan CreateTrackingSpan(VisualStudio.Text.Span span, SpanTrackingMode trackingMode, TrackingFidelityMode trackingFidelity) => throw new NotImplementedException();
/// <summary>
/// Initializes a new instance of the <see cref="TextSpan"/> class.
/// </summary>
public TextSpan(TextBuffer textBuffer, Int32 start, Int32 length, SpanTrackingMode trackingMode)
: base(start, length)
{
this.Initialize(textBuffer, trackingMode);
}
public ITrackingSpan CreateTrackingSpan(int start, int length, SpanTrackingMode trackingMode) => throw new NotImplementedException();
public ITrackingSpan CreateTrackingSpan(int start, int length, SpanTrackingMode trackingMode, TrackingFidelityMode trackingFidelity) {
throw new NotImplementedException();
}
public TagNode(ITagSpan <TTag> ts, SpanTrackingMode trackingMode)
{
_snapshotSpan = ts.Span;
this.Span = ts.Span.CreateTrackingSpan(trackingMode);
this.Tag = ts.Tag;
}
public ITrackingSpan CreateTrackingSpan(Span span, SpanTrackingMode trackingMode, TrackingFidelityMode trackingFidelity) {
throw new NotImplementedException();
}
public ITrackingSpan CreateTrackingSpan(int start, int length, SpanTrackingMode trackingMode, TrackingFidelityMode trackingFidelity)
{
throw new NotImplementedException();
}
public NormalizedSnapshotSpanCollection MapUpToSnapshot(SnapshotSpan span, SpanTrackingMode trackingMode, ITextSnapshot targetSnapshot) {
throw new NotImplementedException();
}
public ITrackingSpan CreateTrackingSpan(int start, int length, SpanTrackingMode trackingMode)
{
return(new MockTrackingSpan(this, start, length, trackingMode));
}
public NormalizedSnapshotSpanCollection MapDownToBuffer(SnapshotSpan span, SpanTrackingMode trackingMode, ITextBuffer targetBuffer) {
throw new NotImplementedException();
}
public ITrackingSpan CreateTrackingSpan(Span span, SpanTrackingMode trackingMode, TrackingFidelityMode trackingFidelity)
{
throw new NotImplementedException();
}
public ITrackingSpan CreateTrackingSpan(Span span, SpanTrackingMode trackingMode) => Version.CreateTrackingSpan(span, trackingMode);
public ITrackingSpan CreateTrackingSpan(Span span, SpanTrackingMode trackingMode)
{
return(new MockTrackingSpan(this, span.Start, span.Length, trackingMode));
}
public ITrackingSpan CreateTrackingSpan(int start, int length, SpanTrackingMode trackingMode) => Version.CreateTrackingSpan(start, length, trackingMode);
public static ITrackingSpan CreateTrackingSpan(this SnapshotSpan snapshotSpan, SpanTrackingMode trackingMode) => snapshotSpan.Snapshot.CreateTrackingSpan(snapshotSpan.Span, trackingMode);
public static ITrackingSpan CreateTrackingSpan(this SnapshotSpan snapshotSpan, SpanTrackingMode trackingMode)
{
return snapshotSpan.Snapshot.CreateTrackingSpan(snapshotSpan.Span, trackingMode);
}
public NormalizedSnapshotSpanCollection MapDownToFirstMatch(SnapshotSpan span, SpanTrackingMode trackingMode, Predicate <ITextSnapshot> match)
{
if (span.Snapshot == null)
{
throw new ArgumentException();
}
if (match == null)
{
throw new ArgumentNullException(nameof(match));
}
if (span.Snapshot.TextBuffer != TopBuffer)
{
return(NormalizedSnapshotSpanCollection.Empty);
}
if (!match(TopBuffer.CurrentSnapshot))
{
return(NormalizedSnapshotSpanCollection.Empty);
}
return(new NormalizedSnapshotSpanCollection(span.TranslateTo(TopBuffer.CurrentSnapshot, trackingMode)));
}
public FakeTrackingSpan(Span span, SpanTrackingMode trackingMode)
{
this.span = span;
this.trackingMode = trackingMode;
}
public Span TrackTo(VersionedSpan span, SpanTrackingMode mode)
{
throw new NotSupportedException();
}
