public void GetTagsIgnoresDoubleQuotesAroundAttributeValue() { ITagSpan <ClassificationTag> lastSpan = this.GetTags("<#@ \"value\"").Last(); Assert.Equal(this.attributeValueClassification, lastSpan.Tag.ClassificationType); Assert.Equal("value", lastSpan.Span.GetText()); }
public void GetTagsIgnoresEqualsBetweenAttributeNameAndAttributeValue() { ITagSpan <ClassificationTag> lastSpan = this.GetTags("<#@ directive attribute =").Last(); Assert.Equal(this.attributeNameClassification, lastSpan.Tag.ClassificationType); Assert.Equal("attribute", lastSpan.Span.GetText()); }
/// <summary> /// The get tags. /// </summary> /// <param name="spans"> /// The spans. /// </param> /// <returns> /// The /// <see> /// <cref>IEnumerable</cref> /// </see> /// . /// </returns> public IEnumerable <ITagSpan <SonarTag> > GetTags(NormalizedSnapshotSpanCollection spans) { if (spans.Count == 0) { yield break; } if (spans.Count == 0) { yield break; } if (this.sonarTags.Count == 0) { yield break; } ITextSnapshot snapshot = spans[0].Snapshot; foreach (SonarTag tag in this.sonarTags) { ITagSpan <SonarTag> tagSpan = tag.ToTagSpan(snapshot); if (tagSpan.Span.Length == 0) { continue; } yield return(tagSpan); } }
/// <summary> /// The get tags. /// </summary> /// <param name="spans"> /// The spans. /// </param> /// <returns> /// The System.Collections.Generic.IEnumerable`1[T -> Microsoft.VisualStudio.Text.Tagging.ITagSpan`1[T -> /// SmartTags.Coverage.HighlightCoverageTag]]. /// </returns> public IEnumerable <ITagSpan <CoverageTag> > GetTags(NormalizedSnapshotSpanCollection spans) { if (spans.Count == 0) { yield break; } if (!SonarQubeViewModelFactory.SQViewModel.ServerViewModel.CoverageInEditorEnabled) { yield break; } if (this.coverageTags.Count == 0) { yield break; } ITextSnapshot snapshot = spans[0].Snapshot; foreach (CoverageTag tag in this.coverageTags) { ITagSpan <CoverageTag> tagSpan = tag.ToTagSpan(snapshot); if (tagSpan.Span.Length == 0) { continue; } yield return(tagSpan); } }
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 static bool IsUrlSpanValid(ITagSpan <IUrlTag> urlTagSpan) { return(urlTagSpan != null && urlTagSpan.Tag != null && urlTagSpan.Tag.Url != null && urlTagSpan.Tag.Url.IsAbsoluteUri); }
public void GetTagsReturnsAttributeValueSpanForAttributeValueToken() { ITagSpan <ClassificationTag> span = this.GetTags("<#@ \"value\" #>").ElementAt(1); Assert.Equal(this.attributeValueClassification, span.Tag.ClassificationType); Assert.Equal("value", span.Span.GetText()); }
void NavigateTo(ITagSpan<GoToDefinitionTag> navigateToTagSpan) { _textView.Selection.Clear(); var location = navigateToTagSpan.Tag.Location; NavLanguagePackage.GoToLocationInPreviewTab(location); }
public bool Equals(ITagSpan <TTag> x, ITagSpan <TTag> y) { if (x.Span != y.Span) { return(false); } return(_tagComparer.Equals(x.Tag, y.Tag)); }
public void AddTag(ITagSpan <TTag> tag) { if (tag == null) { return; } _resultTagsList.Add(tag); }
bool GoToDiagnostic(ITagSpan <DiagnosticErrorTag> tagSpan) { if (tagSpan == null) { return(false); } return(_textView.TryMoveCaretToAndEnsureVisible(tagSpan.Span.Start, _outliningManagerService)); }
public void AddTag(ITagSpan <TTag> tag) { if (tag == null || CancellationToken.IsCancellationRequested) { return; } tagsQueue.Enqueue(tag); }
protected virtual bool IsMultilineTagSpan(ITagSpan <TTag> span) { Contract.Requires <ArgumentNullException>(span != null, "span"); if (span.Span.IsEmpty) { return(false); } return(span.Span.Start.GetContainingLine().LineNumber != span.Span.End.GetContainingLine().LineNumber); }
protected virtual bool IsMultilineTagSpan([NotNull] ITagSpan <TTag> span) { Requires.NotNull(span, nameof(span)); if (span.Span.IsEmpty) { return(false); } return(span.Span.Start.GetContainingLine().LineNumber != span.Span.End.GetContainingLine().LineNumber); }
private void AddOutliningTagToBQL(TextSpan span) { if (AcuminatorVSPackage.Instance?.UseBqlOutlining == false) { return; } ITagSpan <IOutliningRegionTag> tag = span.ToOutliningTagSpan(_tagger.Snapshot); _tagger.OutliningsTagsCache.AddTag(tag); }
private void AddOutliningTagToBQL(TextSpan span) { if (!_tagger.Provider.Package.UseBqlOutlining) { return; } ITagSpan <IOutliningRegionTag> tag = span.ToOutliningTagSpan(_tagger.Snapshot); _tagger.OutliningsTagsCache.AddTag(tag); }
public static void GetTagsReturnsErrorSpanForSemanticError() { var buffer = new FakeTextBuffer("<#@ include file=\" \" #>"); var tagger = new TemplateErrorTagger(buffer); var snapshotSpans = new NormalizedSnapshotSpanCollection(new SnapshotSpan(buffer.CurrentSnapshot, 0, buffer.CurrentSnapshot.Length)); ITagSpan <ErrorTag> errorSpan = tagger.GetTags(snapshotSpans).Single(); Assert.Equal(new Span(12, 8), errorSpan.Span); Assert.Contains("File", (string)errorSpan.Tag.ToolTipContent, StringComparison.OrdinalIgnoreCase); }
public IEnumerable <ITagSpan <IErrorTag> > GetTags(NormalizedSnapshotSpanCollection spans) { var result = GetErrorTag(spans); if (result != null) { _tagSpan = result; } return(result != null ? new[] { result } : Array.Empty <ITagSpan <IErrorTag> >()); }
private void ParseAndCache() { if (!Invalidated) { lock (Timer) Timer.Change(-1, -1); return; } try { Invalidated = false; var snapshot = Buffer.CurrentSnapshot; bool validDsl; var tokens = SyntaxParser.GetTokens(snapshot, out validDsl); var arr = new ITagSpan <DddTokenTag> [tokens.Length]; int previousLine = -1; ITextSnapshotLine line = null; for (int i = 0; i < tokens.Length; i++) { var d = tokens[i]; var t = d.Concept; if (t.Line != previousLine) { line = snapshot.GetLineFromLineNumber(t.Line - 1); previousLine = t.Line; } var span = new SnapshotSpan(snapshot, new Span(line.Start.Position + t.Column, t.Value.Length)); arr[i] = new TagSpan <DddTokenTag>(span, d); } if (!validDsl) { if (TagsEqual(Tags, arr)) { return; } } if (Invalidated) { return; } Tags = arr; TagsChanged(this, new SnapshotSpanEventArgs(new SnapshotSpan(snapshot, Span.FromBounds(0, snapshot.Length)))); lock (Timer) Timer.Change(1000, -1); } catch { lock (Timer) Timer.Change(5000, -1); } }
private static bool IsMultilineStringOrComment(ITagSpan <ClassificationTag> token) { if (token.Tag.ClassificationType.Classification == "string" && !(token.Span.GetText().StartsWith("'") || token.Span.GetText().StartsWith("\""))) { return(true); } if (token.Tag.ClassificationType.Classification == "comment" && !(token.Span.GetText().StartsWith("//") || token.Span.GetText().StartsWith("/*"))) { return(true); } return(false); }
public static void GetTagsReturnsOutliningRegionsSpanWithCollapsedHintFormShowingEllipsisAfter10Lines() { string codeBlock = "<#" + Environment.NewLine; for (int i = 1; i <= 10; i++) { codeBlock += "Line" + i + Environment.NewLine; } codeBlock += "#>"; ITagSpan <OutliningRegionTag> outliningSpan = GetTags(codeBlock).Single(); var expectedHint = string.Join( Environment.NewLine, codeBlock.Split(new[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries).Take(10).Concat(new[] { "..." })); Assert.Equal(expectedHint, outliningSpan.Tag.CollapsedHintForm); }
private void OnNewSearch(StartNewSearchEvent e) { if (!_textView.HasAggregateFocus || _textView.IsClosed) { return; } _searchMarkerViewModel.Update(e.Text, _textView.LineHeight, e.MatchNumber); if (_searcher != null) { return; } _searcher = new TagSpan <IntraTextAdornmentTag>( span: new SnapshotSpan(_buffer.CurrentSnapshot, new Span(e.StartPosition, 0)), tag: new IntraTextAdornmentTag(new SearcherWithMarker(_searchMarkerViewModel), null, PositionAffinity.Predecessor) ); _taggers.Add(0, _searcher); this.InvokeTagsChanged(TagsChanged, _buffer); }
private void AddOutliningTagToAttribute(AttributeListSyntax attributeListNode) { if (AcuminatorVSPackage.Instance?.UseBqlOutlining != true || attributeListNode.Attributes.Count > 1) { return; } AttributeSyntax attribute = attributeListNode.ChildNodes() .OfType <AttributeSyntax>() .FirstOrDefault(); if (attribute?.ArgumentList == null || attribute.ArgumentList.Arguments.Count == 0 || _cancellationToken.IsCancellationRequested) { return; } string collapsedText = GetAttributeName(attribute); ITagSpan <IOutliningRegionTag> tag = attributeListNode.Span.ToOutliningTagSpan(_tagger.Snapshot, collapsedText); _tagger.OutliningsTagsCache.AddTag(tag); }
private void HandleErrorChanged(object sender, EventArgs e) { if (_tagSpan != null) { TagsChanged?.Invoke(this, new SnapshotSpanEventArgs(_tagSpan.Span)); _tagSpan = null; } _error = _process.Error; if (_sink != null) { if (_error != null) { _sink.AddEntries(new[] { new XamlErrorTableEntry(_projectName, _path, _error) }, true); } else { _sink.RemoveAllEntries(); } } RaiseTagsChanged(_error); }
public TagNode(ITagSpan <TTag> ts, SpanTrackingMode trackingMode) { _snapshotSpan = ts.Span; this.Span = ts.Span.CreateTrackingSpan(trackingMode); this.Tag = ts.Tag; }
public int GetHashCode(ITagSpan <TTag> obj) { return(obj.Span.GetHashCode() ^ _tagComparer.GetHashCode(obj.Tag)); }
public void AddTag(ITagSpan <TTag> tag) { tagSpans.Add(tag); }
private bool IsSameTag(IClassificationTag c1, ITagSpan <IClassificationTag> c2) { return(c1.ClassificationType.Classification == c2.Tag.ClassificationType.Classification); }
void RemoveNavigateToTagSpan() { if (_navigateToTagSpan == null) { return; } UnderlineTagger.GetOrCreateSingelton(_textView.TextBuffer)?.RemoveUnderlineSpan(_navigateToTagSpan.Span); _navigateToTagSpan = null; _textView.VisualElement.Cursor = _overriddenCursor; }
public TagWrapper(ITagSpan <TTag> tag) { this.Span = tag.Span.Span; this.Tag = new Optional <ITagSpan <TTag> >(tag); }
private bool AreAdjacent(SnapshotSpan c1, ITagSpan <IClassificationTag> c2) { return(c1.End == c2.Span.Start); }
void UpdateNavigateToTagSpan(ITagSpan<GoToTag> navigateToTagSpan) { if(navigateToTagSpan.Span == _navigateToTagSpan?.Span) { // Theoretisch könnten sich die Tags dennoch unterscheiden... _navigateToTagSpan = navigateToTagSpan; return; } RemoveNavigateToTagSpan(); _navigateToTagSpan = navigateToTagSpan; UnderlineTagger.GetOrCreateSingelton(_textView.TextBuffer)?.AddUnderlineSpan(navigateToTagSpan.Span); _overriddenCursor = _textView.VisualElement.Cursor; _textView.VisualElement.Cursor = Cursors.Hand; }
public bool Equals(ITagSpan <TTag> tagSpan1, ITagSpan <TTag> tagSpan2) { return(_comparer.Equals(tagSpan1.Tag, tagSpan2.Tag)); }
private static bool IsUrlSpanValid(ITagSpan<IUrlTag> urlTagSpan) { return urlTagSpan != null && urlTagSpan.Tag != null && urlTagSpan.Tag.Url != null && urlTagSpan.Tag.Url.IsAbsoluteUri; }
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; }
bool GoToDiagnostic(ITagSpan<DiagnosticErrorTag> tagSpan) { if (tagSpan == null) { return false; } _outliningManager.ExpandAll(tagSpan.Span, c => c.IsCollapsed); _textView.Caret.MoveTo(tagSpan.Span.Start); _textView.ViewScroller.EnsureSpanVisible(tagSpan.Span); return true; }
void AddNavigateToTagSpan(ITagSpan<GoToDefinitionTag> navigateToTagSpan) { GoToDefinitionAdorner.GetOrCreate(_textView)?.SetNavigateToSpan(navigateToTagSpan.Span, () => NavigateTo(navigateToTagSpan)); }
private bool IsCloseGrouping(ITagSpan<ClassificationTag> token) { var text = token.Span.GetText(); return text == ")" || text == "}" || text == "]"; }
private bool IsOpenGrouping(ITagSpan<ClassificationTag> token) { var text = token.Span.GetText(); return text == "(" || text == "{" || text == "["; }
private static bool IsMultilineStringOrComment(ITagSpan<ClassificationTag> token) { if (token.Tag.ClassificationType.Classification == "string" && !(token.Span.GetText().StartsWith("'") || token.Span.GetText().StartsWith("\""))) { return true; } if (token.Tag.ClassificationType.Classification == "comment" && !(token.Span.GetText().StartsWith("//") || token.Span.GetText().StartsWith("/*"))) { return true; } return false; }