public void GetProInf(string key, string pro, out string inf, ITextSnapshot currentSnapshot, out ITrackingSpan applicableToSpan, SnapshotSpan querySpan)
{
if (m_controlMap.ContainsKey(key))
{
CtrlInf tinf;
m_controlMap.TryGetValue(key, out tinf);
if (tinf.getprolist().ContainsKey(pro))
{
applicableToSpan = currentSnapshot.CreateTrackingSpan
(
querySpan.Start.Add(0).Position, 9, SpanTrackingMode.EdgeInclusive
);
tinf.getprolist().TryGetValue(pro, out inf);
return;
}
else
{//父窗口的属性
if (GetProInf(key, ref pro, out inf))
{
applicableToSpan = currentSnapshot.CreateTrackingSpan(querySpan.Start.Add(0).Position, 9, SpanTrackingMode.EdgeInclusive);
return;
}
}
}
else if (GetProInf("window", ref pro, out inf))
{
applicableToSpan = currentSnapshot.CreateTrackingSpan(querySpan.Start.Add(0).Position, 9, SpanTrackingMode.EdgeInclusive);
return;
}
inf = null;
applicableToSpan = null;
}
private List <ITrackingSpan> CreateSpansFromProjections(List <ProjectionInfo> projections, ITextSnapshot snapshot)
{
var spans = new List <ITrackingSpan>();
var nextLocation = 0;
foreach (var projectionInfo in projections)
{
// generate default projection buffer span
if (projectionInfo.Start != nextLocation)
{
var preSpan = new Span(nextLocation, projectionInfo.Start - nextLocation);
var preTrackingPreSpan = snapshot.CreateTrackingSpan(preSpan, SpanTrackingMode.EdgeExclusive);
spans.Add(preTrackingPreSpan);
}
// generate separate contentype projection buffer
var span = new Span(projectionInfo.Start, projectionInfo.End - projectionInfo.Start);
var trackingSpan = snapshot.CreateTrackingSpan(span, SpanTrackingMode.EdgeExclusive);
var buffer = CreateProjectionBuffer(projectionInfo.ContentType, trackingSpan);
spans.Add(buffer.CurrentSnapshot.CreateTrackingSpan(new Span(0, buffer.CurrentSnapshot.Length), SpanTrackingMode.EdgeExclusive));
nextLocation = projectionInfo.End;
}
// generate default projection buffer span
if (nextLocation < snapshot.Length)
{
var preSpan = new Span(nextLocation, snapshot.Length - nextLocation);
spans.Add(snapshot.CreateTrackingSpan(preSpan, SpanTrackingMode.EdgeExclusive));
}
return(spans);
}
/// <summary>
/// Fetches auto complete suggestions and appends to the completion sets of the current completion session.
/// </summary>
/// <param name="session">The active completion session, initiated from the completion command handler.</param>
/// <param name="completionSets">A list of completion sets that may be augmented by this source.</param>
public void AugmentCompletionSession(ICompletionSession session, IList <CompletionSet> completionSets)
{
if (disposed)
{
throw new ObjectDisposedException(GetType().Name);
}
ITextSnapshot snapshot = buffer.CurrentSnapshot;
SnapshotPoint?sp = session.GetTriggerPoint(snapshot);
if (!sp.HasValue)
{
return;
}
var triggerPoint = sp.Value;
var line = triggerPoint.GetContainingLine();
int col = triggerPoint.Position - line.Start.Position;
if (line.GetText() == "" || col == 0 || char.IsWhiteSpace(line.GetText()[col - 1]))
{
// On empty rows or without a prefix, return only completions for rust keywords.
var location = snapshot.CreateTrackingSpan(col + line.Start.Position, 0, SpanTrackingMode.EdgeInclusive);
completionSets.Add(new RustCompletionSet("All", "All", location, keywordCompletions, null));
return;
}
// Get token under cursor.
var tokens = Utils.LexString(line.GetText());
var activeToken = col == line.Length
? tokens.Last()
: tokens.FirstOrDefault(t => col >= t.StartIndex && col <= t.StopIndex);
if (activeToken == null)
{
return;
}
RustTokenTypes tokenType = Utils.LexerTokenToRustToken(activeToken.Text, activeToken.Type);
// Establish the extents of the current token left of the cursor.
var extent = new TextExtent(
new SnapshotSpan(
new SnapshotPoint(snapshot, activeToken.StartIndex + line.Start.Position),
triggerPoint),
tokenType != RustTokenTypes.WHITESPACE);
var span = snapshot.CreateTrackingSpan(extent.Span, SpanTrackingMode.EdgeInclusive);
// Fetch racer completions & return in a completion set.
var completions = GetCompletions(tokenType, activeToken.Text, RunRacer(snapshot, triggerPoint)).ToList();
completions.AddRange(keywordCompletions);
completionSets.Add(new RustCompletionSet("All", "All", span, completions, null));
}
public void AugmentCompletionSession(ICompletionSession session, IList <CompletionSet> completionSets)
{
try {
if (_disposed)
{
throw new ObjectDisposedException("BatCompletionSource");
}
ITextSnapshot snapshot = _buffer.CurrentSnapshot;
var triggerPoint = (SnapshotPoint)session.GetTriggerPoint(snapshot);
if (triggerPoint == null)
{
return;
}
var lineSnapshot = triggerPoint.GetContainingLine();
var allText = lineSnapshot.Snapshot.GetText();
SnapshotPoint start = triggerPoint;
SnapshotPoint start2 = triggerPoint;
var batDefinitions = ConfigurationEngine.Singleton.IntellisenseManager.BatDefinitions;
var line = lineSnapshot.GetText();
List <Completion> completions = null;
if (Ps1Language.CommandFilter.IntellisenseChar == "-")
{
if (ConfigurationEngine.Singleton.IntellisenseManager.PowerShellDefinitions.IsRelevantToTriggerIntellisense(Ps1Language.CommandFilter.IntellisensePreviousWord))
{
completions = GetCompletionsListFromIntellisenseMetaData(Ps1Language.CommandFilter.IntellisensePreviousWord, Ps1Language.CommandFilter.IntellisensePreviousWordAlreadyUsedParameters);
}
}
if (completions != null && completions.Count > 0)
{
var applicableTo = snapshot.CreateTrackingSpan(new SnapshotSpan(start, triggerPoint), SpanTrackingMode.EdgeInclusive);
completionSets.Add(new CompletionSet("All", "All", applicableTo, completions, Enumerable.Empty <Completion>()));
}
else
{
// Set an empty intellisense list else it break the intellisense
var applicableTo = snapshot.CreateTrackingSpan(new SnapshotSpan(start, triggerPoint), SpanTrackingMode.EdgeInclusive);
completionSets.Add(new CompletionSet("All", "All", applicableTo, new List <Completion>(), Enumerable.Empty <Completion>()));
}
}
catch (System.Exception ex) {
this.Out(ex.ToString());
#if DEBUG
Util.Utility.MsgBox(": (", ex);
#endif
}
}
public void GetKeyInf(string key, out string inf, ITextSnapshot currentSnapshot, out ITrackingSpan applicableToSpan, SnapshotSpan querySpan)
{
if (m_controlMap.ContainsKey(key))
{
applicableToSpan = currentSnapshot.CreateTrackingSpan
(
querySpan.Start.Add(0).Position, 9, SpanTrackingMode.EdgeInclusive
);
CtrlInf tinf;
m_controlMap.TryGetValue(key, out tinf);
inf = tinf.getdes();
return;
}
// foreach (KeyValuePair<string, CtrlInf> pair in m_controlMap)
// {
// if (pair.Value.getprolist().ContainsKey(key))
// {
// applicableToSpan = currentSnapshot.CreateTrackingSpan
// (
// querySpan.Start.Add(0).Position, 9, SpanTrackingMode.EdgeInclusive
// );
// pair.Value.getprolist().TryGetValue(key, out inf);
// return;
// }
// }
inf = null;
applicableToSpan = null;
}
void ReparseFile(object sender, EventArgs args)
{
ITextSnapshot snapshot = _buffer.CurrentSnapshot;
List <MarkdownSection> newSections = new List <MarkdownSection>(
MarkdownParser.ParseMarkdownSections(snapshot)
.Select(t => new MarkdownSection()
{
TokenType = t.TokenType,
Span = snapshot.CreateTrackingSpan(t.Span, SpanTrackingMode.EdgeExclusive)
}));
NormalizedSnapshotSpanCollection oldSectionSpans = new NormalizedSnapshotSpanCollection(
_sections.Select(s => s.Span.GetSpan(snapshot)));
NormalizedSnapshotSpanCollection newSectionSpans = new NormalizedSnapshotSpanCollection(
newSections.Select(s => s.Span.GetSpan(snapshot)));
NormalizedSnapshotSpanCollection difference = SymmetricDifference(oldSectionSpans, newSectionSpans);
_sections = newSections;
foreach (var span in difference)
{
var temp = TagsChanged;
if (temp != null)
{
temp(this, new SnapshotSpanEventArgs(span));
}
}
}
public void AugmentQuickInfoSession(IQuickInfoSession session, IList <object> quickInfoContent, out Microsoft.VisualStudio.Text.ITrackingSpan applicableToSpan)
{
SnapshotPoint?sp = session.GetTriggerPoint(this.textBuffer.CurrentSnapshot);
if (!sp.HasValue)
{
applicableToSpan = null;
return;
}
ITextSnapshot currentSnapshot = sp.Value.Snapshot;
SnapshotSpan span = new SnapshotSpan(sp.Value, 0);
ITextStructureNavigator navigator = provider.NavigatorService.GetTextStructureNavigator(this.textBuffer);
string keyText = navigator.GetExtentOfWord(sp.Value).Span.GetText().Trim();
if (string.IsNullOrEmpty(keyText))
{
applicableToSpan = null;
return;
}
string info;
quickInfos.TryGetValue(keyText, out info);
if (!string.IsNullOrEmpty(info))
{
applicableToSpan = currentSnapshot.CreateTrackingSpan(span.Start.Position, 9, SpanTrackingMode.EdgeInclusive);
quickInfoContent.Add(info);
return;
}
applicableToSpan = null;
}
private void CreateTracking(IWpfTextView textView, ITextSnapshot textSnapshot, Span span)
{
if (_trackingSpan != null)
{
return;
}
_textView = textView;
if (_tagger == null)
{
IComponentModel componentModel = (IComponentModel)_serviceProvider.GetService(typeof(SComponentModel));
ISarifLocationProviderFactory sarifLocationProviderFactory = componentModel.GetService <ISarifLocationProviderFactory>();
// Get a SimpleTagger over the buffer to color
_tagger = sarifLocationProviderFactory.GetTextMarkerTagger(_textView.TextBuffer);
}
// Add the marker
if (_tagger != null)
{
// The list of colors for TextMarkerTag are defined in Platform\Text\Impl\TextMarkerAdornment\TextMarkerProviderFactory.cs
_trackingSpan = textSnapshot.CreateTrackingSpan(span, SpanTrackingMode.EdgeExclusive);
}
}
internal static ITrackingSpan GetEncapsulatingSpan(ITrackingSpan span1, ITrackingSpan span2)
{
// If either of the spans is null, return the other one. If they're both null, we'll end up returning null
// (as it should be).
if (span1 == null)
{
return(span2);
}
if (span2 == null)
{
return(span1);
}
// In the case where the two spans exist over different buffers, just use the first span.
if (span1.TextBuffer != span2.TextBuffer)
{
return(span1);
}
ITextSnapshot snapshot = span1.TextBuffer.CurrentSnapshot;
SnapshotSpan snapSpan1 = span1.GetSpan(snapshot);
SnapshotSpan snapSpan2 = span2.GetSpan(snapshot);
return(snapshot.CreateTrackingSpan
(Span.FromBounds
(Math.Min(snapSpan1.Start.Position, snapSpan2.Start.Position),
Math.Max(snapSpan1.End.Position, snapSpan2.End.Position)),
span1.TrackingMode));
}
public void AugmentCompletionSession(ICompletionSession session, IList <CompletionSet> completionSets)
{
if (_disposed)
{
throw new ObjectDisposedException("AntlrCompletionSource");
}
List <Completion> completions = new List <Completion>()
{
new Completion(Constants.ClassificationNameTerminal),
new Completion(Constants.ClassificationNameNonterminal),
new Completion(Constants.ClassificationNameComment),
new Completion(Constants.ClassificationNameKeyword)
};
ITextSnapshot snapshot = _buffer.CurrentSnapshot;
SnapshotPoint snapshot_point = (SnapshotPoint)session.GetTriggerPoint(snapshot);
if (snapshot_point == null)
{
return;
}
var line = snapshot_point.GetContainingLine();
SnapshotPoint start = snapshot_point;
while (start > line.Start && !char.IsWhiteSpace((start - 1).GetChar()))
{
start -= 1;
}
ITrackingSpan tracking_span = snapshot.CreateTrackingSpan(new SnapshotSpan(start, snapshot_point), SpanTrackingMode.EdgeInclusive);
completionSets.Add(new CompletionSet("All", "All", tracking_span, completions, Enumerable.Empty <Completion>()));
}
public override void DoOperation(GlyphDefinition glyph)
{
foreach (var replacement in _replacements)
{
try
{
var span = _snapshot.CreateTrackingSpan(replacement.OriginalOffset, replacement.OriginalLength, SpanTrackingMode.EdgeNegative).GetSpan(_snapshot);
if (span.GetText() != replacement.Original)
{
return;
}
var newSpan = span.Snapshot.CreateTrackingSpan(span.Start, replacement.OriginalLength, SpanTrackingMode.EdgeNegative);
_snapshot.TextBuffer.Replace(newSpan.GetSpan(newSpan.TextBuffer.CurrentSnapshot), replacement.Replacement);
}
catch (Exception e)
{
OutputPane.WriteMessage("error unable to do replacement : {0}", e);
}
}
glyph.Tag.Tagger.Reset();
}
public void AugmentQuickInfoSession(IQuickInfoSession session, IList <object> quickInfoContent, out ITrackingSpan applicableToSpan)
{
// Map the trigger point down to our buffer
ITextSnapshot snapshot = _subjectBuffer.CurrentSnapshot;
SnapshotPoint?subjectTriggerPoint = session.GetTriggerPoint(snapshot);
if (!subjectTriggerPoint.HasValue)
{
applicableToSpan = null;
return;
}
ITextStructureNavigator navigator = _navigatorService.GetTextStructureNavigator(_subjectBuffer);
TextExtent extent = navigator.GetExtentOfWord(subjectTriggerPoint.Value);
string extentText = extent.Span.GetText();
// What we are effectively doing here is placing this QuickInfo source at the end so that it
// can hijack the other previous QuickInfo sources. We replace them with colourised versions.
applicableToSpan = null;
if (quickInfoContent.Count > 0)
{
ITextBuffer cppQuickInfoContentBuffer = quickInfoContent[0] as ITextBuffer;
string cppQuickInfoText = cppQuickInfoContentBuffer.CurrentSnapshot.GetText();
TextBlock newContent = CreateColourisedContent(cppQuickInfoText);
quickInfoContent.RemoveAt(0);
quickInfoContent.Add(newContent);
applicableToSpan = snapshot.CreateTrackingSpan(extent.Span.Start, extent.Span.Length, SpanTrackingMode.EdgeInclusive);
}
}
public void AugmentCompletionSession(ICompletionSession session, IList <CompletionSet> completionSets)
{
if (_disposed)
{
throw new ObjectDisposedException("OokCompletionSource");
}
List <Completion> completions = new List <Completion>()
{
new Completion("Ook!"),
new Completion("Ook."),
new Completion("Ook?")
};
ITextSnapshot snapshot = _buffer.CurrentSnapshot;
var triggerPoint = (SnapshotPoint)session.GetTriggerPoint(snapshot);
var line = triggerPoint.GetContainingLine();
SnapshotPoint start = triggerPoint;
while (start > line.Start && !char.IsWhiteSpace((start - 1).GetChar()))
{
start -= 1;
}
var applicableTo = snapshot.CreateTrackingSpan(new SnapshotSpan(start, triggerPoint), SpanTrackingMode.EdgeInclusive);
completionSets.Add(new CompletionSet("All", "All", applicableTo, completions, Enumerable.Empty <Completion>()));
}
private ITrackingSpan FindApplicableSpan(ICompletionSession session, ClassificationSpan span, SnapshotPoint point)
{
// We eventually want to use an ITextStructureNavigator to expand the current point, but
// first we have to teach it what out structure is. For now, we just understand the Rtype
// syntax directly.
////ITextStructureNavigator navigator = this.sourceProvider.NavigatorService.GetTextStructureNavigator(this.textBuffer);
ITextSnapshot snapshot = session.TextView.TextSnapshot;
if (span != null)
{
return(snapshot.CreateTrackingSpan(span.Span, SpanTrackingMode.EdgeInclusive));
}
return(snapshot.CreateTrackingSpan(point, 0, SpanTrackingMode.EdgeInclusive));
}
public bool AugmentSignatureHelpSession(ISignatureHelpSession session, IList <ISignature> signatures, AstRoot ast, Action <object> triggerSession)
{
ITextSnapshot snapshot = _textBuffer.CurrentSnapshot;
int position = session.GetTriggerPoint(_textBuffer).GetPosition(snapshot);
// Retrieve parameter positions from the current text buffer snapshot
ParameterInfo parametersInfo = SignatureHelp.GetParametersInfoFromBuffer(ast, snapshot, position);
if (parametersInfo != null)
{
position = Math.Min(parametersInfo.SignatureEnd, position);
int start = Math.Min(position, snapshot.Length);
int end = Math.Min(parametersInfo.SignatureEnd, snapshot.Length);
ITrackingSpan applicableToSpan = snapshot.CreateTrackingSpan(Span.FromBounds(start, end), SpanTrackingMode.EdgeInclusive);
// Get collection of function signatures from documentation (parsed RD file)
IFunctionInfo functionInfo = FunctionIndex.GetFunctionInfo(parametersInfo.FunctionName, triggerSession, session.TextView);
if (functionInfo != null && functionInfo.Signatures != null)
{
foreach (ISignatureInfo signatureInfo in functionInfo.Signatures)
{
ISignature signature = CreateSignature(session, functionInfo, signatureInfo, applicableToSpan, ast, position);
signatures.Add(signature);
}
session.Properties["functionInfo"] = functionInfo;
return(true);
}
}
return(false);
}
internal void DocumentReopened(ITextDocument document)
{
_document = document;
ITextSnapshot snapshot = document.TextBuffer.CurrentSnapshot;
SnapshotPoint start;
SnapshotPoint end;
if (_useLineIndex)
{
start = PersistentSpan.LineIndexToSnapshotPoint(_startLine, _startIndex, snapshot);
end = PersistentSpan.LineIndexToSnapshotPoint(_endLine, _endIndex, snapshot);
if (end < start)
{
//Guard against the case where _start & _end are something like (100,2) & (101, 1).
//Those points would pass the argument validation (since _endLine > _startLine) but
//would cause problems if the document has only 5 lines since they would map to
//(5, 2) & (5, 1).
end = start;
}
}
else
{
start = new SnapshotPoint(snapshot, Math.Min(_nonTrackingSpan.Start, snapshot.Length));
end = new SnapshotPoint(snapshot, Math.Min(_nonTrackingSpan.End, snapshot.Length));
}
_span = snapshot.CreateTrackingSpan(new SnapshotSpan(start, end), _trackingMode);
_filePath = null;
}
/// <summary>
/// Provide a list of completion items that contains the valid string-substitution tokens
/// </summary>
public void AugmentCompletionSession(ICompletionSession session, IList <CompletionSet> completionSets)
{
// create a list of completions from the dictionary of valid tokens
List <Completion> completions = new List <Completion>();
foreach (KeyValuePair <string, string> token in PkgDefTokenTagger.ValidTokens)
{
completions.Add(new Completion(token.Key, token.Key, token.Value, null, null));
}
;
ITextSnapshot snapshot = _buffer.CurrentSnapshot;
var triggerPoint = (SnapshotPoint)session.GetTriggerPoint(snapshot);
if (triggerPoint == null)
{
return;
}
var line = triggerPoint.GetContainingLine();
SnapshotPoint start = triggerPoint - 1; // start selection to left of '$'
var applicableTo = snapshot.CreateTrackingSpan(new SnapshotSpan(start, triggerPoint), SpanTrackingMode.EdgeInclusive);
completionSets.Add(new CompletionSet("PkgDefTokens", "All", applicableTo, completions, Enumerable.Empty <Completion>()));
}
public void AugmentCompletionSession(ICompletionSession session, IList <CompletionSet> completionSets)
{
if (_disposed)
{
throw new ObjectDisposedException("DaxCompletionSource");
}
ITextSnapshot snapshot = _buffer.CurrentSnapshot;
var triggerPoint = (SnapshotPoint)session.GetTriggerPoint(snapshot);
if (triggerPoint == null)
{
return;
}
var line = triggerPoint.GetContainingLine();
SnapshotPoint start = triggerPoint;
while (start > line.Start && !char.IsWhiteSpace((start - 1).GetChar()))
{
start -= 1;
}
var applicableTo = snapshot.CreateTrackingSpan(new SnapshotSpan(start, triggerPoint), SpanTrackingMode.EdgeInclusive);
var completion = _completionDataProvider.GetCompletionDataSnapshot().GetCompletionData(_completionIconSource);
completionSets.Add(new CompletionSet("All", "All", applicableTo, completion, Enumerable.Empty <Completion>()));
}
public void AugmentQuickInfoSession(IQuickInfoSession session, IList <object> qiContent, out ITrackingSpan applicableToSpan)
{
// Map the trigger point down to our buffer.
SnapshotPoint?subjectTriggerPoint = session.GetTriggerPoint(subjectBuffer.CurrentSnapshot);
if (!subjectTriggerPoint.HasValue)
{
applicableToSpan = null;
return;
}
string issueKey = provider.CurrentIssueKey;
if (issueKey != null)
{
ITextSnapshot currentSnapshot = subjectTriggerPoint.Value.Snapshot;
SnapshotSpan querySpan = new SnapshotSpan(subjectTriggerPoint.Value, 0);
applicableToSpan = currentSnapshot.CreateTrackingSpan(querySpan.Start.Add(0).Position, issueKey.Length, SpanTrackingMode.EdgeInclusive);
qiContent.Add(createIssueTextFromKey(issueKey));
}
else
{
applicableToSpan = null;
}
}
public TrackingTag(ITextSnapshot snapshot, int start, int length)
{
Snapshot = snapshot;
Start = start;
Length = length;
Span = snapshot.CreateTrackingSpan(start, length, SpanTrackingMode.EdgeExclusive);
}
private ITrackingSpan GetApplicableToForStep(ITextSnapshot snapshot, SnapshotPoint triggerPoint, string parsedKeyword)
{
var line = triggerPoint.GetContainingLine();
SnapshotPoint keywordEnd = line.Start;
ForwardWhile(ref keywordEnd, triggerPoint, p => char.IsWhiteSpace(p.GetChar()));
if (parsedKeyword != null)
{
keywordEnd += parsedKeyword.Length;
}
else
{
ForwardWhile(ref keywordEnd, triggerPoint, p => !char.IsWhiteSpace(p.GetChar()));
}
var start = keywordEnd;
if (start < triggerPoint)
{
ForwardWhile(ref start, start + 1, p => char.IsWhiteSpace(p.GetChar()));
}
return(snapshot.CreateTrackingSpan(new SnapshotSpan(start, line.End), SpanTrackingMode.EdgeInclusive));
}
//FIXME: can we display some kind of "loading" message while it loads?
async Task <QuickInfoItem> CreateNuGetQuickInfo(ITextSnapshot snapshot, MSBuildRootDocument doc, MSBuildResolveResult rr, CancellationToken token)
{
IPackageInfo info = null;
var packageId = (string)rr.Reference;
try {
var frameworkId = doc.GetTargetFrameworkNuGetSearchParameter();
//FIXME: can we use the correct version here?
var infos = await provider.PackageSearchManager.SearchPackageInfo(packageId, null, frameworkId).ToTask(token);
//prefer non-local results as they will have more metadata
info = infos
.FirstOrDefault(p => p.SourceKind != ProjectFileTools.NuGetSearch.Feeds.FeedKind.Local)
?? infos.FirstOrDefault();
}
catch (Exception ex) when(!(ex is OperationCanceledException && token.IsCancellationRequested))
{
LoggingService.LogError("Error loading package description", ex);
}
var span = snapshot.CreateTrackingSpan(rr.ReferenceOffset, rr.ReferenceLength, SpanTrackingMode.EdgeInclusive);
return(new QuickInfoItem(span, provider.DisplayElementFactory.GetPackageInfoTooltip(packageId, info, FeedKind.NuGet)));
}
private void OnSpansChanged(object sender, SpansChangedEventArgs eventArgs)
{
IEnumerable <System.Web.Razor.Parser.SyntaxTree.Span> arg_8C_0 = eventArgs.Spans;
Microsoft.VisualStudio.Text.Span?span = null;
ITextSnapshot currentSnapshot = _diskBuffer.CurrentSnapshot;
if (_spansToClassify.Count > 0)
{
SnapshotPoint startPoint = _spansToClassify[0].TrackingSpan.GetStartPoint(currentSnapshot);
SnapshotPoint endPoint = _spansToClassify[_spansToClassify.Count - 1].TrackingSpan.GetEndPoint(currentSnapshot);
span = new Microsoft.VisualStudio.Text.Span?(Microsoft.VisualStudio.Text.Span.FromBounds(startPoint.Position, endPoint.Position));
}
_spansToClassify = new List <ClassificationData>();
IClassificationType classificationType = null;
foreach (System.Web.Razor.Parser.SyntaxTree.Span current in arg_8C_0)
{
switch (current.Kind)
{
case SpanKind.Transition:
case SpanKind.MetaCode:
classificationType = _razorDelimiterClassificationType;
break;
case SpanKind.Comment:
classificationType = _razorCommentClassificationType;
break;
}
if (classificationType != null)
{
Microsoft.VisualStudio.Text.Span span2 = new Microsoft.VisualStudio.Text.Span(current.Start.AbsoluteIndex, current.Length);
ClassificationData item = new ClassificationData(currentSnapshot.CreateTrackingSpan(span2, SpanTrackingMode.EdgeExclusive), classificationType);
_spansToClassify.Add(item);
classificationType = null;
}
}
if (_spansToClassify.Count > 0)
{
SnapshotPoint startPoint2 = _spansToClassify[0].TrackingSpan.GetStartPoint(currentSnapshot);
SnapshotPoint endPoint2 = _spansToClassify[_spansToClassify.Count - 1].TrackingSpan.GetEndPoint(currentSnapshot);
if (!span.HasValue)
{
span = new Microsoft.VisualStudio.Text.Span?(Microsoft.VisualStudio.Text.Span.FromBounds(startPoint2.Position, endPoint2.Position));
}
else
{
span = new Microsoft.VisualStudio.Text.Span?(Microsoft.VisualStudio.Text.Span.FromBounds(Math.Min(span.Value.Start, startPoint2.Position), Math.Max(span.Value.End, endPoint2.Position)));
}
}
if (span.HasValue)
{
EventHandler <ClassificationChangedEventArgs> classificationChanged = ClassificationChanged;
if (classificationChanged != null)
{
SnapshotSpan changeSpan = new SnapshotSpan(currentSnapshot, span.Value);
classificationChanged(this, new ClassificationChangedEventArgs(changeSpan));
}
}
}
public void AugmentQuickInfoSession(IQuickInfoSession session, IList <object> qiContent, out ITrackingSpan applicableToSpan)
{
// Map the trigger point down to our buffer.
SnapshotPoint?subjectTriggerPoint = session.GetTriggerPoint(m_subjectBuffer.CurrentSnapshot);
if (!subjectTriggerPoint.HasValue)
{
applicableToSpan = null;
return;
}
var fileSpecificTooltips = fileSpecificTooltipProvider.GetFileSpecificTooltipDefinitions(GetFileFullPath());
ITextSnapshot currentSnapshot = subjectTriggerPoint.Value.Snapshot;
SnapshotSpan querySpan = new SnapshotSpan(subjectTriggerPoint.Value, 0);
//look for occurrences of our QuickInfo words in the span
ITextStructureNavigator navigator = m_provider.NavigatorService.GetTextStructureNavigator(m_subjectBuffer);
TextExtent extent = navigator.GetExtentOfWord(subjectTriggerPoint.Value);
string searchText = extent.Span.GetText();
foreach (TooltipDefinition tooltipDefinition in fileSpecificTooltips)
{
int foundIndex = searchText.IndexOf(tooltipDefinition.Input, StringComparison.CurrentCultureIgnoreCase);
if (foundIndex > -1)
{
var start = extent.Span.Start + foundIndex;
applicableToSpan = currentSnapshot.CreateTrackingSpan(start, tooltipDefinition.Input.Length, SpanTrackingMode.EdgeInclusive);
qiContent.Add(tooltipDefinition.Description);
return;
}
}
applicableToSpan = null;
}
public void AugmentQuickInfoSession(IQuickInfoSession session, IList <object> quickInfoContent, out ITrackingSpan applicableToSpan)
{
applicableToSpan = null;
// Map the trigger point down to our buffer.
SnapshotPoint?subjectTriggerPoint = session.GetTriggerPoint(_subjectBuffer.CurrentSnapshot);
if (!subjectTriggerPoint.HasValue)
{
return;
}
ITextSnapshot currentSnapshot = subjectTriggerPoint.Value.Snapshot;
ITextStructureNavigator navigator = _provider.NavigatorService.GetTextStructureNavigator(_subjectBuffer);
TextExtent extent = navigator.GetExtentOfWord(subjectTriggerPoint.Value);
string key = extent.Span.GetText();
//look for occurrences of our QuickInfo words in the span
SQDeclaration dec = _languageService.Find(key);
if (dec != null)
{
quickInfoContent.Add(dec.GetDescription());
//quickInfoContent.Add(searchText);
applicableToSpan = currentSnapshot.CreateTrackingSpan(extent.Span.Start, key.Length, SpanTrackingMode.EdgeInclusive);
}
}
private void TextBuffer_Changed(object sender, TextContentChangedEventArgs e)
{
if (this.shouldTrackChange != null && !this.shouldTrackChange())
{
return;
}
if (e.Changes.Count > 1)
{
this.changedAll = true;
}
else
{
if (this.changedAll)
{
return;
}
ITextSnapshot after = e.After;
foreach (ITextChange textChange in (IEnumerable <ITextChange>)e.Changes)
{
this.changes.Add(after.CreateTrackingSpan(textChange.NewPosition, textChange.NewLength, SpanTrackingMode.EdgeExclusive));
if (textChange.NewLength < textChange.OldLength)
{
this.containsRangeDeletions = true;
}
}
}
}
public void AugmentQuickInfoSession(
IQuickInfoSession session, IList <object> quickInfoContent,
out ITrackingSpan applicableToSpan)
{
applicableToSpan = null;
SnapshotPoint?subjectTriggerPoint =
session.GetTriggerPoint(this.textBuffer.CurrentSnapshot);
if (!subjectTriggerPoint.HasValue)
{
return;
}
ITextSnapshot currentSnapshot = subjectTriggerPoint.Value.Snapshot;
SnapshotSpan querySpan = new SnapshotSpan(subjectTriggerPoint.Value, 0);
var tagAggregator = GetAggregator(session);
TextExtent extent = FindExtentAtPoint(subjectTriggerPoint);
if (CheckForPrefixTag(tagAggregator, extent.Span))
{
String prefix = extent.Span.GetText();
String url = FindNSUri(extent.Span, GetDocText(extent.Span));
applicableToSpan = currentSnapshot.CreateTrackingSpan(
extent.Span, SpanTrackingMode.EdgeInclusive
);
quickInfoContent.Add(CreateInfoText(prefix, url));
}
}
/// <summary>
/// Gets the quick information item asynchronous.
/// </summary>
/// <owner>Anton Patron</owner>
/// <param name="session">The session.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>The <see cref="QuickInfoItem"/></returns>
public async Task <QuickInfoItem> GetQuickInfoItemAsync(IAsyncQuickInfoSession session, CancellationToken cancellationToken)
{
SnapshotPoint?subjectTriggerPoint = session.GetTriggerPoint(this.m_subjectBuffer.CurrentSnapshot);
if (!subjectTriggerPoint.HasValue)
{
return(null);
}
ITextSnapshot currentSnapshot = subjectTriggerPoint.Value.Snapshot;
ITextStructureNavigator navigator = this.m_provider.NavigatorService.GetTextStructureNavigator(this.m_subjectBuffer);
TextExtent extent = navigator.GetExtentOfWord(subjectTriggerPoint.Value);
string searchText = extent.Span.GetText();
var elements = await this.m_provider.TranslatorService.GetTooltipElementsAsync(searchText).ConfigureAwait(false);
if (!elements.Any())
{
return(null);
}
var applicableToSpan = currentSnapshot.CreateTrackingSpan(extent.Span.Start, searchText.Length, SpanTrackingMode.EdgeInclusive);
var element = QuickInfoSource.ComposeContainerElement(elements);
return(new QuickInfoItem(applicableToSpan, element));
}
/// <summary>
/// Asynchronously constructs a line map from a <paramref name="snapshot"/> and <paramref name="code"/>.
/// </summary>
/// <param name="snapshot">The current text snapshot.</param>
/// <param name="code">The code to derive a line map from.</param>
/// <param name="cancelToken">Cancellation token.</param>
/// <returns>
/// A <see cref="LineMap"/> if <paramref name="code"/> was parsed correctly,
/// <c>null</c> if there was invalid code or it was canceled.
/// </returns>
internal static Task<LineMap> ConstructAsync(ITextSnapshot snapshot, string code, CancellationToken cancelToken)
{
if (snapshot == null)
throw new ArgumentNullException ("snapshot");
if (code == null)
throw new ArgumentNullException ("code");
return Task<LineMap>.Factory.StartNew (() =>
{
try
{
var tree = SyntaxTree.Parse (code, cancellationToken: cancelToken);
if (tree.Errors.Any (p => p.ErrorType == ErrorType.Error))
return null;
var identifier = new IdentifyingVisitor();
tree.AcceptVisitor (identifier);
var spans = new Dictionary<int, ITrackingSpan> (identifier.LineMap.Count);
foreach (var kvp in identifier.LineMap)
{
ITextSnapshotLine line = snapshot.GetLineFromLineNumber (kvp.Value - 1);
ITrackingSpan span = snapshot.CreateTrackingSpan (line.Extent, SpanTrackingMode.EdgeExclusive);
spans.Add (kvp.Key, span);
}
return (cancelToken.IsCancellationRequested) ? null : new LineMap (spans);
}
catch (OperationCanceledException)
{
return null;
}
}, cancelToken);
}
private static ITrackingSpan GetReplacementSpanFromCompletions(ITextSnapshot snapshot, Protocol.Response.AutocompleteResponse.Completion c)
{
int start = c.replaceStart;
int length = c.replaceEnd - start;
return(snapshot.CreateTrackingSpan(start, length, SpanTrackingMode.EdgeInclusive));
}
private void AugmentCompletionSession(IList <CompletionSet> completionSets, SnapshotPoint triggerPoint, ITextSnapshot snapshot)
{
var line = triggerPoint.GetContainingLine();
List <Completion> completions = new List <Completion>();
var stateAndDialect = GetLineStartStateAndDialect(line);
var expectedTokens = GherkinEditorParser.GetExpectedTokens(stateAndDialect.Item1);
AddCompletionsFromExpectedTokens(expectedTokens, completions, stateAndDialect.Item2);
if (completions.Count == 0)
{
return;
}
var applicableToSpan = CalculateApplicableToSpan(triggerPoint, line);
var applicableToText = applicableToSpan.GetText();
if (applicableToText.Length > 0 && completions.Any(c => applicableToText.StartsWith(c.InsertionText)))
{
return;
}
var applicableTo = snapshot.CreateTrackingSpan(applicableToSpan, SpanTrackingMode.EdgeInclusive);
completionSets.Add(new CompletionSet("Gherkin", "Gherkin", applicableTo, completions, Enumerable.Empty <Completion>()));
}
internal void InitializeTrackingSpans(ITextSnapshot textSnapshot)
{
this.TrackingSpans = this.Spans.Select(s => textSnapshot.CreateTrackingSpan(s.ToSpan(), SpanTrackingMode.EdgeExclusive)).ToList();
if (this.ChildItems != null)
{
this.ChildItems.Do(i => i.InitializeTrackingSpans(textSnapshot));
}
}
private Span ComputeReplacementSpan(ITextBuffer subjectBuffer, ITextSnapshot snapshot)
{
var trackingSpan = snapshot.CreateTrackingSpan(FilterSpan.ToSpan(), SpanTrackingMode.EdgeInclusive);
var currentSpan = trackingSpan.GetSpan(subjectBuffer.CurrentSnapshot);
return Span.FromBounds(subjectBuffer.CurrentSnapshot[currentSpan.Start - 1] == '<' && _beforeCaretText[0] == '<'
? currentSpan.Start - 1
: currentSpan.Start,
currentSpan.End);
}
private ITrackingSpan GetApplicableToSpan(ITextSnapshot snapshot, SnapshotPoint triggerPoint)
{
var line = triggerPoint.GetContainingLine();
SnapshotPoint start = triggerPoint;
while (start > line.Start && !char.IsWhiteSpace((start - 1).GetChar()))
{
start -= 1;
}
return snapshot.CreateTrackingSpan(new SnapshotSpan(start, line.End), SpanTrackingMode.EdgeInclusive);
}
public RoslynOutliningRegionTag(
ITextEditorFactoryService textEditorFactoryService,
IProjectionBufferFactoryService projectionBufferFactoryService,
IEditorOptionsFactoryService editorOptionsFactoryService,
ITextSnapshot snapshot,
BlockSpan outliningSpan)
{
_textEditorFactoryService = textEditorFactoryService;
_projectionBufferFactoryService = projectionBufferFactoryService;
_editorOptionsFactoryService = editorOptionsFactoryService;
_subjectBuffer = snapshot.TextBuffer;
BlockSpan = outliningSpan;
_hintSpan = snapshot.CreateTrackingSpan(BlockSpan.HintSpan.ToSpan(), SpanTrackingMode.EdgeExclusive);
}
/// <summary>
/// Returns the applicable span at the provided position.
/// </summary>
/// <returns>A tracking span, or null if there is no token at the
/// provided position.</returns>
internal static ITrackingSpan GetApplicableSpan(ITextSnapshot snapshot, int position) {
var classifier = snapshot.TextBuffer.GetNodejsClassifier();
var line = snapshot.GetLineFromPosition(position);
if (classifier == null || line == null) {
return null;
}
var spanLength = position - line.Start.Position;
// Increase position by one to include 'fob' in: "abc.|fob"
if (spanLength < line.Length) {
spanLength += 1;
}
var classifications = classifier.GetClassificationSpans(new SnapshotSpan(line.Start, spanLength));
// Handle "|"
if (classifications == null || classifications.Count == 0) {
return null;
}
var lastToken = classifications[classifications.Count - 1];
// Handle "fob |"
if (lastToken == null || position > lastToken.Span.End) {
return null;
}
if (position > lastToken.Span.Start) {
if (lastToken.CanComplete()) {
// Handle "fo|o"
return snapshot.CreateTrackingSpan(lastToken.Span, SpanTrackingMode.EdgeInclusive);
} else {
// Handle "<|="
return null;
}
}
var secondLastToken = classifications.Count >= 2 ? classifications[classifications.Count - 2] : null;
if (lastToken.Span.Start == position && lastToken.CanComplete() &&
(secondLastToken == null || // Handle "|fob"
position > secondLastToken.Span.End || // Handle "if |fob"
!secondLastToken.CanComplete())) { // Handle "abc.|fob"
return snapshot.CreateTrackingSpan(lastToken.Span, SpanTrackingMode.EdgeInclusive);
}
// Handle "abc|."
// ("ab|c." would have been treated as "ab|c")
if (secondLastToken != null && secondLastToken.Span.End == position && secondLastToken.CanComplete()) {
return snapshot.CreateTrackingSpan(secondLastToken.Span, SpanTrackingMode.EdgeInclusive);
}
return null;
}
private static ITrackingSpan CreateTrackingSpan(ITextSnapshot snapshot, Span span)
{
return snapshot.CreateTrackingSpan(span, SpanTrackingMode.EdgeExclusive);
}
private ITrackingSpan GetApplicableToForStep(ITextSnapshot snapshot, SnapshotPoint triggerPoint, string parsedKeyword)
{
var line = triggerPoint.GetContainingLine();
SnapshotPoint keywordEnd = line.Start;
ForwardWhile(ref keywordEnd, triggerPoint, p => char.IsWhiteSpace(p.GetChar()));
if (parsedKeyword != null)
keywordEnd += parsedKeyword.Length;
else
ForwardWhile(ref keywordEnd, triggerPoint, p => !char.IsWhiteSpace(p.GetChar()));
var start = keywordEnd;
if (start < triggerPoint)
ForwardWhile(ref start, start + 1, p => char.IsWhiteSpace(p.GetChar()));
return snapshot.CreateTrackingSpan(new SnapshotSpan(start, line.End), SpanTrackingMode.EdgeInclusive);
}
private static ITrackingSpan GetReplacementSpanFromCompletions(ITextSnapshot snapshot, Protocol.Response.AutocompleteResponse.Completion c)
{
int start = c.replaceStart;
int length = c.replaceEnd - start;
return snapshot.CreateTrackingSpan(start, length, SpanTrackingMode.EdgeInclusive);
}
private void AddTokensFromText(ITextSnapshot snapshot, IList<LanguageToken> tokens, int startIndex,
string spanText)
{
Match match = _resourcesRegex.Match(spanText);
while (match.Success)
{
Group keyGroup = match.Groups["key"];
string key = keyGroup.Value;
List<TranslationKeyInfo> translations = _translationKeys.GetTranslationsForKey(key).ToList();
if (translations.Any())
{
var languageToken = new LanguageToken();
languageToken.TranslationKeys = translations;
languageToken.Span = snapshot.CreateTrackingSpan(startIndex + keyGroup.Index, keyGroup.Length,
SpanTrackingMode.EdgeExclusive);
languageToken.TarnslationsString = translations
.Aggregate("\n", (curr, tr) => string.Format("{0}{1}: {2}\n", curr, tr.Language, tr.Value));
tokens.Add(languageToken);
}
match = match.NextMatch();
}
}
private ITrackingSpan GetApplicableToForStep(ITextSnapshot snapshot, SnapshotPoint triggerPoint)
{
var line = triggerPoint.GetContainingLine();
SnapshotPoint start = line.Start;
ForwardWhile(ref start, triggerPoint, p => char.IsWhiteSpace(p.GetChar()));
ForwardWhile(ref start, triggerPoint, p => !char.IsWhiteSpace(p.GetChar()));
if (start < triggerPoint)
ForwardWhile(ref start, start + 1, p => char.IsWhiteSpace(p.GetChar()));
return snapshot.CreateTrackingSpan(new SnapshotSpan(start, line.End), SpanTrackingMode.EdgeInclusive);
}
private void GetTrackingSpan(ITextSnapshot snapshot, int triggerPoint)
{
ITextSnapshotLine line = snapshot.GetLineFromPosition(triggerPoint);
string lineString = line.GetText();
var stopChars = new char[] {' ', '\t', '{', '}', '.', '"', ':'};
int start = lineString.Substring(0, triggerPoint - line.Start.Position).LastIndexOfAny(stopChars) + line.Start.Position + 1;
int length = lineString.Substring(triggerPoint - line.Start.Position).IndexOfAny(stopChars) + triggerPoint - start;
_trackingSpan = snapshot.CreateTrackingSpan(start, length < 0 ? 0 : length, SpanTrackingMode.EdgeInclusive);
}
///////////////////////////////////////////////////////////////////////////////////
//
// Validate the mardown directive syntax according to the ruleset definitions
//
// Copyright (c) 2014 Microsoft Corporation.
// Author: Junyi Yi ([email protected]) - Initial version
//
///////////////////////////////////////////////////////////////////////////////////
/// <summary>
/// Validate the whole document according to the specified ruleset.
/// </summary>
/// <param name="snapshot">The whole document snapshot.</param>
/// <param name="errorTagger">The tagger used to generate error squiggles.</param>
/// <param name="ruleset">The specified ruleset.</param>
public static void ValidateDirectiveSyntax(ITextSnapshot snapshot, DirectiveRuleset ruleset, SimpleTagger<ErrorTag> errorTagger)
{
// Remove all current error squiggles
errorTagger.RemoveTagSpans(errorTagSpan => true);
// Get the full document text and clear all HTML tags
string text = snapshot.GetText();
text = MarkdownParser.DestroyHtmlTags(text);
// Three cases:
// 0123456789 01234567 8 01234567 8
// [ WA ab ] [ WA ab \n [ WA ab EOT
// | |-endIndex=9 | |-endIndex=8 | |-endIndex=8
// |-startIndex=0 |-startIndex=0 |-startIndex=0
// Greedily search for the pair of '[...]' (supports nested pair '[... [...] ...]')
// Here 'Greedily' means if we have a string '[...[...]', it would also treat the latter '[...]' as the pair
for (int startIndex = text.IndexOf('['); startIndex >= 0; startIndex = text.IndexOf('[', startIndex))
{
int endIndex = MarkdownParser.FindCorrespondingEndBracket(text, startIndex + 1);
// Get the directive content string
ITrackingSpan overallDirective = snapshot.CreateTrackingSpan(startIndex + 1, endIndex - startIndex - 1, SpanTrackingMode.EdgeInclusive);
string directive = overallDirective.GetText(snapshot);
var directiveMatches = Regex.Matches(directive, string.Concat(@"^\s*(", ValidationUtilities.DirectiveNameRegularPattern, @")(.*)$"));
if (directiveMatches.Count != 1 || !directiveMatches[0].Success || directiveMatches[0].Groups.Count != 3 || directiveMatches[0].Value != directive)
{
startIndex++;
continue;
}
string directiveName = directiveMatches[0].Groups[1].Value;
string directiveContent = directiveMatches[0].Groups[2].Value;
var rule = ruleset.TryGetDirectiveRule(directiveName);
if (rule != null)
{
// Get the preceding and following directive string of the same line
ITextSnapshotLine line = snapshot.GetLineFromPosition(startIndex);
string precedingText = snapshot.GetText(line.Start, startIndex - line.Start);
string followingText = endIndex < line.End ? snapshot.GetText(endIndex + 1, line.End - endIndex - 1) : string.Empty;
// If we found a exactly-matched rule, just validate it
string message = rule.Validate(directiveContent, precedingText, followingText);
if (message != null)
{
ITrackingSpan squiggleSpan = overallDirective;
if (rule.SquiggleWholeLine)
{
squiggleSpan = snapshot.CreateTrackingSpan(line.Start, line.Length, SpanTrackingMode.EdgeInclusive);
}
errorTagger.CreateTagSpan(squiggleSpan, new ErrorTag(PredefinedErrorTypeNames.SyntaxError, message));
}
// If we miss the closing bracket, give out the prompt message
if (endIndex >= text.Length || text[endIndex] != ']')
{
errorTagger.CreateTagSpan(snapshot.CreateTrackingSpan(line.End, 0, SpanTrackingMode.EdgePositive), new ErrorTag(PredefinedErrorTypeNames.CompilerError, "Missing the closing bracket"));
}
}
else
{
// Otherwise we may take a look at the suspects
var suspects = ruleset.GetSuspects(directive);
if (suspects.Count() > 0)
{
StringBuilder suspectPrompt = new StringBuilder();
suspectPrompt.AppendLine("Are you trying to enter one of the following directives?");
foreach (var suspect in suspects)
{
suspectPrompt.AppendLine(string.Format(" \u2022 {0} - {1}", suspect.ParentRule.DirectiveName, suspect.SuggestionMessage));
}
errorTagger.CreateTagSpan(overallDirective, new ErrorTag(PredefinedErrorTypeNames.Warning, suspectPrompt.ToString().TrimEnd()));
}
}
startIndex = endIndex;
}
}
public void ReportParseErrors(IParseResult parseResult, ITextSnapshot snapshot)
{
_errorListProvider.SuspendRefresh();
try
{
// remove any previously created errors to get a clean start
ClearErrors();
var messages = (CompilerMessageList)parseResult.CompilerMessages;
foreach (var error in messages.GetMessages())
{
// creates the instance that will be added to the Error List
var nSpan = error.Location.Span;
var span = new Span(nSpan.StartPos, nSpan.Length);
if (span.Start >= snapshot.Length)
continue;
ErrorTask task = new ErrorTask();
task.Category = TaskCategory.All;
task.Priority = TaskPriority.Normal;
task.Document = _textBuffer.Properties.GetProperty<ITextDocument>(typeof(ITextDocument)).FilePath;
task.ErrorCategory = TranslateErrorCategory(error);
task.Text = error.Text;
task.Line = snapshot.GetLineNumberFromPosition(span.Start);
task.Column = span.Start - snapshot.GetLineFromLineNumber(task.Line).Start;
task.Navigate += OnTaskNavigate;
_errorListProvider.Tasks.Add(task);
_previousErrors.Add(task);
var trackingSpan = snapshot.CreateTrackingSpan(span, SpanTrackingMode.EdgeNegative);
_squiggleTagger.CreateTagSpan(trackingSpan, new ErrorTag("syntax error", error.Text));
_previousSquiggles.Add(new TrackingTagSpan<IErrorTag>(trackingSpan, new ErrorTag("syntax error", error.Text)));
}
}
finally { _errorListProvider.ResumeRefresh(); }
}
private void CreateTracking(IWpfTextView textView, ITextSnapshot textSnapshot, Span span)
{
if (m_trackingSpan != null)
return;
m_textView = textView;
if (m_tagger == null)
{
IComponentModel componentModel = (IComponentModel)m_serviceProvider.GetService(typeof(SComponentModel));
ISarifLocationProviderFactory sarifLocationProviderFactory = componentModel.GetService<ISarifLocationProviderFactory>();
// Get a SimpleTagger over the buffer to color
m_tagger = sarifLocationProviderFactory.GetTextMarkerTagger(m_textView.TextBuffer);
}
// Add the marker
if (m_tagger != null)
{
// The list of colors for TextMarkerTag are defined in Platform\Text\Impl\TextMarkerAdornment\TextMarkerProviderFactory.cs
m_trackingSpan = textSnapshot.CreateTrackingSpan(span, SpanTrackingMode.EdgeExclusive);
}
}
