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