private void OnTagsChanged(object sender, BatchedTagsChangedEventArgs e)
{
// Remove any unnecessary adornments from the cache. To do that we need to ask the aggregator
// for all of its tags.
var wholeSpan = new SnapshotSpan(wpfView.TextSnapshot, 0, wpfView.TextSnapshot.Length);
var allTags = tagAggregator.GetTags(wholeSpan);
adornmentCache.Refresh(allTags.Select(x => x.Tag.Location));
}
/// <summary>
/// Get every GrayLogTag instance within the given span. Generally, the span in
/// question is the displayed portion of the file currently open in the Editor
/// </summary>
/// <param name="span">The span of text that will be searched for GrayLog tags</param>
/// <returns>A list of every relevant tag in the given span</returns>
public IList <ClassificationSpan> GetClassificationSpans(SnapshotSpan span)
{
var tags = _tagger.GetTags(span);
return(tags
.Select(tagSpan => tagSpan.Span.GetSpans(span.Snapshot).First())
.Select(grayLogSpan => new ClassificationSpan(grayLogSpan, _classificationType))
.ToList());
}
public IEnumerable <ITagSpan <ClassificationTag> > GetTags(NormalizedSnapshotSpanCollection spans)
{
foreach (var tagSpan in _aggregator.GetTags(spans))
{
var tagSpans = tagSpan.Span.GetSpans(spans[0].Snapshot);
yield return(new TagSpan <ClassificationTag>(tagSpans[0], new ClassificationTag(_typeService.GetClassificationType("url"))));
}
}
public IEnumerable <ITagSpan <IOutliningRegionTag> > GetTags(NormalizedSnapshotSpanCollection spans)
{
return(from tag in aggregator.GetTags(spans)
let tagSpans = tag.Span.GetSpans(spans[0].Snapshot)
where tag.Tag.Type == FeatureTokenTypes.ScenarioBody
select new TagSpan <IOutliningRegionTag>(tagSpans[0],
new OutliningRegionTag(false, false,
tagSpans[0].GetText().Lines().First(), tagSpans[0].GetText())));
}
public IEnumerable <ITagSpan <ClassificationTag> > GetTags(NormalizedSnapshotSpanCollection spans)
{
var tags = aggregator.GetTags(spans).ToList();
foreach (var tagSpan in tags)
{
yield return(CreateTagSpanForTag(spans[0].Snapshot, tagSpan));
}
NotifyTagsChanged(spans);
}
public IEnumerable <ITagSpan <IClassificationTag> > GetTags(NormalizedSnapshotSpanCollection spans)
{
foreach (var tagSpan in tagAggregator.GetTags(spans))
{
foreach (var span in tagSpan.Span.GetSpans(textBuffer))
{
yield return(new TagSpan <IClassificationTag>(span, classificationTag));
}
}
}
private static IEnumerable <SnapshotSpan> GetTags(
ITagAggregator <NavigableHighlightTag> tagAggregator,
SnapshotSpan span
)
{
return(tagAggregator
.GetTags(span)
.SelectMany(tag => tag.Span.GetSpans(span.Snapshot.TextBuffer))
.OrderBy(tag => tag.Start));
}
public IList <ClassificationSpan> GetClassificationSpans(SnapshotSpan span) =>
_tagger
.GetTags(span)
.Select(tagSpan =>
{
var termTag = tagSpan.Span.GetSpans(span.Snapshot).First();
var classificationType = _classificationRegistry.GetClassificationType(tagSpan.Tag.Classifier);
return(new ClassificationSpan(termTag, classificationType));
}).ToList();
public IEnumerable <ITagSpan <ClassificationTag> > GetTags(NormalizedSnapshotSpanCollection spans)
{
foreach (IMappingTagSpan <AntlrTokenTag> tag_span in _aggregator.GetTags(spans))
{
NormalizedSnapshotSpanCollection tag_spans = tag_span.Span.GetSpans(spans[0].Snapshot);
yield return
(new TagSpan <ClassificationTag>(tag_spans[0],
new ClassificationTag(_antlrtype_to_classifiertype[tag_span.Tag.TagType])));
}
}
/// <summary>
/// Gets all the tags that intersect the specified spans.
/// </summary>
/// <param name="spans">The spans to visit.</param>
/// <returns>
/// A <see cref="T:Microsoft.VisualStudio.Text.Tagging.TagSpan`1" /> for each tag.
/// </returns>
public IEnumerable <ITagSpan <ClassificationTag> > GetTags(NormalizedSnapshotSpanCollection spans)
{
foreach (var tagSpan in _aggregator.GetTags(spans))
{
var tagSpans = tagSpan.Span.GetSpans(spans[0].Snapshot);
yield return
(new TagSpan <ClassificationTag>(tagSpans[0],
new ClassificationTag(_z80AsmTypes[tagSpan.Tag.Type])));
}
}
public IList <ClassificationSpan> GetClassificationSpans(SnapshotSpan span)
{
IList <ClassificationSpan> classifiedSpans = new List <ClassificationSpan>();
var tags = tagger.GetTags(span).ToList();
foreach (IMappingTagSpan <NaturalTextTag> tagSpan in tags)
{
SnapshotSpan snapshot = tagSpan.Span.GetSpans(span.Snapshot).First();
string text = snapshot.GetText();
int index = -1;
// keywords
foreach (string keyword in keywords)
{
while (snapshot.Length > index + 1 && (index = text.IndexOf(keyword, index + 1)) > -1)
{
// controleren of het gevonden keyword niet tegen of in een ander woord staat
if ((index > 0 && keywordPrefixCharacters.Contains(text[index - 1]) == false) ||
(index + keyword.Length < text.Length && keywordPostfixCharacters.Contains(text[index + keyword.Length]) == false))
{
continue;
}
classifiedSpans.Add(new ClassificationSpan(new SnapshotSpan(snapshot.Start + index, keyword.Length), keywordType));
}
}
// functions
foreach (string function in functions)
{
while (snapshot.Length > index + 1 && (index = text.IndexOf(function, index + 1)) > -1)
{
// controleren of het gevonden keyword niet tegen of in een ander woord staat
if ((index > 0 && functionPrefixCharacters.Contains(text[index - 1]) == false) ||
(index + function.Length < text.Length && functionPostfixCharacters.Contains(text[index + function.Length]) == false))
{
continue;
}
classifiedSpans.Add(new ClassificationSpan(new SnapshotSpan(snapshot.Start + index, function.Length), functionType));
}
}
// variables
var matches = variables.Matches(text);
foreach (Match match in matches)
{
classifiedSpans.Add(new ClassificationSpan(new SnapshotSpan(snapshot.Start + match.Groups["Variable"].Index, match.Groups["Variable"].Length), variableType));
}
}
return(classifiedSpans);
}
public IEnumerable <ITagSpan <KeywordTag> > GetTags(NormalizedSnapshotSpanCollection spans)
{
if (spans.Count == 0)
{
yield break;
}
ILanguage lang = GetLanguageByContentType(theBuffer.ContentType);
if (!lang.Settings.Enabled)
{
yield break;
}
bool eshe = settings.EscapeSequencesEnabled;
bool kce = settings.KeywordClassifierEnabled;
if (!(kce || eshe))
{
yield break;
}
ITextSnapshot snapshot = spans[0].Snapshot;
// Get all spans that contain interesting tags
// translated into our snapshot
var interestingSpans = from tagSpan in aggregator.GetTags(spans)
let classificationType = tagSpan.Tag.ClassificationType
where IsInterestingTag(lang, classificationType)
select tagSpan.ToTagSpan(snapshot);
// GetTags() coalesce adjacent spans with the same tag
// so that we can process them as a single span
foreach (var tagSpan in GetTags(interestingSpans, snapshot))
{
var classificationType = tagSpan.Tag.ClassificationType;
String name = classificationType.Classification.ToLower();
if (eshe && name.Contains("string"))
{
foreach (var escapeTag in ProcessEscapeSequences(lang, name, tagSpan.Span))
{
yield return(escapeTag);
}
}
if (kce && lang.IsKeywordClassification(classificationType))
{
// Is this one of the keywords we care about?
var result = IsInterestingKeyword(lang, tagSpan.Span);
if (result != null)
{
yield return(result);
}
}
}
}
private IEnumerable <SnapshotSpan> GetCodeCommentsSpans(NormalizedSnapshotSpanCollection spans)
{
// Loop through each comment span
return
(from classificationMappingTagSpan in _classificationTagAggregator.GetTags(spans)
where classificationMappingTagSpan.Tag.ClassificationType.IsOfType("comment") ||
classificationMappingTagSpan.Tag.ClassificationType.IsOfType("XML Doc Comment")
from snapshotSpan in classificationMappingTagSpan.Span.GetSpans(_textView.TextSnapshot)
from line in SplitSnapshotSpanToLines(snapshotSpan)
select line);
}
public IEnumerable <ITagSpan <ClassificationTag> > GetTags(NormalizedSnapshotSpanCollection spans)
{
return((
from span in spans.AsEnumerable()
from mappingTag in _aggregator.GetTags(span)
where IsCommentSpan(mappingTag)
let normalizedSnapshotSpans = mappingTag.Span.GetSpans(span.Snapshot)
from tagSpan in GetTagSpansFromSnapshotSpans(normalizedSnapshotSpans)
select tagSpan
).ToList());
}
public static bool isComment(ITextSnapshotLine line, int index, ITagAggregator <IClassificationTag> aggregator)
{
var tags = aggregator.GetTags(
new SnapshotSpan(
new SnapshotPoint(line.Snapshot, line.Start + index - 1 < 0 ? 0 : line.Start + index - 1),
new SnapshotPoint(line.Snapshot, line.Start + index)
)
);
return(tags.Any(x => x.Tag.ClassificationType.Classification == "comment"));
}
public IEnumerable <ITagSpan <ClassificationTag> > GetTags(NormalizedSnapshotSpanCollection spans)
{
foreach (var tagSpan in _aggregator.GetTags(spans))
{
var tagSpans = tagSpan.Span.GetSpans(spans[0].Snapshot);
if (spans.IntersectsWith(tagSpans))
{
yield return(new TagSpan <ClassificationTag>(tagSpans[0], new ClassificationTag(_SLangTypes[tagSpan.Tag.type])));
}
}
}
public static (AsmTokenTag tag, SnapshotSpan?keywordSpan) GetAsmTokenTag(ITagAggregator <AsmTokenTag> aggregator, SnapshotPoint triggerPoint)
{
foreach (IMappingTagSpan <AsmTokenTag> asmTokenTag in aggregator.GetTags(new SnapshotSpan(triggerPoint, triggerPoint)))
{
foreach (SnapshotSpan span in asmTokenTag.Span.GetSpans(triggerPoint.Snapshot.TextBuffer))
{
return(asmTokenTag.Tag, span);
}
}
return(null, null);
}
public static bool ContainsTag(ITextSnapshotLine line, string classificationName, ITagAggregator <IClassificationTag> aggregator)
{
var tags = aggregator.GetTags(
new SnapshotSpan(
new SnapshotPoint(line.Snapshot, line.Start),
new SnapshotPoint(line.Snapshot, line.End)
)
);
return(tags.Any(x => x.Tag.ClassificationType.Classification == classificationName));
}
public IEnumerable <ITagSpan <ClassificationTag> > GetTags(NormalizedSnapshotSpanCollection spans)
{
foreach (var tagSpan in _aggregator.GetTags(spans))
{
if (!_clojureTypes.ContainsKey(tagSpan.Tag.Token.Type))
{
continue;
}
var tagSpans = tagSpan.Span.GetSpans(spans[0].Snapshot);
yield return(new TagSpan <ClassificationTag>(tagSpans[0], new ClassificationTag(_clojureTypes[tagSpan.Tag.Token.Type])));
}
}
private bool IsOnSelectedVisualization(SnapshotSpan range)
{
var primaryLocationsTagSpans = issueLocationsTagAggregator.GetTags(range);
var isOnSelectedPrimaryLocation = primaryLocationsTagSpans.Select(x => x.Tag.Location)
.OfType <IAnalysisIssueVisualization>()
.Any(x => x == selectionService.SelectedIssue);
var selectedLocationsTagSpans = selectedIssueLocationsTagAggregator.GetTags(range);
var isOnSelectedSecondaryLocation = selectedLocationsTagSpans.Any();
return(isOnSelectedPrimaryLocation || isOnSelectedSecondaryLocation);
}
public IEnumerable <ITagSpan <KeywordTag> > GetTags(NormalizedSnapshotSpanCollection spans)
{
if (spans.Count == 0)
{
yield break;
}
ILanguage lang = GetLanguageByContentType(theBuffer.ContentType);
if (!lang.Enabled)
{
yield break;
}
bool eshe = settings.EscapeSequencesEnabled;
bool kce = settings.KeywordClassifierEnabled;
if (!(kce || eshe))
{
yield break;
}
ITextSnapshot snapshot = spans[0].Snapshot;
foreach (var tagSpan in aggregator.GetTags(spans))
{
if (tagSpan.Tag.ClassificationType is RainbowTag)
{
continue;
}
var classificationType = tagSpan.Tag.ClassificationType;
String name = classificationType.Classification.ToLower();
if (eshe && name.Contains("string"))
{
var span = tagSpan.GetSpan(snapshot);
foreach (var escapeTag in ProcessEscapeSequences(lang, span))
{
yield return(escapeTag);
}
}
if (kce && lang.IsKeywordClassification(classificationType))
{
var span = tagSpan.GetSpan(snapshot);
// Is this one of the keywords we care about?
var result = IsInterestingKeyword(lang, span);
if (result != null)
{
yield return(result);
}
}
}
}
internal NormalizedSnapshotSpanCollection GetErrors()
{
IEnumerable <IMappingTagSpan <IErrorTag> > tags =
_errorTagAggregator.GetTags(new SnapshotSpan(_textView.TextSnapshot, 0, _textView.TextSnapshot.Length));
List <SnapshotSpan> unnormalizederrors = new List <SnapshotSpan>();
foreach (IMappingTagSpan <IErrorTag> tag in tags)
{
unnormalizederrors.AddRange(tag.Span.GetSpans(_textView.TextSnapshot));
}
return(new NormalizedSnapshotSpanCollection(unnormalizederrors));
}
public IEnumerable <ITagSpan <TextMarkerTag> > GetTags(NormalizedSnapshotSpanCollection spans)
{
SnapshotPoint caretPosition = _view.Caret.Position.BufferPosition;
if (caretPosition >= _buffer.CurrentSnapshot.Length)
{
yield break;
}
TokenId tagType = TokenId.Ignore;
SnapshotPoint tokenPosition = new SnapshotPoint();
var caretSpan = new SnapshotSpan(caretPosition, 1);
foreach (var tagSpan in _aggregator.GetTags(caretSpan))
{
tagType = tagSpan.Tag.type;
tokenPosition = tagSpan.Span.GetSpans(caretSpan.Snapshot)[0].Start;
}
if (!_bracketTokens.ContainsKey(tagType))
{
yield break;
}
Tuple <BracketSide, BracketGroup> bracket = _bracketTokens[tagType];
if (bracket.Item1 != BracketSide.Start)
{
foreach (var tag in MatchBackward(bracket.Item2, tokenPosition))
{
yield return(tag);
}
}
foreach (var tag in MatchForward(bracket.Item1, bracket.Item2, tokenPosition))
{
yield return(tag);
}
}
private SnapshotSpan?GetTableSpan(ITextSnapshotLine line, ITagAggregator <GherkinTokenTag> gherkinTagAggregator)
{
if (!gherkinTagAggregator.GetTags(line.Extent).Any(t => t.Tag.IsToken && t.Tag.IsAnyTokenType(TokenType.TableRow)))
{
return(null);
}
var snapshot = line.Snapshot;
int scanLineFrom = Math.Max(0, line.LineNumber - SCAN_LINE_RADIUS);
int scanLineTo = Math.Min(snapshot.LineCount - 1, line.LineNumber + SCAN_LINE_RADIUS);
return(GetTableSpan(line, gherkinTagAggregator, snapshot, scanLineFrom, scanLineTo));
}
public IEnumerable <ITagSpan <ErrorTag> > GetTags(NormalizedSnapshotSpanCollection spans)
{
if (spans.Count == 0) //there is no content in the buffer
{
yield break;
}
if (!this._labelGraph.isEnabled)
{
yield break;
}
DateTime time1 = DateTime.Now;
foreach (IMappingTagSpan <AsmTokenTag> asmTokenTag in _aggregator.GetTags(spans))
{
SnapshotSpan tagSpan = asmTokenTag.Span.GetSpans(_sourceBuffer)[0];
//AsmDudeToolsStatic.Output(string.Format("INFO: ErrorTagger:GetTags: found keyword \"{0}\"", tagSpan.GetText()));
switch (asmTokenTag.Tag.type)
{
case AsmTokenType.Label: {
if (Settings.Default.IntelliSenseDecorateUndefinedLabels)
{
string label = tagSpan.GetText();
if (!this._labelGraph.hasLabel(label))
{
var toolTipContent = undefinedlabelToolTipContent();
yield return(new TagSpan <ErrorTag>(tagSpan, new ErrorTag("warning", toolTipContent)));
}
}
break;
}
case AsmTokenType.LabelDef: {
if (Settings.Default.IntelliSenseDecorateClashingLabels)
{
string label = tagSpan.GetText();
if (this._labelGraph.hasLabelClash(label))
{
var toolTipContent = labelClashToolTipContent(label);
yield return(new TagSpan <ErrorTag>(tagSpan, new ErrorTag("warning", toolTipContent)));
}
}
break;
}
default: break;
}
}
AsmDudeToolsStatic.printSpeedWarning(time1, "LabelErrorTagger");
}
protected IEnumerable <KeyValuePair <SnapshotSpan, DeveroomTag> > GetDeveroomTags(NormalizedSnapshotSpanCollection spans, Predicate <DeveroomTag> filter = null)
{
var snapshot = spans[0].Snapshot;
var gherkinMappingTagSpans = DeveroomTagAggregator.GetTags(spans);
if (filter != null)
{
gherkinMappingTagSpans = gherkinMappingTagSpans.Where(t => filter(t.Tag));
}
return(gherkinMappingTagSpans.SelectMany(
mappingTagSpan => mappingTagSpan.Span.GetSpans(snapshot),
(mappingTagSpan, mappedTagSpan) => new KeyValuePair <SnapshotSpan, DeveroomTag>(mappedTagSpan, mappingTagSpan.Tag)));
}
private bool CheckForPrefixTag(
ITagAggregator<IClassificationTag> tagAggregator,
SnapshotSpan span)
{
String text = span.GetText();
if ( text.StartsWith("<") || text.Contains(":") ) {
return false;
}
var firstMatch = from tagSpan in tagAggregator.GetTags(span)
let tagName = tagSpan.Tag.ClassificationType.Classification
where tagName == Constants.XML_PREFIX
select tagSpan;
return firstMatch.FirstOrDefault() != null;
}
