public static IElisionBuffer CreateElisionBufferWithoutIndentation(
this IProjectionBufferFactoryService factoryService,
IEditorOptions editorOptions,
IContentType contentType,
IEnumerable<SnapshotSpan> exposedSpans)
{
var spans = new NormalizedSnapshotSpanCollection(exposedSpans);
if (spans.Count > 0)
{
// BUG(6335): We have to make sure that the spans refer to the current snapshot of
// the buffer.
var buffer = spans.First().Snapshot.TextBuffer;
var currentSnapshot = buffer.CurrentSnapshot;
spans = new NormalizedSnapshotSpanCollection(
spans.Select(s => s.TranslateTo(currentSnapshot, SpanTrackingMode.EdgeExclusive)));
}
contentType = contentType ?? factoryService.ProjectionContentType;
var elisionBuffer = factoryService.CreateElisionBuffer(
null, spans, ElisionBufferOptions.None, contentType);
if (spans.Count > 0)
{
var snapshot = spans.First().Snapshot;
var buffer = snapshot.TextBuffer;
// We need to figure out the shorted indentation level of the exposed lines. We'll
// then remove that indentation from all lines.
var indentationColumn = DetermineIndentationColumn(editorOptions, spans);
var spansToElide = new List<Span>();
foreach (var span in spans)
{
var startLineNumber = snapshot.GetLineNumberFromPosition(span.Start);
var endLineNumber = snapshot.GetLineNumberFromPosition(span.End);
for (var lineNumber = startLineNumber; lineNumber <= endLineNumber; lineNumber++)
{
var line = snapshot.GetLineFromLineNumber(lineNumber);
var lineOffsetOfColumn = line.GetLineOffsetFromColumn(indentationColumn, editorOptions);
spansToElide.Add(Span.FromBounds(line.Start, line.Start + lineOffsetOfColumn));
}
}
elisionBuffer.ElideSpans(new NormalizedSpanCollection(spansToElide));
}
return elisionBuffer;
}
// Produces tags on the snapshot that the tag consumer asked for.
public virtual IEnumerable <ITagSpan <IntraTextAdornmentTag> > GetTags(NormalizedSnapshotSpanCollection spans)
{
if (spans == null || spans.Count == 0)
{
yield break;
}
// Translate the request to the snapshot that this tagger is current with.
var requestedSnapshot = spans[0].Snapshot;
var translatedSpans = new NormalizedSnapshotSpanCollection(spans.Select(span => span.TranslateTo(snapshot, SpanTrackingMode.EdgeExclusive)));
// Grab the adornments.
foreach (var tagSpan in GetAdornmentTagsOnSnapshot(translatedSpans))
{
// Translate each adornment to the snapshot that the tagger was asked about.
var span = tagSpan.Span.TranslateTo(requestedSnapshot, SpanTrackingMode.EdgeExclusive);
var tag = new IntraTextAdornmentTag(tagSpan.Tag.Adornment, tagSpan.Tag.RemovalCallback, tagSpan.Tag.Affinity);
yield return(new TagSpan <IntraTextAdornmentTag>(span, tag));
}
}
// Produces tags on the snapshot that the tag consumer asked for.
public virtual IEnumerable <ITagSpan <IntraTextAdornmentTag> > GetTags(NormalizedSnapshotSpanCollection spans)
{
if (spans == null || spans.Count == 0)
{
yield break;
}
// Translate the request to the snapshot that this tagger is current with.
ITextSnapshot requestedSnapshot = spans[0].Snapshot;
var translatedSpans = new NormalizedSnapshotSpanCollection(spans.Select(span => span.TranslateTo(this.snapshot, SpanTrackingMode.EdgeExclusive)));
// Grab the adornments.
var tags = GetAdornmentTagsOnSnapshot(translatedSpans).GetEnumerator();
while (tags.MoveNext())
{
var current = tags.Current;
SnapshotSpan span = current.Span.TranslateTo(requestedSnapshot, SpanTrackingMode.EdgeExclusive);
IntraTextAdornmentTag tag = new IntraTextAdornmentTag(current.Tag.Adornment, current.Tag.RemovalCallback, current.Tag.Affinity);
yield return(new TagSpan <IntraTextAdornmentTag>(span, tag));
}
}
public IEnumerable <ITagSpan <ClassificationTag> > GetTags(NormalizedSnapshotSpanCollection spans)
{
if (CurrentWord == null)
{
yield break;
}
// Hold on to a "snapshot" of the word spans and current word, so that the same collection is maintained throughout
SnapshotSpan currentWord = CurrentWord.Value;
NormalizedSnapshotSpanCollection wordSpans = WordSpans;
if (spans.Count == 0 || WordSpans.Count == 0)
{
yield break;
}
// If the requested snapshot isn't the same as the one the words are on, translate the spans to the expected snapshot
if (spans[0].Snapshot != wordSpans[0].Snapshot)
{
wordSpans = new NormalizedSnapshotSpanCollection(wordSpans.Select(span => span.TranslateTo(spans[0].Snapshot, SpanTrackingMode.EdgeExclusive)));
currentWord = currentWord.TranslateTo(spans[0].Snapshot, SpanTrackingMode.EdgeExclusive);
}
// First, yield back the word the cursor is under (if it overlaps)
// Note that this will yield back the same word again in the wordspans collection; the duplication here is expected.
if (spans.OverlapsWith(new NormalizedSnapshotSpanCollection(currentWord)))
{
yield return(new TagSpan <ClassificationTag>(currentWord, new ClassificationTag(TypeService.GetClassificationType(Constants.FONT_FORMAT_NAME))));
}
// Second, yield all the other words in the file
foreach (SnapshotSpan span in NormalizedSnapshotSpanCollection.Overlap(spans, wordSpans))
{
yield return(new TagSpan <ClassificationTag>(span, new ClassificationTag(TypeService.GetClassificationType(Constants.FONT_FORMAT_NAME))));
}
}
public IEnumerable <ITagSpan <HighlightWordTag> > GetTags(NormalizedSnapshotSpanCollection spans)
{
if (CurrentWord == null)
{
yield break;
}
SnapshotSpan currentWord = CurrentWord.Value;
NormalizedSnapshotSpanCollection wordSpans = WordSpans;
if (spans.Count == 0 || WordSpans.Count == 0)
{
yield break;
}
if (spans[0].Snapshot != wordSpans[0].Snapshot)
{
wordSpans = new NormalizedSnapshotSpanCollection(
wordSpans.Select(span => span.TranslateTo(spans[0].Snapshot, SpanTrackingMode.EdgeExclusive)));
currentWord = currentWord.TranslateTo(spans[0].Snapshot, SpanTrackingMode.EdgeExclusive);
}
foreach (SnapshotSpan span in NormalizedSnapshotSpanCollection.Overlap(spans, wordSpans))
{
yield return(new TagSpan <HighlightWordTag>(span, new HighlightWordTag()));
}
}
public static IProjectionBuffer CreateProjectionBufferWithoutIndentation(
this IProjectionBufferFactoryService factoryService,
IEditorOptions editorOptions,
IContentType?contentType,
IEnumerable <SnapshotSpan> exposedSpans
)
{
var spans = new NormalizedSnapshotSpanCollection(exposedSpans);
if (spans.Count > 0)
{
// BUG(6335): We have to make sure that the spans refer to the current snapshot of
// the buffer.
var buffer = spans.First().Snapshot.TextBuffer;
var currentSnapshot = buffer.CurrentSnapshot;
spans = new NormalizedSnapshotSpanCollection(
spans.Select(
s => s.TranslateTo(currentSnapshot, SpanTrackingMode.EdgeExclusive)
)
);
}
contentType ??= factoryService.ProjectionContentType;
var projectionBuffer = factoryService.CreateProjectionBuffer(
projectionEditResolver: null,
sourceSpans: Array.Empty <object>(),
options: ProjectionBufferOptions.None,
contentType: contentType
);
if (spans.Count > 0)
{
var finalSpans = new List <object>();
// We need to figure out the shorted indentation level of the exposed lines. We'll
// then remove that indentation from all lines.
var indentationColumn = DetermineIndentationColumn(editorOptions, spans);
foreach (var span in spans)
{
var snapshot = span.Snapshot;
var startLineNumber = snapshot.GetLineNumberFromPosition(span.Start);
var endLineNumber = snapshot.GetLineNumberFromPosition(span.End);
for (
var lineNumber = startLineNumber;
lineNumber <= endLineNumber;
lineNumber++
)
{
// Compute the span clamped to this line
var line = snapshot.GetLineFromLineNumber(lineNumber);
var finalSpanStart = Math.Max(line.Start, span.Start);
var finalSpanEnd = Math.Min(line.EndIncludingLineBreak, span.End);
// We'll only offset if our span doesn't already start at the start of the line. See the similar exclusion in
// DetermineIndentationColumn that this matches.
if (line.Start == finalSpanStart)
{
finalSpanStart += line.GetLineOffsetFromColumn(
indentationColumn,
editorOptions
);
// Paranoia: what if the indentation reversed our ordering?
if (finalSpanStart > finalSpanEnd)
{
finalSpanStart = finalSpanEnd;
}
}
// We don't expect edits to happen while this projection buffer is active. We'll choose EdgeExclusive so
// if they do we don't end up in any cases where there is overlapping source spans.
finalSpans.Add(
snapshot.CreateTrackingSpan(
Span.FromBounds(finalSpanStart, finalSpanEnd),
SpanTrackingMode.EdgeExclusive
)
);
}
}
projectionBuffer.InsertSpans(0, finalSpans);
}
return(projectionBuffer);
}
internal SnapshotMultipleSpanSourceCodeReader(NormalizedSnapshotSpanCollection spans)
{
_spans = spans;
_readers = spans.Select(s => new SnapshotSpanSourceCodeReader(s)).ToArray();
_index = 0;
}
public void AddSpans(NormalizedSnapshotSpanCollection snapshotSpanCollection)
{
// TODO: custom tracking spans!
var newTrackingSpans = snapshotSpanCollection.Select(ss => ss.Snapshot.CreateTrackingSpan(ss, SpanTrackingMode.EdgeInclusive, TrackingFidelityMode.Forward));
AddSpans(newTrackingSpans);
}
public IEnumerable <ClassifiedSpan> GetClassifiedSpans(NormalizedSnapshotSpanCollection spans)
{
return(spans
.Select(s => TextSpan.FromBounds(s.Start, s.End))
.SelectMany(s => Classifier.GetClassifiedSpans(SemanticModel, s, Workspace)));
}
internal SnapshotMultipleSpanSourceCodeReader(NormalizedSnapshotSpanCollection spans)
{
_spans = spans;
_readers = spans.Select(s => new SnapshotSpanSourceCodeReader(s)).ToArray();
_index = 0;
}
/// <summary>
/// Get the text of the given spans.
/// If there are multiple spans, then return the concatenation of the text of each span plus a newline character,
/// otherwise, simply return the text of the only span.
/// </summary>
private string GetText(NormalizedSnapshotSpanCollection spans)
{
Debug.Assert(spans.Count > 0);
if (spans.Count > 1)
{
var builder = new StringBuilder();
builder.Append(string.Join(EditorOperations.Options.GetNewLineCharacter(), spans.Select((span) => span.GetText()).ToArray()));
// Append one last newline character
builder.Append(EditorOperations.Options.GetNewLineCharacter());
return builder.ToString();
}
else
{
return spans[0].GetText();
}
}