private void UpdateWordAdornments() { var point = _requestedPoint; // Find all words in the buffer like the one the caret is on TextExtent extent = _textStructureNavigator.GetExtentOfWord(point); // If we've selected something not worth highlighting, we might have missed a "word" by a little bit if (!IsExtentValid(extent, point)) { //Before we retry, make sure it is worthwhile if (extent.Span.Start != point || point == point.GetContainingLine().Start || char.IsWhiteSpace((point - 1).GetChar())) { // If we couldn't find a word, clear out the existing markers SynchronousUpdate(point, new NormalizedSnapshotSpanCollection(), null); return; } else { // Try again, one character previous. If the caret is at the end of a word, pick up the word. extent = _textStructureNavigator.GetExtentOfWord(point - 1); // If the word still isn't valid, we're done if (!IsExtentValid(extent, point)) { // If we couldn't find a word, clear out the existing markers SynchronousUpdate(point, new NormalizedSnapshotSpanCollection(), null); return; } } } FindAndUpdateSpans(extent, point); }
private static CompletionContext GetCompletionContext(PaketDocument paketDocument, ITextStructureNavigator navigator, SnapshotPoint position) { var startPos = position.Position; var length = 0; if (position.Position > 0) { TextExtent endPosition = navigator.GetExtentOfWord(position); TextExtent startPosition = endPosition; // try to extend the span over . while (!String.IsNullOrWhiteSpace(paketDocument.GetCharAt(startPosition.Span.Start.Position - 1))) { startPosition = navigator.GetExtentOfWord(startPosition.Span.Start - 2); } startPos = startPosition.Span.Start.Position; length = endPosition.Span.End.Position - startPos; } var span = new Span(startPos, length); var snapShotSpan = new SnapshotSpan(position.Snapshot, span); var context = new CompletionContext(span); context.ContextType = CompletionContextType.InstalledNuGet; context.Snapshot = snapShotSpan.Snapshot; return(context); }
public int Exec(ref Guid pguidCmdGroup, uint nCmdID, uint nCmdexecopt, IntPtr pvaIn, IntPtr pvaOut) { char typedChar = char.MinValue; if (pguidCmdGroup == VSConstants.VSStd2K && nCmdID == (uint)VSConstants.VSStd2KCmdID.TYPECHAR) { typedChar = (char)(ushort)Marshal.GetObjectForNativeVariant(pvaIn); if (typedChar.Equals('(') && (m_session == null || m_session.IsDismissed)) { //move the point back so it's in the preceding word SnapshotPoint point = m_textView.Caret.Position.BufferPosition - 1; TextExtent extent = m_navigator.GetExtentOfWord(point); string word = extent.Span.GetText(); m_session = m_broker.CreateSignatureHelpSession(m_textView, m_textView.TextSnapshot.CreateTrackingPoint(point.Position, PointTrackingMode.Positive), true); m_session.Properties.AddProperty("word", word); m_session.Start(); } else if (typedChar.Equals(',') && (m_session == null || m_session.IsDismissed)) { int paramPos; int pos = m_textView.Caret.Position.BufferPosition - 1; while (pos > 0 && m_textView.TextSnapshot[pos] != '(') { pos--; } if (pos > 0) { paramPos = pos; pos--; while (pos > 0 && char.IsWhiteSpace(m_textView.TextSnapshot[pos])) { pos--; } if (pos > 0) { SnapshotPoint point = new SnapshotPoint(m_textView.TextSnapshot, pos); TextExtent extent = m_navigator.GetExtentOfWord(point); string word = extent.Span.GetText(); m_session = m_broker.CreateSignatureHelpSession(m_textView, m_textView.TextSnapshot.CreateTrackingPoint(m_textView.Caret.Position.BufferPosition - 1, PointTrackingMode.Positive), true); m_session.Properties.AddProperty("word", word); m_session.Properties.AddProperty("span", new Span(paramPos, m_textView.Caret.Position.BufferPosition - paramPos)); m_session.Start(); } } } else if (typedChar.Equals(')') && m_session != null) { m_session.Dismiss(); m_session = null; } else if (m_session != null && m_session.IsDismissed) { m_session = null; } } return(m_nextCommandHandler.Exec(ref pguidCmdGroup, nCmdID, nCmdexecopt, pvaIn, pvaOut)); }
private TextExtent GetExtentOfWordWorker(SnapshotPoint position, CancellationToken cancellationToken) { var textLength = position.Snapshot.Length; if (textLength == 0) { return(_naturalLanguageNavigator.GetExtentOfWord(position)); } // If at the end of the file, go back one character so stuff works if (position == textLength && position > 0) { position -= 1; } // If we're at the EOL position, return the line break's extent var line = position.Snapshot.GetLineFromPosition(position); if (position >= line.End && position < line.EndIncludingLineBreak) { return(new TextExtent(new SnapshotSpan(line.End, line.EndIncludingLineBreak - line.End), isSignificant: false)); } var document = GetDocument(position, cancellationToken); if (document != null) { var root = document.GetSyntaxRootSynchronously(cancellationToken); var trivia = root.FindTrivia(position, findInsideTrivia: true); if (trivia != default) { if (trivia.Span.Start == position && _provider.ShouldSelectEntireTriviaFromStart(trivia)) { // We want to select the entire comment return(new TextExtent(trivia.Span.ToSnapshotSpan(position.Snapshot), isSignificant: true)); } } var token = root.FindToken(position, findInsideTrivia: true); // If end of file, go back a token if (token.Span.Length == 0 && token.Span.Start == textLength) { token = token.GetPreviousToken(); } if (token.Span.Length > 0 && token.Span.Contains(position) && !_provider.IsWithinNaturalLanguage(token, position)) { // Cursor position is in our domain - handle it. return(_provider.GetExtentOfWordFromToken(token, position)); } } // Fall back to natural language navigator do its thing. return(_naturalLanguageNavigator.GetExtentOfWord(position)); }
internal static SnapshotSpan?GetNextWord(this ITextStructureNavigator navigator, SnapshotPoint position) { var word = navigator.GetExtentOfWord(position); while (!word.IsSignificant && !word.Span.IsEmpty) { word = navigator.GetExtentOfWord(word.Span.End); } return(word.IsSignificant ? new SnapshotSpan?(word.Span) : null); }
private static CompletionContext GetCompletionContext(PaketDocument paketDocument, ITextStructureNavigator navigator, SnapshotPoint position) { TextExtent endPosition = navigator.GetExtentOfWord(position - 1); TextExtent startPosition = endPosition; // try to extend the span over . while (!String.IsNullOrWhiteSpace(paketDocument.GetCharAt(startPosition.Span.Start.Position - 1))) { startPosition = navigator.GetExtentOfWord(startPosition.Span.Start - 2); } var startPos = startPosition.Span.Start.Position; var length = endPosition.Span.End.Position - startPos; var span = new Span(startPos, length); var snapShotSpan = new SnapshotSpan(position.Snapshot, span); var context = new CompletionContext(span); var pos = startPosition.Span.Start; if (startPosition.Span.Start.Position > 0) { pos = startPosition.Span.Start - 1; } TextExtent previous = navigator.GetExtentOfWord(pos); // try to extend the span over blanks while (paketDocument.GetCharAt(previous.Span.Start.Position) == " ") { var pos2 = previous.Span.Start; if (previous.Span.Start.Position > 0) { pos2 = previous.Span.Start - 1; } previous = navigator.GetExtentOfWord(pos2); } var lastWord = previous.Span.GetText(); switch (lastWord) { case "nuget": context.ContextType = CompletionContextType.NuGet; break; case "source": context.ContextType = CompletionContextType.Source; break; case "strategy": context.ContextType = CompletionContextType.Strategy; break; default: context.ContextType = CompletionContextType.Keyword; break; } context.Snapshot = snapShotSpan.Snapshot; return(context); }
/// <summary> /// Determine if this IAsyncCompletionSource wants to participate in the current auto-completion session. /// </summary> /// <param name="trigger">The action that triggered the auto-completion session.</param> /// <param name="triggerLocation">The location in the text where auto-completion was triggered.</param> /// <param name="cancellationToken">A cancellation token.</param> /// <returns>CompletionStartData.DoesNotParticipateInCompletion, if the current instance does not want to provide items for auto-completion; otherwise, an instance of CompletionStartData.</returns> public CompletionStartData InitializeCompletion(CompletionTrigger trigger, SnapshotPoint triggerLocation, CancellationToken cancellationToken) { // Get the syntactical parts of the current line, and check if the trigger location is after the XML doc delimiter '///' IList <ClassificationSpan> spans = _classifier.GetClassificationSpans(triggerLocation.GetContainingLine().Extent); ClassificationSpan commentDelimiter = spans.FirstOrDefault(s => s.ClassificationType.IsOfType(ClassificationTypeNames.XmlDocCommentDelimiter)); if (commentDelimiter == null || commentDelimiter.Span.End > triggerLocation || cancellationToken.IsCancellationRequested) { // No XML comment in that line, or trigger location is before the '///' comment start. return(CompletionStartData.DoesNotParticipateInCompletion); } // See if trigger location is within a text span int triggerSpanIndex = -1; for (int i = 0; i < spans.Count; i++) { if (spans[i].Span.Contains(triggerLocation)) { triggerSpanIndex = i; break; } else if (cancellationToken.IsCancellationRequested) { return(CompletionStartData.DoesNotParticipateInCompletion); } } if (triggerSpanIndex == -1) // Not within a word (EOL etc.) { if (trigger.Character == '<' || (trigger.Character == '\0' && (trigger.Reason == CompletionTriggerReason.Invoke || trigger.Reason == CompletionTriggerReason.InvokeAndCommitIfUnique))) { SnapshotSpan applicableToSpan = _navigator.GetExtentOfWord(triggerLocation).Span; return(new CompletionStartData(CompletionParticipation.ProvidesItems, applicableToSpan)); } else { return(CompletionStartData.DoesNotParticipateInCompletion); } } else // Within a word { ClassificationSpan triggerSpan = spans[triggerSpanIndex]; if (triggerSpan.ClassificationType.IsOfType(ClassificationTypeNames.XmlDocCommentText)) // Just text, so an xml element could be inserted here { if (trigger.Character == '<') { SnapshotSpan applicableToSpan = _navigator.GetExtentOfWord(triggerLocation).Span; return(new CompletionStartData(CompletionParticipation.ProvidesItems, applicableToSpan)); } } } return(CompletionStartData.DoesNotParticipateInCompletion); }
internal static SnapshotSpan?GetNextWord(this ITextStructureNavigator navigator, SnapshotPoint position) { TextExtent extentOfWord = navigator.GetExtentOfWord(position); while (!extentOfWord.IsSignificant && !extentOfWord.Span.IsEmpty) { extentOfWord = navigator.GetExtentOfWord(extentOfWord.Span.End); } if (!extentOfWord.IsSignificant) { return(new SnapshotSpan?()); } return(extentOfWord.Span); }
private bool IsXmlAttributeValue(SnapshotPoint triggerLocation) { TextExtent extent = _navigator.GetExtentOfWord(triggerLocation - 1); IList <ClassificationSpan> spans = _classifier.GetClassificationSpans(extent.Span); return(spans.Any(s => s.ClassificationType.IsOfType("XML Attribute Value"))); }
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 bool TryGetUE4Macro(SnapshotPoint triggerPoint, out UE4MacroStatement ue4MacroStatement) { ue4MacroStatement = null; var currentPoint = triggerPoint - 1; var extent = _navigator.GetExtentOfWord(currentPoint); var statement = _navigator.GetSpanOfEnclosing(extent.Span); var statementText = statement.GetText(); var match = Regex.Match(statementText, $@"({UE4Statics.MacroNamesRegExPatern})\((.*)\)", RegexOptions.IgnoreCase, TimeSpan.FromMilliseconds(100)); if (!match.Success) { return(false); } if (!match.Groups[1].Success || !match.Groups[2].Success) { return(false); } var contentPosition = statement.Start + match.Groups[2].Index; var contentEnd = contentPosition + match.Groups[2].Length; var specifiersSpan = new SnapshotSpan(contentPosition, contentEnd); var macro = (UE4Macros)Enum.Parse(typeof(UE4Macros), match.Groups[1].Value.ToUpper()); ue4MacroStatement = new UE4MacroStatement(specifiersSpan, macro); return(true); }
/// <summary> /// Returns a caret location of itself or the location after the token the caret is inside of. /// </summary> private static int GetCaretLocationAfterToken(ITextStructureNavigator navigator, BlockCommentSelectionHelper blockCommentSelection) { var snapshotSpan = blockCommentSelection.SnapshotSpan; if (navigator == null) { return(snapshotSpan.Start); } var extent = navigator.GetExtentOfWord(snapshotSpan.Start); int locationAfterToken = extent.Span.End; // Don't move to the end if it's already before the token. if (snapshotSpan.Start == extent.Span.Start) { locationAfterToken = extent.Span.Start; } // If the 'word' is just whitespace, use the selected location. if (blockCommentSelection.IsSpanWhitespace(TextSpan.FromBounds(extent.Span.Start, extent.Span.End))) { locationAfterToken = snapshotSpan.Start; } return(locationAfterToken); }
private ITrackingSpan FindTokenSpanAtPosition(ICompletionSession session) { SnapshotPoint currentPoint = session.TextView.Caret.Position.BufferPosition - 1; TextExtent extent = _textStructureNavigator.GetExtentOfWord(currentPoint); var prev = _textStructureNavigator.GetSpanOfPreviousSibling(extent.Span); if (prev != null && !prev.Contains(extent.Span)) { string text = prev.GetText(); if (!string.IsNullOrEmpty(text) && text.Last() != '%' && !char.IsLetter(text[0])) { return(null); } if (text.First() != '%' && CmdLanguage.Keywords.ContainsKey(text.ToLowerInvariant())) { text = text.ToLowerInvariant(); if (text != "if" && text != "not") { return(null); } } } return(currentPoint.Snapshot.CreateTrackingSpan(extent.Span, SpanTrackingMode.EdgeInclusive)); }
public SnapshotPoint?ConvertPointToBufferIndex(Point position) { try { var line = _view.TextViewLines.GetTextViewLineContainingYCoordinate(position.Y); if (line == null) { return(default(SnapshotPoint?)); } SnapshotPoint?bufferPosition = line.GetBufferPositionFromXCoordinate(position.X); if (!bufferPosition.HasValue) { // Assume beginning of line. return(new SnapshotPoint(line.Snapshot, line.Start)); } var extent = _navigator.GetExtentOfWord(bufferPosition.Value); if (!extent.IsSignificant) { return(default(SnapshotPoint?)); } return(bufferPosition); } catch (Exception) { } return(default(SnapshotPoint?)); }
/// <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)); }
public int Exec(ref Guid pguidCmdGroup, uint nCmdID, uint nCmdexecopt, IntPtr pvaIn, IntPtr pvaOut) { char typedChar = char.MinValue; if (pguidCmdGroup == VSConstants.VSStd2K && nCmdID == (uint)VSConstants.VSStd2KCmdID.TYPECHAR) { typedChar = (char)(ushort)Marshal.GetObjectForNativeVariant(pvaIn); if (typedChar.Equals('(')) { //move the point back so it's in the preceding word SnapshotPoint point = m_textView.Caret.Position.BufferPosition - 1; TextExtent extent = m_navigator.GetExtentOfWord(point); string word = extent.Span.GetText(); /******************************************************************/ //if (word.Equals("add")) if (!String.IsNullOrEmpty(word)) { m_session = m_broker.TriggerSignatureHelp(m_textView); } } else if (typedChar.Equals(')') && m_session != null) { m_session.Dismiss(); m_session = null; } } return(m_nextCommandHandler.Exec(ref pguidCmdGroup, nCmdID, nCmdexecopt, pvaIn, pvaOut)); }
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; }
protected override bool Execute(VSConstants.VSStd97CmdID commandId, uint nCmdexecopt, IntPtr pvaIn, IntPtr pvaOut) { SnapshotPoint?point = TextView.Caret.Position.Point.GetPoint(TextView.TextBuffer, PositionAffinity.Predecessor); if (point.HasValue) { TextExtent wordExtent = _navigator.GetExtentOfWord(point.Value - 1); string wordText = TextView.TextSnapshot.GetText(wordExtent.Span); Find2 find = (Find2)EditorExtensionsPackage.DTE.Find; string types = find.FilesOfType; bool matchCase = find.MatchCase; bool matchWord = find.MatchWholeWord; find.WaitForFindToComplete = false; find.Action = EnvDTE.vsFindAction.vsFindActionFindAll; find.Backwards = false; find.MatchInHiddenText = true; find.MatchWholeWord = true; find.MatchCase = true; find.PatternSyntax = EnvDTE.vsFindPatternSyntax.vsFindPatternSyntaxLiteral; find.ResultsLocation = EnvDTE.vsFindResultsLocation.vsFindResults1; find.SearchSubfolders = true; find.FilesOfType = "*.js"; find.Target = EnvDTE.vsFindTarget.vsFindTargetSolution; find.FindWhat = wordText; find.Execute(); find.FilesOfType = types; find.MatchCase = matchCase; find.MatchWholeWord = matchWord; } return(true); }
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) { SnapshotPoint?subjectTriggerPoint = session.GetTriggerPoint(_subjectBuffer.CurrentSnapshot); if (!subjectTriggerPoint.HasValue) { applicableToSpan = null; return; } //ITextSnapshot currentSnapshot = subjectTriggerPoint.Value.Snapshot; //SnapshotSpan querySpan = new SnapshotSpan(subjectTriggerPoint.Value, 0); ITextStructureNavigator navigator = _provider.NavigatorService.GetTextStructureNavigator(_subjectBuffer); TextExtent extent = navigator.GetExtentOfWord(subjectTriggerPoint.Value); //string searchText = extent.Span.GetText(); string description = _analysisEntry.GetDescription(_subjectBuffer, subjectTriggerPoint.Value); if (description != String.Empty && description != null) { applicableToSpan = subjectTriggerPoint.Value.Snapshot.CreateTrackingSpan(extent.Span.Start, extent.Span.Length, SpanTrackingMode.EdgeInclusive); quickInfoContent.Add(description); return; } applicableToSpan = null; }
public int Exec(ref Guid pguidCmdGroup, uint nCmdID, uint nCmdexecopt, IntPtr pvaIn, IntPtr pvaOut) { ThreadHelper.ThrowIfNotOnUIThread(); if (pguidCmdGroup == VSConstants.VSStd2K && nCmdID == (uint)VSConstants.VSStd2KCmdID.TYPECHAR) { var typedChar = (char)(ushort)Marshal.GetObjectForNativeVariant(pvaIn); if (typedChar.Equals('(')) { // Move the point back so it's in the preceding word var point = _textView.Caret.Position.BufferPosition - 1; var extent = _navigator.GetExtentOfWord(point); var word = extent.Span.GetText(); if (word.Equals("emplace") || word.Equals("emplace_back")) { _session = _broker.TriggerSignatureHelp(_textView); } } else if (typedChar.Equals(')') && _session != null) { _session.Dismiss(); _session = null; } } return(_nextCommandHandler.Exec(ref pguidCmdGroup, nCmdID, nCmdexecopt, pvaIn, pvaOut)); }
private void OnLayoutChanged(object sender, TextViewLayoutChangedEventArgs e) { var caretPosition = _view.Caret.Position; SnapshotPoint?point = caretPosition.Point.GetPoint(_buffer, caretPosition.Affinity); if (!point.HasValue) { return; } /*/ If the new caret position is still within the current word (and on the same snapshot), we don't need to check it * if (CurrentWord.HasValue * && CurrentWord.Value.Snapshot == m_view.TextSnapshot * && point.Value >= CurrentWord.Value.Start * && point.Value <= CurrentWord.Value.End) * { * return; * }*/ List <SnapshotSpan> wordSpans = new List <SnapshotSpan>(); //Find all words in the buffer like the one the caret is on TextExtent word = _textStructureNavigator.GetExtentOfWord(point.Value); if (_codeModel == null) { //If we couldn't find a word, clear out the existing markers SynchronousUpdate(new NormalizedSnapshotSpanCollection()); return; } FindBadActions(wordSpans, word.Span); SynchronousUpdate(new NormalizedSnapshotSpanCollection(wordSpans)); }
public async Task <INavigableSymbol> GetNavigableSymbolAsync(SnapshotSpan triggerSpan, CancellationToken cancellationToken) { Debug.Assert(triggerSpan.Length == 1); cancellationToken.ThrowIfCancellationRequested(); var extent = _textNavigator.GetExtentOfWord(triggerSpan.Start); if (!extent.IsSignificant) { return(null); } // Check with pylance, which will give us a precise // result, including the source location. var result = await GetDefinitionLocationsAsync(extent.Span, cancellationToken).ConfigureAwait(false); cancellationToken.ThrowIfCancellationRequested(); if (result != null && result.Any()) { return(result.First()); } return(null); }
/// <summary> /// Determines whether the given match qualifies as a whole word using <see cref="ITextStructureNavigator"/>. /// </summary> /// <remarks> /// In the new implementation, we don't use any external parties to determine word boundaries, rather we pick a small /// predictable range of characters and use them as word splitters. The primary reason for this is performance as calls /// to external components could be slow. Further, we want the search service to be a dumb but very predictable and simple /// text based search service so we enforce our own rules in the new implementation. /// </remarks> private bool LegacyMatchesAWholeWord(SnapshotSpan result, FindData findData) { ITextStructureNavigator textStructureNavigator = findData.TextStructureNavigator; if (textStructureNavigator == null) { // the navigator was never set; create one without benefit of context textStructureNavigator = _navigatorSelectorService.GetTextStructureNavigator(findData.TextSnapshotToSearch.TextBuffer); } // We'll need to get the left extent and right extent in case the match spans across multiple words Microsoft.VisualStudio.Text.Operations.TextExtent leftExtent = textStructureNavigator.GetExtentOfWord(result.Start); Microsoft.VisualStudio.Text.Operations.TextExtent rightExtent = textStructureNavigator.GetExtentOfWord(result.Length > 0 ? result.End - 1 : result.End); return((result.Start == leftExtent.Span.Start) && (result.End == rightExtent.Span.End)); }
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); } }
public void AugmentQuickInfoSession(IQuickInfoSession session, IList <object> quickInfoContent, out ITrackingSpan applicableToSpan) { // Map the trigger point down to our buffer. SnapshotPoint?subjectTriggerPoint = session.GetTriggerPoint(m_subjectBuffer.CurrentSnapshot); if (!subjectTriggerPoint.HasValue) { applicableToSpan = null; return; } 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(); searchText = searchText?.Trim(); String text = null; if (!String.IsNullOrEmpty(searchText)) { text = TranslateApi.TranslateEn_Zh(searchText); applicableToSpan = currentSnapshot.CreateTrackingSpan ( //querySpan.Start.Add(foundIndex).Position, 9, SpanTrackingMode.EdgeInclusive extent.Span.Start, text.Length, SpanTrackingMode.EdgeInclusive ); quickInfoContent.Add(text); return; } //foreach (string key in m_dictionary.Keys) //{ // int foundIndex = searchText.IndexOf(key, StringComparison.CurrentCultureIgnoreCase); // if (foundIndex > -1) // { // applicableToSpan = currentSnapshot.CreateTrackingSpan // ( // //querySpan.Start.Add(foundIndex).Position, 9, SpanTrackingMode.EdgeInclusive // extent.Span.Start + foundIndex, key.Length, SpanTrackingMode.EdgeInclusive // ); // string value; // m_dictionary.TryGetValue(key, out value); // if (value != null) // quickInfoContent.Add(value); // else // quickInfoContent.Add(""); // return; // } //} applicableToSpan = null; }
private ITrackingSpan FindTokenSpanAtPosition(ICompletionSession session) { SnapshotPoint currentPoint = (session.TextView.Caret.Position.BufferPosition) - 1; ITextStructureNavigator navigator = _navigator.GetTextStructureNavigator(_buffer); TextExtent extent = navigator.GetExtentOfWord(currentPoint); return(currentPoint.Snapshot.CreateTrackingSpan(extent.Span, SpanTrackingMode.EdgeInclusive)); }
private ITrackingSpan FindTokenSpanAtPosition(ITrackingPoint point, ICompletionSession completionSession) { SnapshotPoint ssPoint = (completionSession.TextView.Caret.Position.BufferPosition) - 1; ITextStructureNavigator navigator = sourceProvider.TextNavigatorService.GetTextStructureNavigator(this.textBuffer); TextExtent textExtent = navigator.GetExtentOfWord(ssPoint); return(ssPoint.Snapshot.CreateTrackingSpan(textExtent.Span, SpanTrackingMode.EdgeInclusive)); }
ITrackingSpan FindTokenSpanAtPosition(ITrackingPoint point, ICompletionSession session) { SnapshotPoint currentPoint = (session.TextView.Caret.Position.BufferPosition) - 1; ITextStructureNavigator navigator = m_sourceProvider.NavigatorService.GetTextStructureNavigator(m_textBuffer); TextExtent extent = navigator.GetExtentOfWord(currentPoint); return(currentPoint.Snapshot.CreateTrackingSpan(extent.Span, SpanTrackingMode.EdgeInclusive)); }
private TextExtent FindExtentAtPoint(SnapshotPoint?subjectTriggerPoint) { ITextStructureNavigator navigator = this.provider.NavigatorService.GetTextStructureNavigator(this.textBuffer); TextExtent extent = navigator.GetExtentOfWord(subjectTriggerPoint.Value); return(extent); }
bool IsWholeWord(ITextStructureNavigator textStructureNavigator, ITextSnapshot snapshot, FindResult result) { Debug.Assert(textStructureNavigator != null); if (textStructureNavigator == null) return false; if (result.Length == 0) return false; var start = textStructureNavigator.GetExtentOfWord(new SnapshotPoint(snapshot, result.Position)); if (start.Span.Start.Position != result.Position) return false; var end = textStructureNavigator.GetExtentOfWord(new SnapshotPoint(snapshot, result.Position + result.Length - 1)); return end.Span.End.Position == result.Position + result.Length; }