public IEnumerable <ITagSpan <IErrorTag> > GetTags(NormalizedSnapshotSpanCollection snapshotSpans)
{
var list = new List <TagSpan <IErrorTag> >();
IList <ErrorTask> errors = this.errorListProvider.GetErrors(this.fileName);
var snapshot = buffer.CurrentSnapshot;
foreach (SnapshotSpan snapshotSpan in snapshotSpans)
{
foreach (var error in errors)
{
if (error.Line > snapshotSpan.Snapshot.LineCount)
{
continue;
}
var lintTag = new LintTag(error.Text);
Span errorSpan = GetErrorSpan(snapshotSpan.Snapshot, error);
var tagSpan = new TagSpan <IErrorTag>(new SnapshotSpan(snapshotSpan.Snapshot, errorSpan), lintTag);
list.Add(tagSpan);
}
}
return(list);
}
private bool TryGetUrlSpan(int line, int column, out ITagSpan <IUrlTag> urlSpan)
{
urlSpan = null;
SnapshotPoint point;
if (!TryToSnapshotPoint(TextView.TextSnapshot, line, column, out point))
{
return(false);
}
SnapshotSpan span = new SnapshotSpan(point, 0);
foreach (IMappingTagSpan <IUrlTag> current in _urlTagAggregator.GetTags(span))
{
NormalizedSnapshotSpanCollection spans = current.Span.GetSpans(TextView.TextSnapshot);
if (spans.Count == 1 && spans[0].Length == current.Span.GetSpans(current.Span.AnchorBuffer)[0].Length && spans[0].Contains(span.Start))
{
urlSpan = new TagSpan <IUrlTag>(spans[0], current.Tag);
return(true);
}
}
return(false);
}
private void ProcessTokenSpan(SnapshotSpan tokenSpan, TokenBuilder tokenBuilder, StatementBuilder statementBuilder)
{
var tokenTags = ProcessToken(tokenSpan);
tokenBuilder.Position += tokenTags.Consumed;
// Track preprocessors, but don't process them in our statements
if (tokenTags.ClassifierTagSpan != null && tokenTags.ClassifierTagSpan.Tag.TokenType.IsPreprocessor())
{
var preprocessorTagSpan = new TagSpan <IGLSLTag>(tokenTags.ClassifierTagSpan.Span, tokenTags.ClassifierTagSpan.Tag);
_statements.Append(preprocessorTagSpan);
}
else
{
var token = tokenSpan.GetText();
statementBuilder.AppendTokenTags(tokenTags);
// Process the statement once we encounter either a ';' or '{' character
if ((tokenTags.ClassifierTagSpan != null && tokenTags.ClassifierTagSpan.Tag.TokenType == GLSLTokenTypes.Semicolon) || token == "{")
{
var statement = statementBuilder.ProcessStatement(_bracketTagger, _functionTagger, _variableTagger);
_statements.Append(statement);
}
}
}
private static TagSpan GetOutlineSpan(ITextSnapshot snapshot, IOutlinableResult outlineResult)
{
TagSpan tagSpan = null;
try
{
int length = outlineResult.EndIndex - outlineResult.StartIndex;
if (length > 0)
{
var headerLength = outlineResult.DecoratorEnd - outlineResult.DecoratorStart;
ITextSnapshotLine startLine;
if ((startLine = snapshot.GetLineFromPosition(outlineResult.DecoratorStart)).LineNumber !=
snapshot.GetLineNumberFromPosition(outlineResult.DecoratorEnd))
{
// the decorator range spans multiple lines, so we want to truncate that
headerLength = startLine.End.Position - outlineResult.DecoratorStart;
}
Span headerSpan = new Span(outlineResult.DecoratorStart, headerLength);
var span = GetFinalSpan(snapshot, outlineResult.StartIndex, length);
tagSpan = new TagSpan(
new SnapshotSpan(snapshot, span),
new OutliningTag(snapshot, headerSpan, span, true)
);
}
}
catch (ArgumentException)
{
// sometimes Python's parser gives us bad spans, ignore those and fix the parser
Debug.Assert(false, "bad argument when making span/tag");
}
return(tagSpan);
}
public IEnumerable <ITagSpan <IOutliningRegionTag> > GetTags(NormalizedSnapshotSpanCollection spans)
{
//Debug.WriteLine($"GetTags({spans}) begin");
var oldSnapshot = _oldSnapshot;
var outlining = _outlining;
foreach (var span in spans)
{
var translatedSnapshotSpan = span.TranslateTo(oldSnapshot, SpanTrackingMode.EdgeExclusive);
var translatedSpan = translatedSnapshotSpan.Span;
var nSpan = new NSpan(translatedSpan.Start, translatedSpan.End);
var info = new OutliningInfo(nSpan, false, false);
foreach (var currentInfo in outlining)
{
var currentSpan = currentInfo.Span;
if (!nSpan.IntersectsWith(currentSpan))
{
continue;
}
var tagSpan = new TagSpan <IOutliningRegionTag>(
new SnapshotSpan(oldSnapshot, new Span(currentSpan.StartPos, currentSpan.Length))
.TranslateTo(span.Snapshot, SpanTrackingMode.EdgeExclusive),
new OutliningRegionTag(currentInfo.IsDefaultCollapsed, currentInfo.IsImplementation, "...", "colapsed code..."));
Debug.WriteLine($" tagSpan={{Start={tagSpan.Span.Start.Position}, Len={tagSpan.Span.Length}}}");
yield return(tagSpan);
}
//Debug.WriteLine($"GetTags({spans}) end");
}
}
public IEnumerable <ITagSpan <IErrorTag> > GetTags(NormalizedSnapshotSpanCollection spans)
{
if (this._collectedTags.Count <= 0)
{
yield break;
}
foreach (var span in spans)
{
foreach (var tag in this._collectedTags)
{
var snapshot = span.Snapshot;
var trackingSpanSpan = tag.TrackingSpan.GetSpan(snapshot);
if (!trackingSpanSpan.IntersectsWith(span))
{
continue;
}
var tagSpan = new TagSpan <IErrorTag>(
new SnapshotSpan(snapshot, trackingSpanSpan),
tag
);
yield return(tagSpan);
}
}
}
public IEnumerable <ITagSpan <IErrorTag> > GetTags(NormalizedSnapshotSpanCollection snapshotSpans)
{
var list = new List <TagSpan <IErrorTag> >();
if (this.tags.Count > 0)
{
foreach (var snapshotSpan in snapshotSpans)
{
foreach (var tag in this.tags)
{
var snapshot = snapshotSpan.Snapshot;
var span = tag.TrackingSpan.GetSpan(snapshot);
if (span.IntersectsWith(snapshotSpan))
{
var tagSpan = new TagSpan <IErrorTag>(new SnapshotSpan(snapshot, span), tag);
list.Add(tagSpan);
}
}
}
}
return(list);
}
private void ProcessSpansWorker(
TaggerContext <TRegionTag> context,
SnapshotSpan snapshotSpan,
BlockStructureService outliningService,
ImmutableArray <BlockSpan> spans)
{
if (spans != null)
{
var snapshot = snapshotSpan.Snapshot;
spans = GetMultiLineRegions(outliningService, spans, snapshot);
// Create the outlining tags.
var tagSpanStack = new Stack <TagSpan <TRegionTag> >();
foreach (var region in spans)
{
var spanToCollapse = new SnapshotSpan(snapshot, region.TextSpan.ToSpan());
while (tagSpanStack.Count > 0 &&
tagSpanStack.Peek().Span.End <= spanToCollapse.Span.Start)
{
tagSpanStack.Pop();
}
var parentTag = tagSpanStack.Count > 0 ? tagSpanStack.Peek() : null;
var tag = CreateTag(parentTag?.Tag, snapshot, region);
var tagSpan = new TagSpan <TRegionTag>(spanToCollapse, tag);
context.AddTag(tagSpan);
tagSpanStack.Push(tagSpan);
}
}
}
private IEnumerable <ITagSpan <T> > getTagsFromCacheFor(IEnumerable <SnapshotSpan> spans)
{
List <ITagSpan <T> > result = new List <ITagSpan <T> >();
if (!GlobalSettings.shouldShowIssueLinks(buffer.CurrentSnapshot.LineCount))
{
return(result);
}
JiraServer selectedServer = AtlassianPanel.Instance.Jira.CurrentlySelectedServerOrDefault;
if (selectedServer == null)
{
return(result);
}
int lastLine = -1;
foreach (SnapshotSpan span in spans)
{
foreach (TagCache.TagEntry tagEntry in tagCache.Entries)
{
if (tagEntry.Start >= span.Start && tagEntry.End <= span.End)
{
TagSpan <T> tag = getTagForKey(new SnapshotSpan(tagEntry.Start, tagEntry.End), tagEntry.IssueKey, lastLine);
lastLine = tagEntry.Start.GetContainingLine().LineNumber;
if (tag != null)
{
result.Add(tag);
}
}
}
}
return(result);
}
private void CalculateTagSpans()
{
Debug.WriteLine($"CalculateTagSpans, file={FilePath}, thread={Thread.CurrentThread.ManagedThreadId}");
_tagSpans = new List <ITagSpan <LintingErrorTag> >();
if (!ErrorListDataSource.Snapshots.ContainsKey(FilePath))
{
return;
}
List <LintingError> errors = ErrorListDataSource.Snapshots[FilePath].Errors; // Immutable snapshot
if (errors == null || errors.Count == 0)
{
return;
}
foreach (LintingError lintingError in errors)
{
LintingErrorTag lintingErrorTag = new LintingErrorTag(lintingError);
SnapshotPoint startSnapshotPoint = CalculateSnapshotPoint(lintingError.LineNumber, lintingError.ColumnNumber);
SnapshotPoint endSnapshotPoint = IsEndProvided(lintingError) ?
CalculateSnapshotPoint(lintingError.EndLineNumber.Value, lintingError.EndColumnNumber.Value) :
startSnapshotPoint; // snapshot [1, 1) does include character at 1
SnapshotSpan snapshotSpan = new SnapshotSpan(startSnapshotPoint, endSnapshotPoint);
ITagSpan <LintingErrorTag> tagSpan = new TagSpan <LintingErrorTag>(snapshotSpan, lintingErrorTag);
_tagSpans.Add(tagSpan);
}
}
public IEnumerable <ITagSpan <ClipsTokenTag> > GetTags(NormalizedSnapshotSpanCollection spans)
{
//Debug.WriteLine("GetTags");
foreach (SnapshotSpan curSpan in spans)
{
//Debug.WriteLine("curSpan = {0}", curSpan);
ITextSnapshotLine containingLine = curSpan.Start.GetContainingLine();
var lineStart = containingLine.Start.Position;
var position = lineStart;
var line = containingLine.GetText();
var lastToken = (string)null;
foreach (var token in Tokenize(line))
{
var type = GetTokenType(token, lastToken);
var tokenSpan = new SnapshotSpan(curSpan.Snapshot,
new Span(position, token.Length));
if (type != null && tokenSpan.IntersectsWith(curSpan))
{
var tag = new ClipsTokenTag(type);
var span = new TagSpan <ClipsTokenTag>(tokenSpan, tag);
//Debug.WriteLine("{0}", tag);
yield return(span);
}
if (type != PredefinedClassificationTypeNames.WhiteSpace)
{
lastToken = token;
}
position += token.Length;
}
}
}
private TokenTagCollection MatchSquareBrackets(SnapshotSpan span)
{
var tokenTags = new TokenTagCollection(span);
tokenTags.SetClassifierTag(GLSLTokenTypes.SquareBracket);
int start = span.Start;
if (!_squareBracketBuilder.Start.HasValue)
{
_squareBracketBuilder.Start = start;
string text = span.Snapshot.GetText();
int end = GetClosingPosition(text, start, '[', ']', _squareBracketBuilder);
if (end >= 0)
{
_squareBracketBuilder.End = end + 1;
var bracketSpan = _squareBracketBuilder.ToSpan();
_squareBracketBuilder.Clear();
int outlineEnd = _squareBracketBuilder.ConsumeUntil(text, start, "\r", "\n");
if (outlineEnd >= 0 && outlineEnd < end)
{
var collapseText = text.Substring(start, outlineEnd - start) + "...]";
var tagSpan = new TagSpan <GLSLOutlineTag>(bracketSpan, new GLSLOutlineTag(SQUARE_TOKEN_TYPE, collapseText));
tokenTags.AddOutlineTagSpan(tagSpan);
_squareBracketSpans.Add(tagSpan);
}
}
}
return(tokenTags);
}
protected override bool TryCreateTagSpan(SnapshotSpan span, RenameSpanKind type, out TagSpan <ITextMarkerTag> tagSpan)
{
ITextMarkerTag tagKind;
switch (type)
{
case RenameSpanKind.Reference:
tagKind = ValidTag.Instance;
break;
case RenameSpanKind.UnresolvedConflict:
tagKind = ConflictTag.Instance;
break;
case RenameSpanKind.Complexified:
tagKind = FixupTag.Instance;
break;
default:
throw ExceptionUtilities.UnexpectedValue(type);
}
tagSpan = new TagSpan <ITextMarkerTag>(span, tagKind);
return(true);
}
IEnumerable <ITagSpan <T> > ITagger <T> .GetTags(NormalizedSnapshotSpanCollection spans)
{
var result = new List <ITagSpan <T> >();
if (spans == null || fccEngine.CoverageLines == null)
{
return(result);
}
foreach (var span in spans)
{
if (!span.Snapshot.TextBuffer.Properties.TryGetProperty(typeof(ITextDocument), out ITextDocument document))
{
continue;
}
var startLineNumber = span.Start.GetContainingLine().LineNumber + 1;
var endLineNumber = span.End.GetContainingLine().LineNumber + 1;
var coverageLines = GetLines(document.FilePath, startLineNumber, endLineNumber);
foreach (var coverageLine in coverageLines)
{
var tag = new GlyphTag(coverageLine);
var tagSpan = new TagSpan <GlyphTag>(span, tag);
var iTagSpan = tagSpan as ITagSpan <T>;
result.Add(iTagSpan);
}
}
return(result);
}
protected override Tuple <ITextSnapshot, List <ITagSpan <ITextMarkerTag> > > GetTags(ITextSnapshot snapshot, CancellationToken cancellationToken)
{
if (snapshot != _textView.TextSnapshot)
{
return(Tuple.Create(snapshot, _emptyList));
}
var syntaxTree = snapshot.GetSyntaxTree(cancellationToken);
var unmappedPosition = _textView.GetPosition(snapshot);
var position = syntaxTree.MapRootFilePosition(unmappedPosition);
var result = _braceMatcher.MatchBraces(syntaxTree, position);
if (!result.IsValid)
{
return(Tuple.Create(snapshot, _emptyList));
}
var leftTag = new TagSpan <ITextMarkerTag>(new SnapshotSpan(snapshot, result.Left.Start, result.Left.Length), _tag);
var rightTag = new TagSpan <ITextMarkerTag>(new SnapshotSpan(snapshot, result.Right.Start, result.Right.Length), _tag);
return(Tuple.Create(snapshot, new List <ITagSpan <ITextMarkerTag> > {
leftTag, rightTag
}));
}
private ReadOnlyCollection <ITagSpan <MarkGlyphTag> > GetTags(SnapshotSpan span)
{
if (_glyphPairs.Count == 0)
{
return(s_emptyTagList);
}
var snapshot = span.Snapshot;
var list = new List <ITagSpan <MarkGlyphTag> >();
VimTrace.TraceInfo($"MarkGlyphTagger::GetTags: starting...");
foreach (var pair in _glyphPairs)
{
var chars = pair.Item1;
var lineNumber = pair.Item2;
if (lineNumber < snapshot.LineCount)
{
var line = snapshot.GetLineFromLineNumber(lineNumber);
var startSpan = new SnapshotSpan(line.Start, 0);
if (span.Contains(startSpan))
{
VimTrace.TraceInfo($"MarkGlyphTagger::GetTags: tag {lineNumber} {chars}");
var tag = new MarkGlyphTag(chars);
var tagSpan = new TagSpan <MarkGlyphTag>(startSpan, tag);
list.Add(tagSpan);
}
}
}
return(list.ToReadOnlyCollectionShallow());
}
public IEnumerable <ITagSpan <IconFileNameMarkerTag> > GetTags(NormalizedSnapshotSpanCollection spans)
{
var jsonDocument = JsonEditorDocument.FromTextBuffer(buffer);
var treeRoot = jsonDocument.DocumentNode;
var result = new List <ITagSpan <IconFileNameMarkerTag> >();
var visitor = new NodeVisitor(
(item) =>
{
if (item is MemberNode property)
{
string propertyName = property.Name.GetCanonicalizedText();
if ((propertyName == "color" || propertyName == "outline") && (property.Value != null))
{
var markerSpan = new SnapshotSpan(buffer.CurrentSnapshot, property.Value.Start, property.Value.Span.Length);
var tagSpan = new TagSpan <IconFileNameMarkerTag>(markerSpan, new IconFileNameMarkerTag());
result.Add(tagSpan);
return(VisitNodeResult.SkipChildren);
}
}
return(VisitNodeResult.Continue);
});
treeRoot.Accept(visitor);
return(result);
}
public IEnumerable <ITagSpan <IErrorTag> > GetTags(NormalizedSnapshotSpanCollection snapshotSpans)
{
var list = new List <TagSpan <IErrorTag> >();
List <LintingError> errors = TableDataSource.Instance.GetErrors(this.fileName);
var snapshot = buffer.CurrentSnapshot;
foreach (SnapshotSpan snapshotSpan in snapshotSpans)
{
foreach (LintingError error in errors)
{
if (error.LineNumber > snapshotSpan.Snapshot.LineCount)
{
continue;
}
var lintTag = new LintTag(error.Message);
Span errorSpan = GetErrorSpan(snapshotSpan.Snapshot, error);
var tagSpan = new TagSpan <IErrorTag>(new SnapshotSpan(snapshotSpan.Snapshot, errorSpan), lintTag);
list.Add(tagSpan);
}
}
return(list);
}
private TokenTagCollection MatchParentheses(SnapshotSpan span)
{
var tokenTags = new TokenTagCollection(span);
tokenTags.SetClassifierTag(GLSLTokenTypes.Parenthesis);
int start = span.Start;
if (!_parenthesisBuilder.Start.HasValue)
{
_parenthesisBuilder.Start = start;
string text = span.Snapshot.GetText();
int end = GetClosingPosition(text, start, '(', ')', _parenthesisBuilder);
if (end >= 0)
{
_parenthesisBuilder.End = end + 1;
var parenthesisSpan = _parenthesisBuilder.ToSpan();
_parenthesisBuilder.Clear();
int outlineEnd = _parenthesisBuilder.ConsumeUntil(text, start, "\r", "\n");
if (outlineEnd >= 0 && outlineEnd < end)
{
var collapseText = text.Substring(start, outlineEnd - start) + "...)";
var tagSpan = new TagSpan <GLSLOutlineTag>(parenthesisSpan, new GLSLOutlineTag(PARENTHESIS_TOKEN_TYPE, collapseText));
tokenTags.AddOutlineTagSpan(tagSpan);
_parenthesisSpans.Add(tagSpan);
}
}
}
return(tokenTags);
}
protected virtual bool TryRecalculateTags(int revision, SnapshotPoint point, int searchDistance, out IEnumerable <TagSpan <TextMarkerTag> > tags)
{
// get the current char and the previous char
char currentText = point.GetChar();
// if current char is 0 (beginning of buffer), don't move it back
SnapshotPoint lastChar = point == 0 ? point : point - 1;
char lastText = lastChar.GetChar();
SnapshotSpan pairSpan = new SnapshotSpan();
if (IsMatchStartCharacter(currentText) && !IsInIgnoredSpan(Aggregator, point, TextView.Caret.Position.Affinity))
{
char closeChar = GetMatchCloseCharacter(currentText);
/* TODO: Need to improve handling of larger blocks. this won't highlight if the matching brace is more
* than 1 screen's worth of lines away. Changing this to 10 * TextView.TextViewLines.Count seemed
* to improve the situation.
*/
if (FindMatchingCloseChar(revision, point, Aggregator, currentText, closeChar, searchDistance, out pairSpan))
{
tags = new TagSpan <TextMarkerTag>[]
{
new TagSpan <TextMarkerTag>(new SnapshotSpan(point, 1), PredefinedTextMarkerTags.BraceHighlight),
new TagSpan <TextMarkerTag>(pairSpan, PredefinedTextMarkerTags.BraceHighlight)
};
return(true);
}
else
{
tags = new TagSpan <TextMarkerTag> [0];
return(false);
}
}
else if (IsMatchCloseCharacter(lastText) && !IsInIgnoredSpan(Aggregator, point, TextView.Caret.Position.Affinity))
{
var open = GetMatchOpenCharacter(lastText);
if (FindMatchingOpenChar(revision, lastChar, Aggregator, open, lastText, searchDistance, out pairSpan))
{
tags = new TagSpan <TextMarkerTag>[]
{
new TagSpan <TextMarkerTag>(new SnapshotSpan(lastChar, 1), PredefinedTextMarkerTags.BraceHighlight),
new TagSpan <TextMarkerTag>(pairSpan, PredefinedTextMarkerTags.BraceHighlight)
};
return(true);
}
else
{
tags = new TagSpan <TextMarkerTag> [0];
return(false);
}
}
else
{
// successfully identified that there are no matching braces
tags = new TagSpan <TextMarkerTag> [0];
return(true);
}
}
public IEnumerable <ITagSpan <ClassificationTag> > GetTags(NormalizedSnapshotSpanCollection spans)
{
try
{
if (_grammar_description == null)
{
yield break;
}
if (_grammar_description == null)
{
throw new Exception();
}
string f = _buffer.GetFFN().Result;
var document = Workspaces.Workspace.Instance.FindDocument(f);
if (document == null)
{
yield break;
}
document.Code = _buffer.GetBufferText();
var pd = ParserDetailsFactory.Create(document);
}
catch (Exception exception)
{
Logger.Log.Notify(exception.StackTrace);
}
List <IMappingTagSpan <AntlrTokenTag> > span_list = null;
try
{
span_list = _aggregator.GetTags(spans).ToList();
}
catch (Exception exception)
{
Logger.Log.Notify(exception.StackTrace);
}
if (span_list != null)
{
foreach (IMappingTagSpan <AntlrTokenTag> tag_span in span_list)
{
TagSpan <ClassificationTag> result = null;
try
{
NormalizedSnapshotSpanCollection tag_spans = tag_span.Span.GetSpans(spans[0].Snapshot);
result = new TagSpan <ClassificationTag>(tag_spans[0],
new ClassificationTag(_antlrtype_to_classifiertype[(int)tag_span.Tag.TagType]));
}
catch (Exception exception)
{
Logger.Log.Notify(exception.StackTrace);
}
if (result != null)
{
yield return(result);
}
}
}
}
private void GetSelectCommandTag(ITextSnapshot newSnapshot, string selectOp, int offset)
{
Span span = new Span(offset, selectOp.Length);
SnapshotSpan snapshotSpan = new SnapshotSpan(newSnapshot, span);
var tag = new TagSpan <IClassificationTag>(snapshotSpan, new ClassificationTag(Provider[PXCodeType.BqlOperator]));
_tagsBag.Add(tag);
}
private IEnumerable <Tuple <SnapshotSpan, TagSpan <GherkinTokenTag> > > HandleSpan(SnapshotSpan span, GherkinParseEvent evt)
{
ITextSnapshotLine containingLine = span.Start.GetContainingLine();
var tokenSpan = new SnapshotSpan(span.Snapshot, new Span(containingLine.Start.Position, containingLine.Length));
var tagSpan = new TagSpan <GherkinTokenTag>(tokenSpan, new GherkinTokenTag(evt.GherkinTokenType));
yield return(new Tuple <SnapshotSpan, TagSpan <GherkinTokenTag> >(tokenSpan, tagSpan));
}
protected override ITagSpan <IErrorTag> CreateTagSpan(ITextSnapshot snapshot, Diagnostic rawTag)
{
var span = new Span(rawTag.Span.Start, rawTag.Span.Length);
var snapshotSpan = new SnapshotSpan(snapshot, span);
var errorTag = new ErrorTag(_errorType, rawTag.Message);
var errorTagSpan = new TagSpan <IErrorTag>(snapshotSpan, errorTag);
return(errorTagSpan);
}
private ITagSpan <IErrorTag> CreateTagSpan(ITextSnapshot snapshot, TextSpan textSpan, Diagnostic diagnostic, bool squigglesEnabled)
{
var span = new Span(textSpan.Start, textSpan.Length);
var snapshotSpan = new SnapshotSpan(snapshot, span);
var errorTag = new ErrorTag(_errorType, diagnostic.Message);
var errorTagSpan = new TagSpan <IErrorTag>(snapshotSpan, errorTag);
return(errorTagSpan);
}
private void CreateTag(ITextSnapshot newSnapshot, Match match, int offset, string tagContent, IClassificationType classType)
{
int startIndex = offset + match.Index + match.Value.IndexOf(tagContent);
Span span = new Span(startIndex, tagContent.Length);
SnapshotSpan snapshotSpan = new SnapshotSpan(newSnapshot, span);
var tag = new TagSpan <IClassificationTag>(snapshotSpan, new ClassificationTag(classType));
_tagsBag.Add(tag);
}
private static void AppendTagText(this SpannableStringBuilder spannable, TagSpan tagSpan)
{
var start = spannable.Length();
spannable.Append(tagSpan.TagName);
var end = spannable.Length();
spannable.SetSpan(new RelativeSizeSpan(spanSizeProportion), start, end, SpanTypes.ExclusiveExclusive);
spannable.SetSpan(new TagsTokenSpan(tagSpan.TagId, tagSpan.TagName), start, end, SpanTypes.ExclusiveExclusive);
}
private ReadOnlyCollection <ITagSpan <IntraTextAdornmentTag> > GetTagsCore(SnapshotSpan span)
{
var list = new List <ITagSpan <IntraTextAdornmentTag> >();
var offset = span.Start.Position;
var snapshot = span.Snapshot;
for (var i = 0; i < span.Length; i++)
{
var position = i + offset;
var c = snapshot[position];
if (!ControlCharUtil.TryGetDisplayText(c, out string text))
{
continue;
}
UIElement adornment;
if (TryFindIndex(position, out int cacheIndex))
{
adornment = _adornmentCache[cacheIndex].Adornment;
}
else
{
var textRunProperties = _classificationFormatMap.DefaultTextProperties;
var typeface = textRunProperties.Typeface;
var fontSize = textRunProperties.FontRenderingEmSize;
var textHeight = _textView.LineHeight;
var textBlock = new TextBlock
{
Text = text,
Foreground = _foregroundBrush,
Background = Brushes.Transparent,
FontFamily = typeface.FontFamily,
FontStretch = typeface.Stretch,
FontWeight = typeface.Weight,
FontStyle = typeface.Style,
FontSize = fontSize,
Height = textHeight,
LineHeight = textHeight != 0 ? textHeight : double.NaN,
LineStackingStrategy = LineStackingStrategy.BlockLineHeight,
BaselineOffset = 0,
};
textBlock.Measure(new Size(double.PositiveInfinity, double.PositiveInfinity));
adornment = textBlock;
_adornmentCache.Insert(cacheIndex, new AdornmentData(position, adornment));
}
var tag = new IntraTextAdornmentTag(adornment, null);
var adornmentSpan = new SnapshotSpan(snapshot, position, 1);
var tagSpan = new TagSpan <IntraTextAdornmentTag>(adornmentSpan, tag);
list.Add(tagSpan);
}
return(list.ToReadOnlyCollectionShallow());
}
protected override ITagSpan <IOutliningRegionTag> CreateTagSpan(ITextSnapshot snapshot, OutliningRegionSpan rawTag)
{
var textSpan = rawTag.Span;
var span = new Span(textSpan.Start, textSpan.Length);
var snapshotSpan = new SnapshotSpan(snapshot, span);
var hint = snapshot.GetText(span);
var tag = new OutliningRegionTag(false, false, rawTag.Text, hint);
var tagSpan = new TagSpan <IOutliningRegionTag>(snapshotSpan, tag);
return(tagSpan);
}
protected override bool TryCreateTagSpan(SnapshotSpan span, RenameSpanKind type, out TagSpan <IClassificationTag> tagSpan)
{
if (type == RenameSpanKind.Reference)
{
tagSpan = new TagSpan <IClassificationTag>(span, new ClassificationTag(_classificationType));
return(true);
}
tagSpan = null;
return(false);
}
private static IEnumerable<Tuple<SnapshotSpan, TagSpan<GherkinTokenTag>>> HandleText(
SnapshotSpan span, GherkinTokenType tokenType,
string surroundingText)
{
var str = span.GetText().TrimEnd(WhiteSpaces.Chars);
var idx = str.IndexOf(surroundingText, StringComparison.InvariantCulture);
var idx2 = str.LastIndexOf(surroundingText, StringComparison.InvariantCulture);
if (idx == -1 || idx2 == -1)
yield break;
ITextSnapshotLine containingLine = span.Start.GetContainingLine();
var tokenSpan = new SnapshotSpan(span.Snapshot, new Span(containingLine.Start.Position + idx, idx2 - idx + 1));
var tagSpan = new TagSpan<GherkinTokenTag>(tokenSpan, new GherkinTokenTag(tokenType));
yield return new Tuple<SnapshotSpan, TagSpan<GherkinTokenTag>>(tokenSpan, tagSpan);
}
private void CreateTag(SyntaxToken startToken, SyntaxToken endToken)
{
if (startToken == null || !startToken.Span.IsInRootFile
|| endToken == null || !endToken.Span.IsInRootFile)
return;
var span = new Span(startToken.Span.End, endToken.Span.End - startToken.Span.End);
if (_snapshot.GetLineNumberFromPosition(span.Start) == _snapshot.GetLineNumberFromPosition(span.End))
return;
var snapshotSpan = new SnapshotSpan(_snapshot, span);
var tag = new OutliningRegionTag("...", snapshotSpan.GetText());
var tagSpan = new TagSpan<IOutliningRegionTag>(snapshotSpan, tag);
_results.Add(tagSpan);
}
private void OutlineBlock(CommonTree subchild)
{
if (subchild == null || subchild.Type != LBRACE)
return;
var startToken = _tokens[subchild.TokenStartIndex];
var stopToken = _tokens[subchild.TokenStopIndex];
Span span = new Span(startToken.StartIndex, stopToken.StopIndex - startToken.StartIndex + 1);
if (_snapshot.GetLineNumberFromPosition(span.Start) == _snapshot.GetLineNumberFromPosition(span.End))
return;
SnapshotSpan snapshotSpan = new SnapshotSpan(_snapshot, span);
IOutliningRegionTag tag = new OutliningRegionTag();
TagSpan<IOutliningRegionTag> tagSpan = new TagSpan<IOutliningRegionTag>(snapshotSpan, tag);
_outliningRegions.Add(tagSpan);
}
public List<TagSpan<IOutliningRegionTag>> GetOutlineSpan(SyntaxNode node, ITextSnapshot textSnapshot,
IdeServices ideServices)
{
var ret = new List<TagSpan<IOutliningRegionTag>>();
var sectionSyntax = node as SwitchSectionSyntax;
if (sectionSyntax == null)
{
return ret;
}
var hint = CollapsedHintCreator.GetHint(
new SnapshotSpan(textSnapshot, sectionSyntax.FullSpan.Start,
sectionSyntax.FullSpan.Length),
ideServices);
var span = new TagSpan<IOutliningRegionTag>(
new SnapshotSpan(textSnapshot,
sectionSyntax.Statements.FullSpan.Start - 1,
sectionSyntax.Statements.FullSpan.Length - 1),
new OutliningRegionTag(isDefaultCollapsed: false, isImplementation: true,
collapsedForm: "...", collapsedHintForm:hint));
ret.Add(span);
return ret;
}
public List<TagSpan<IOutliningRegionTag>> GetOutlineSpan(SyntaxNode node, ITextSnapshot textSnapshot,
IdeServices ideServices)
{
var ret = new List<TagSpan<IOutliningRegionTag>>();
var text = node.Parent.GetText();
var isOneLineBlock = text.Lines.Count <= 2;
if (isOneLineBlock)
{
return ret;
}
var hint = CollapsedHintCreator.GetHint(
new SnapshotSpan(textSnapshot, node.Parent.FullSpan.Start, node.Parent.FullSpan.Length),
ideServices);
var span = new TagSpan<IOutliningRegionTag>(
new SnapshotSpan(textSnapshot,
node.FullSpan.Start - 1,
GetSpanLength(node)),
new OutliningRegionTag(isDefaultCollapsed: false, isImplementation: true,
collapsedForm: "...", collapsedHintForm: hint));
ret.Add(span);
return ret;
}
private Tuple<SnapshotSpan, TagSpan<GherkinTokenTag>> CreateTag(Token token, SnapshotSpan span, GherkinTokenType tokenType, string text)
{
foreach (var row in token.Content.Split(new[] { '\n' }, StringSplitOptions.RemoveEmptyEntries))
{
string rowText = row.Trim(WhiteSpaces.Chars);
var idx = text.IndexOf(rowText, StringComparison.Ordinal);
if (idx == -1)
continue;
ITextSnapshotLine containingLine = span.Start.GetContainingLine();
var tokenSpan = new SnapshotSpan(span.Snapshot, new Span(containingLine.Start.Position + idx, rowText.Length));
var tagSpan = new TagSpan<GherkinTokenTag>(tokenSpan, new GherkinTokenTag(tokenType));
return new Tuple<SnapshotSpan, TagSpan<GherkinTokenTag>>(tokenSpan, tagSpan);
}
return null;
}
private IEnumerable<Tuple<SnapshotSpan, TagSpan<GherkinTokenTag>>> HandleDocString(SnapshotSpan span, GherkinParseEvent evt)
{
var text = span.GetText().Trim(WhiteSpaces.Chars);
if (text == "\"\"\"")
return HandleText(span, GherkinTokenType.Tag, "\"");
//TODO: dont color the spaces that will be removed
ITextSnapshotLine containingLine = span.Start.GetContainingLine();
var tokenSpan = new SnapshotSpan(span.Snapshot, new Span(containingLine.Start.Position, containingLine.Length));
var tagSpan = new TagSpan<GherkinTokenTag>(tokenSpan, new GherkinTokenTag(evt.GherkinTokenType));
return new[] { new Tuple<SnapshotSpan, TagSpan<GherkinTokenTag>>(tokenSpan, tagSpan) };
}
private IEnumerable<Tuple<SnapshotSpan, TagSpan<GherkinTokenTag>>> HandleSpan(SnapshotSpan span, GherkinParseEvent evt)
{
ITextSnapshotLine containingLine = span.Start.GetContainingLine();
var tokenSpan = new SnapshotSpan(span.Snapshot, new Span(containingLine.Start.Position, containingLine.Length));
var tagSpan = new TagSpan<GherkinTokenTag>(tokenSpan, new GherkinTokenTag(evt.GherkinTokenType));
yield return new Tuple<SnapshotSpan, TagSpan<GherkinTokenTag>>(tokenSpan, tagSpan);
}
/// <summary>
/// Create tags at the specified SnapshotSpan values
/// </summary>
private void CreateTags(params SnapshotSpan[] spans)
{
var list = new List<ITagSpan<ITag>>();
foreach (var span in spans)
{
var tagSpan = new TagSpan<ITag>(
span,
_factory.Create<ITag>().Object);
list.Add(tagSpan);
}
_tagger.Setup(x => x.GetTags(It.IsAny<NormalizedSnapshotSpanCollection>())).Returns(list);
}
private void CreateTag(SyntaxToken token, IClassificationType classificationType)
{
if (token == null || !token.Span.IsInRootFile)
return;
var snapshotSpan = new SnapshotSpan(_snapshot, token.Span.Start, token.Span.Length);
var tag = new ClassificationTag(classificationType);
var tagSpan = new TagSpan<IClassificationTag>(snapshotSpan, tag);
_results.Add(tagSpan);
}
private Tuple<SnapshotSpan, TagSpan<GherkinTokenTag>> HandleType(SnapshotSpan span, Token token, GherkinTokenType tokenType)
{
var text = span.GetText();
if (text.TrimStart(WhiteSpaces.Chars).StartsWith(token.Content))
{
var idx = text.IndexOf(token.Content, StringComparison.Ordinal);
ITextSnapshotLine containingLine = span.Start.GetContainingLine();
var tokenSpan = new SnapshotSpan(span.Snapshot, new Span(containingLine.Start.Position + idx, token.Content.Length));
var tagSpan = new TagSpan<GherkinTokenTag>(tokenSpan, new GherkinTokenTag(tokenType));
return new Tuple<SnapshotSpan, TagSpan<GherkinTokenTag>>(tokenSpan, tagSpan);
}
return null;
}
public List<TagSpan<IOutliningRegionTag>> GetOutlineSpans(SyntaxNode node, ITextSnapshot textSnapshot,
IdeServices ideServices)
{
var ret = new List<TagSpan<IOutliningRegionTag>>();
var isBlock = IsBlock(node);
if (!isBlock)
{
return ret;
}
// always has an extra empty line?
var text = node.GetText();
var isOnlineBlock = text.Lines.Count <= 2;
if (isOnlineBlock)
{
return ret;
}
if (node.IsKind(SyntaxKind.MultiLineIfBlock))
{
var additionalSpan = AddAdditionalOutlinerForIfStatement(node, textSnapshot, ideServices);
if (additionalSpan != null)
{
ret.Add(additionalSpan);
}
}
var hint = GetCodeHint(textSnapshot, ideServices, node.FullSpan.Start, node.FullSpan.Length);
var span = new TagSpan<IOutliningRegionTag>(
new SnapshotSpan(textSnapshot, GetSpanStartPosition(node, text), GetSpanLength(node, text)),
new OutliningRegionTag(isDefaultCollapsed: false, isImplementation: true,
collapsedForm: "...", collapsedHintForm: hint));
ret.Add(span);
return ret;
}
private IEnumerable<Tuple<SnapshotSpan, TagSpan<GherkinTokenTag>>> HandleTitle(SnapshotSpan span, Token token, GherkinTokenType tokenType)
{
var spanText = span.GetText();
var tokenText = token.Content.Split(new[] { '\n' }, StringSplitOptions.RemoveEmptyEntries).Select(_ => _.Trim(WhiteSpaces.Chars)).ToList();
foreach (var row in tokenText)
{
var idx = spanText.IndexOf(row, StringComparison.CurrentCulture);
if (idx == -1)
continue;
ITextSnapshotLine containingLine = span.Start.GetContainingLine();
var tokenSpan = new SnapshotSpan(span.Snapshot, new Span(containingLine.Start.Position + idx, row.Length));
var tagSpan = new TagSpan<GherkinTokenTag>(tokenSpan, new GherkinTokenTag(tokenType));
yield return new Tuple<SnapshotSpan, TagSpan<GherkinTokenTag>>(tokenSpan, tagSpan);
}
}
private static TagSpan<IOutliningRegionTag> AddAdditionalOutlinerForIfStatement(SyntaxNode node,
ITextSnapshot textSnapshot, IdeServices ideServices)
{
var multiLineIf = node as MultiLineIfBlockSyntax;
Debug.Assert(multiLineIf != null, "multiLineIf != null");
var hasElse = multiLineIf.ElseIfBlocks.Any() || multiLineIf.ElseBlock != null;
if (multiLineIf.Statements.Count <= 1 || !hasElse)
{
return null;
}
var start = multiLineIf.Statements.Span.Start;
var len = multiLineIf.Statements.Span.Length;
var hint = GetCodeHint(textSnapshot, ideServices, multiLineIf.Statements.FullSpan.Start,
multiLineIf.Statements.FullSpan.Length);
var span = new TagSpan<IOutliningRegionTag>(
new SnapshotSpan(textSnapshot, start, len),
new OutliningRegionTag(isDefaultCollapsed: false, isImplementation: true,
collapsedForm: "...", collapsedHintForm: hint));
return span;
}
private bool TryGetUrlSpan(int line, int column, out ITagSpan<IUrlTag> urlSpan)
{
urlSpan = null;
SnapshotPoint point;
if (!TryToSnapshotPoint(TextView.TextSnapshot, line, column, out point))
return false;
SnapshotSpan span = new SnapshotSpan(point, 0);
foreach (IMappingTagSpan<IUrlTag> current in _urlTagAggregator.GetTags(span))
{
NormalizedSnapshotSpanCollection spans = current.Span.GetSpans(TextView.TextSnapshot);
if (spans.Count == 1 && spans[0].Length == current.Span.GetSpans(current.Span.AnchorBuffer)[0].Length && spans[0].Contains(span.Start))
{
urlSpan = new TagSpan<IUrlTag>(spans[0], current.Tag);
return true;
}
}
return false;
}
