public IEnumerable <ITagSpan <SQTokenTag> > GetTags(NormalizedSnapshotSpanCollection spans)
{
int currentVersion = _buffer.CurrentSnapshot.Version.VersionNumber;
if (currentVersion > lastVersion)
{
_currentTags.Clear();
var textstructnav = _textStructureNavigatorSelector.GetTextStructureNavigator(_buffer);
FindData fd = new FindData();
fd.TextStructureNavigator = textstructnav;
fd.FindOptions = FindOptions.WholeWord | FindOptions.MatchCase;
foreach (SnapshotSpan curSpan in spans)
{
fd.TextSnapshotToSearch = curSpan.Snapshot;
foreach (string key in _sqTypes.Keys)
{
fd.SearchString = key;
var result = _textSearchService.FindAll(fd);
foreach (var r in result)
{
_currentTags.Add(new TagSpan <SQTokenTag>(r, new SQTokenTag(SQTokenTypes.ReservedWords)));
}
}
}
lastVersion = currentVersion;
}
foreach (var t in _currentTags)
{
yield return(t);
}
}
public IEnumerable <ITagSpan <LoggingTag> > GetTags(NormalizedSnapshotSpanCollection spans)
{
if (spans.Count == 0)
{
yield break;
}
if (_currentViewLine == null)
{
yield break;
}
if (!_currentViewLine.IsValid)
{
yield break;
}
if (spans.Count > 0)
{
// look for 'StackdriverLogging' occurrences
foreach (SnapshotSpan span in _textSearchService.FindAll(new FindData("StackdriverLogging",
spans[0].Snapshot,
FindOptions.WholeWord | FindOptions.MatchCase | FindOptions.SingleLine,
_textStructureNavigator)))
//spans[0].Snapshot, FindOptions.WholeWord | FindOptions.MatchCase, _textStructureNavigator)))
{
if (_currentViewLine.ContainsBufferPosition(span.Start))
{
yield return(new TagSpan <LoggingTag>(span, new LoggingTag()));
}
}
}
}
#pragma warning disable CS0067
public IList <ClassificationSpan> GetClassificationSpans(SnapshotSpan span)
{
var findData = new FindData(@"(#region((\s+\S+)+)?)|(#endregion((\s+\S+)+)?)", span.Snapshot)
{
FindOptions = FindOptions.UseRegularExpressions
};
var snapshotSpans = textSearchService.FindAll(findData).ToArray();
var classificationForegroundType = registryService.GetClassificationType(ClassifierForegroundFormat.ClassifierKey);
var classificationBackgroundType = registryService.GetClassificationType(ClassifierBackgroundFormat.ClassifierKey);
var classificationIsItalicType = registryService.GetClassificationType(ClassifierIsItalicFormat.ClassifierKey);
var classificationIsBoldType = registryService.GetClassificationType(ClassifierIsBoldFormat.ClassifierKey);
var classificationFontRenderingType = registryService.GetClassificationType(ClassifierFontRenderingFormat.ClassifierKey);
var result = snapshotSpans.Select(sp => new ClassificationSpan(sp, classificationForegroundType))
.Union(snapshotSpans.Select(sp => new ClassificationSpan(sp, classificationBackgroundType)))
.Union(snapshotSpans.Select(sp => new ClassificationSpan(sp, classificationIsItalicType)))
.Union(snapshotSpans.Select(sp => new ClassificationSpan(sp, classificationIsBoldType)))
.Union(snapshotSpans.Select(sp => new ClassificationSpan(sp, classificationIsBoldType)))
.Union(snapshotSpans.Select(sp => new ClassificationSpan(sp, classificationFontRenderingType)))
.ToList();
return(result);
}
private NormalizedSnapshotSpanCollection Find(IEnumerable <string> patterns, ITextSnapshot snapshot)
{
var findDatas = patterns.Select(p => new FindData(p, snapshot, FindOptions.UseRegularExpressions | FindOptions.Multiline, _textStructureNavigator));
var results = findDatas.SelectMany(d => _textSearchService.FindAll(d));
var spans = new NormalizedSnapshotSpanCollection(results);
return(spans);
}
private void FindAndUpdateSpans(TextExtent extent, SnapshotPoint request)
{
var wordSpans = new List <SnapshotSpan>();
var text = request.Snapshot.GetText(extent.Span);
if (!IsComment(extent))
{
if (text.Any(c => char.IsLetter(c)))
{
if (!_currentToken.HasValue || extent.Span != _currentToken)
{
// Find the new spans
var findData = new FindData(extent.Span.GetText(), extent.Span.Snapshot)
{
FindOptions = FindOptions.WholeWord | FindOptions.MatchCase
};
var tagger = new GLSLTaggerProvider().CreateTagger <IGLSLTag>(_buffer) as GLSLTagger;
var scope = tagger.GetScope(extent.Span);
var spans = _textSearchService.FindAll(findData);
foreach (var span in spans)
{
var spanScope = tagger.GetScope(span);
if (spanScope == scope || spanScope.IsDescendentOf(scope) || spanScope.IsAncestorOf(scope))
{
lock (_spanLock)
{
if (!_commentSpans.CloneAndTrackTo(extent.Span.Snapshot, SpanTrackingMode.EdgePositive).OverlapsWith(span) &&
_tokenSpans.CloneAndTrackTo(extent.Span.Snapshot, SpanTrackingMode.EdgePositive).OverlapsWith(span))
{
wordSpans.Add(span);
}
}
}
}
}
}
else
{
var span = GetMatchingBracketSpan(extent, text);
if (span.HasValue && (!_currentToken.HasValue || extent.Span != _currentToken))
{
wordSpans.Add(span.Value);
}
}
}
// If another change hasn't happened, do a real update
if (request == _requestedPoint)
{
SynchronousUpdate(request, new NormalizedSnapshotSpanCollection(wordSpans), extent.Span);
}
}
/// <summary>
/// Handles finding all occurrences
/// </summary>
internal void SelectAllOccurrences()
{
// Get a valid first selection to begin with
SelectNextOccurrence();
foreach (var occurrence in textSearchService.FindAll(GetFindData()))
{
ProcessFoundOccurrence(occurrence);
}
}
private void FindWordsInDocument()
{
lock (UpdateLock)
{
var findData = new FindData(_selectedWord.GetText(), _selectedWord.Snapshot)
{
FindOptions = FindOptions.WholeWord
};
SnapShotsToColor.AddRange(_textSearchService.FindAll(findData));
ColorWords();
}
}
private IEnumerable <SnapshotSpan> FindAll(String searchPattern, ITextSnapshot textSnapshot)
{
if (textSnapshot == null)
{
return(null);
}
return(m_SearchService.FindAll(
new FindData(searchPattern, textSnapshot)
{
FindOptions = FindOptions.WholeWord | FindOptions.MatchCase
}));
}
public IEnumerable <ITagSpan <LoggingTag> > GetTags(NormalizedSnapshotSpanCollection spans)
{
if (ToolWindow1Control.CurrentTextViewer != _view)
{
Debug.WriteLine("FirstWindowControl.CurrentTextViewer != _view");
yield break;
}
if (spans.Count == 0)
{
yield break;
}
if (_currentViewLine == null)
{
yield break;
}
if (!_currentViewLine.IsValid)
{
yield break;
}
bool showToolTip = false;
if (spans.Count > 0)
{
// look for 'StackdriverLogging' occurrences
foreach (SnapshotSpan span in _textSearchService.FindAll(new FindData("StackdriverLogging",
spans[0].Snapshot,
FindOptions.WholeWord | FindOptions.MatchCase | FindOptions.SingleLine,
_textStructureNavigator)))
//spans[0].Snapshot, FindOptions.WholeWord | FindOptions.MatchCase, _textStructureNavigator)))
{
if (_currentViewLine.ContainsBufferPosition(span.Start))
{
yield return(new TagSpan <LoggingTag>(span, new LoggingTag()));
showToolTip = true;
ShowToolTip(span);
}
}
}
if (showToolTip)
{
}
else
{
_toolTipProvider.ClearToolTip();
}
}
private IEnumerable <SnapshotSpan> FindAll(String searchPattern, ITextSnapshot textSnapshot)
{
if (textSnapshot == null)
{
return(null);
}
return(m_SearchService.FindAll(
new FindData(searchPattern, textSnapshot)
{
FindOptions = (FindOptions.MatchCase
| FindOptions.UseRegularExpressions)
}));
}
private void FindWordsInDocument()
{
lock (SelectionHighlight.UpdateLock)
{
Task.Factory.StartNew(() =>
{
var findData =
new FindData(_selectedWord.GetText(), _selectedWord.Snapshot)
{
FindOptions = FindOptions.WholeWord
};
_glyphsToPlace.AddRange(_textSearchService.FindAll(findData));
});
}
}
public IEnumerable <ITagSpan <GotoTag> > GetTags(NormalizedSnapshotSpanCollection spans)
{
if (spans.Count == 0)
{
yield break;
}
if (spans.Count > 0)
{
// look for 'goto' occurrences
foreach (SnapshotSpan span in _textSearchService.FindAll(new FindData("goto", spans[0].Snapshot, FindOptions.WholeWord | FindOptions.MatchCase, _textStructureNavigator)))
{
yield return(new TagSpan <GotoTag>(span, new GotoTag()));
}
}
}
public override Collection <TextRange> FindAll(string pattern, FindOptions findOptions)
{
ValidateFindParameters(pattern, this);
if (pattern.Length == 0)
{
return(new Collection <TextRange>());
}
FindData findData = new FindData(pattern, _textBuffer.AdvancedTextBuffer.CurrentSnapshot);
findData.FindOptions = findOptions;
// Assume that FindAll returns matches sorted starting at the beginning
// of the snapshot.
Collection <SnapshotSpan> matches = _findLogic.FindAll(findData);
List <TextRange> ranges = new List <TextRange>();
Collection <TextRange> beforeRanges = new Collection <TextRange>();
foreach (SnapshotSpan span in matches)
{
TextRange textRange = _bufferPrimitivesFactory.CreateTextRange(_textBuffer,
_bufferPrimitivesFactory.CreateTextPoint(_textBuffer, span.Start),
_bufferPrimitivesFactory.CreateTextPoint(_textBuffer, span.End));
if (textRange.GetStartPoint().CurrentPosition < CurrentPosition)
{
beforeRanges.Add(textRange);
}
else
{
ranges.Add(textRange);
}
}
ranges.AddRange(beforeRanges);
return(new Collection <TextRange>(ranges));
}
private void MarkReplacements(ICollection <string> replaceIDs)
{
if (CodeWindow.TextBuffer == null)
{
return;
}
var findData = new FindData(SnippetRegexPatterns.BuildValidReplacementString(SnippetDelimiter),
CodeWindow.TextBuffer.CurrentSnapshot,
FindOptions.UseRegularExpressions,
null);
var candidateSpans = textSearchService.FindAll(findData);
foreach (var candidateSpan in candidateSpans)
{
var replacementText = candidateSpan.GetText();
var textBetween = TurnReplacementSymbolIntoText(replacementText);
if (!replaceIDs.Contains(textBetween))
{
CreateReplacement(textBetween);
}
}
}
private void UpdateWordAdornnents(string newSelection)
{
// If the new string is equal to the old one, we do not need to update the tags.
if (_currentWord.Equals(newSelection))
{
return;
}
List <SnapshotSpan> wordSpans = new List <SnapshotSpan>();
// If the user only selected whitespace, do not create any snapshots.
if (!newSelection.All(char.IsWhiteSpace))
{
// Finds exact matches (does not match with substrings of words).
FindData findData = new FindData(newSelection, _view.TextSnapshot)
{
FindOptions = FindOptions.WholeWord | FindOptions.MatchCase
};
wordSpans.AddRange(_textSearchService.FindAll(findData));
}
_wordSpans = new NormalizedSnapshotSpanCollection(wordSpans);
Update(newSelection);
}
void UpdateWordAdornments()
{
SnapshotPoint current_request = _point;
List <SnapshotSpan> word_spans = new List <SnapshotSpan>();
// find all words in the buffer like the one the caret is on
TextExtent word = _navigator.GetExtentOfWord(current_request);
bool word_found = true;
// If we've selected something not worth highlighting, we might have missed a "word" by a little bit
if (!WordExtentIsValid(current_request, word))
{
// before we retry, make sure it is worthwhile
if (word.Span.Start != current_request ||
current_request == current_request.GetContainingLine().Start ||
char.IsWhiteSpace((current_request - 1).GetChar()))
{
word_found = false;
}
else
{
// try again, one character previous
// if the caret is at the end of a word, pick up the word
word = _navigator.GetExtentOfWord(current_request - 1);
// if the word still isn't valid, we're done
if (!WordExtentIsValid(current_request, word))
{
word_found = false;
}
}
}
if (!word_found)
{
// if we couldn't find a word, clear out the existing markers
SynchronousUpdate(current_request, new NormalizedSnapshotSpanCollection(), null);
return;
}
SnapshotSpan current_word = word.Span;
// if this is the current word, and the caret moved within a word, we're done.
if (_word.HasValue && current_word == _word)
{
return;
}
// find the new spans
FindData find_data = new FindData(current_word.GetText(), current_word.Snapshot);
find_data.FindOptions = FindOptions.WholeWord | FindOptions.MatchCase;
word_spans.AddRange(_searcher.FindAll(find_data));
// if another change hasn't happened, do a real update
if (current_request == _point)
{
SynchronousUpdate(current_request, new NormalizedSnapshotSpanCollection(word_spans), current_word);
}
}
//int lastVersion = -1;
public IEnumerable <ITagSpan <ClassificationTag> > GetTags(NormalizedSnapshotSpanCollection spans)
{
if (spans.Count == 0)
{
yield break;
}
ITextSnapshot currentSnapshot = _buffer.CurrentSnapshot;
SQCompileError error = null;
bool newversion;
_languangeService.Parse(_buffer, out newversion, ref error);
var ts = _languangeService.GetClassificationInfo(filepath);
// int currentVersion = _buffer.CurrentSnapshot.Version.VersionNumber;
List <SnapshotSpan> keywordspans = new List <SnapshotSpan>();
List <SnapshotSpan> nokeywordspans = new List <SnapshotSpan>();
List <TagSpan <ClassificationTag> > _currentTags = new List <TagSpan <ClassificationTag> >();
var cachekeys = _languangeService.GetKeywordSpans(filepath);
if (cachekeys == null || newversion)
{
//_currentTags.Clear();
var textstructnav = _textStructureNavigatorSelector.GetTextStructureNavigator(_buffer);
FindData fd = new FindData();
fd.TextStructureNavigator = textstructnav;
fd.FindOptions = FindOptions.WholeWord | FindOptions.MatchCase;
foreach (SnapshotSpan curSpan in spans)
{
fd.TextSnapshotToSearch = curSpan.Snapshot;
foreach (string key in _sqTypes.Keys)
{
fd.SearchString = key;
var result = _textSearchService.FindAll(fd);
keywordspans.AddRange(result);
}
}
_languangeService.SetKeywordCache(filepath, keywordspans.ToArray());
}
else
{
keywordspans.AddRange(cachekeys);
}
foreach (var t in ts)
{
TextSpan scope = t.Item2;
if (t.Item4 == SQDeclarationType.Class ||
t.Item4 == SQDeclarationType.Enum)
{
scope = t.Item1;
}
if (scope.iEndLine == -1 || scope.iStartLine == -1 ||
scope.iEndLine >= currentSnapshot.LineCount || scope.iStartLine >= currentSnapshot.LineCount)
{
continue;
}
int length = 0;
string collpasedlabel = t.Item3;
SnapshotPoint?start = null;
try
{
var startLine = currentSnapshot.GetLineFromLineNumber(scope.iStartLine);
var endLine = currentSnapshot.GetLineFromLineNumber(scope.iEndLine);
start = startLine.Start + scope.iStartIndex;
length = (endLine.Start - startLine.Start) + scope.iEndIndex - scope.iStartIndex;
if (start.Value.Position + length >= currentSnapshot.Length)
{
length = currentSnapshot.Length - start.Value.Position;
}
}
catch (Exception)
{
length = 0;
}
if (length > 0 && start != null)
{
SnapshotSpan snap = new SnapshotSpan(start.Value, length);
if (newversion)
{
TagsChanged(this, new SnapshotSpanEventArgs(snap));
}
switch (t.Item4)
{
case SQDeclarationType.AttributeScope:
nokeywordspans.Add(snap);
_currentTags.Add(new TagSpan <ClassificationTag>(snap, _attribtag));
break;
case SQDeclarationType.CommentScope:
nokeywordspans.Add(snap);
_currentTags.Add(new TagSpan <ClassificationTag>(snap, _commenttag));
break;
case SQDeclarationType.LiteralScope:
nokeywordspans.Add(snap);
_currentTags.Add(new TagSpan <ClassificationTag>(snap, _stringtag));
break;
case SQDeclarationType.Extend:
case SQDeclarationType.Class:
_currentTags.Add(new TagSpan <ClassificationTag>(snap, _classtag));
break;
case SQDeclarationType.Enum:
_currentTags.Add(new TagSpan <ClassificationTag>(snap, _enumtag));
break;
case SQDeclarationType.SubName:
_currentTags.Add(new TagSpan <ClassificationTag>(snap, _subnametag));
break;
case SQDeclarationType.Number:
_currentTags.Add(new TagSpan <ClassificationTag>(snap, _numberictag));
break;
}
}
}
foreach (var kwspan in keywordspans)
{
bool cancel = false;
foreach (var nokwspan in nokeywordspans)
{
if (nokwspan.Contains(kwspan.Start.Position))//nokwspan.IntersectsWith(kwspan))
{
cancel = true;
break;
}
}
if (cancel)
{
continue;
}
if (newversion)
{
TagsChanged(this, new SnapshotSpanEventArgs(kwspan));
}
_currentTags.Add(new TagSpan <ClassificationTag>(kwspan, _keywordtag));
}
foreach (var t in _currentTags)
{
yield return(t);
}
}
