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; }