private bool IsCaretOutsideItemBounds( Model model, SnapshotPoint caretPoint, PresentationItem item, Dictionary<TextSpan, string> textSpanToText, Dictionary<TextSpan, ViewTextSpan> textSpanToViewSpan) { // Easy first check. See if the caret point is before the start of the item. ViewTextSpan filterSpanInViewBuffer; if (!textSpanToViewSpan.TryGetValue(item.Item.Span, out filterSpanInViewBuffer)) { filterSpanInViewBuffer = model.GetViewBufferSpan(item.Item.Span); textSpanToViewSpan[item.Item.Span] = filterSpanInViewBuffer; } if (caretPoint < filterSpanInViewBuffer.TextSpan.Start) { return true; } var textSnapshot = caretPoint.Snapshot; var currentText = model.GetCurrentTextInSnapshot(item.Item.Span, textSnapshot, textSpanToText); var currentTextSpan = new TextSpan(filterSpanInViewBuffer.TextSpan.Start, currentText.Length); return !currentTextSpan.IntersectsWith(caretPoint); }
private bool IsFilterTextEmpty( Model model, SnapshotPoint caretPoint, PresentationItem item, Dictionary <TextSpan, string> textSpanToText, Dictionary <TextSpan, ViewTextSpan> textSpanToViewSpan) { // Easy first check. See if the caret point is before the start of the item. ViewTextSpan filterSpanInViewBuffer; if (!textSpanToViewSpan.TryGetValue(item.Item.Span, out filterSpanInViewBuffer)) { filterSpanInViewBuffer = model.GetViewBufferSpan(item.Item.Span); textSpanToViewSpan[item.Item.Span] = filterSpanInViewBuffer; } if (caretPoint < filterSpanInViewBuffer.TextSpan.Start) { return(true); } var textSnapshot = caretPoint.Snapshot; var currentText = model.GetCurrentTextInSnapshot(item.Item.Span, textSnapshot, textSpanToText); var currentTextSpan = new TextSpan(filterSpanInViewBuffer.TextSpan.Start, currentText.Length); return(currentText.Length == 0); }
public Model WithSuggestionModeItem(PresentationItem suggestionModeItem) { return(suggestionModeItem == this.SuggestionModeItem ? this : new Model(_disconnectedBufferGraph, OriginalList, TotalItems, FilteredItems, SelectedItem, CompletionItemFilters, FilterState, CompletionItemToFilterText, IsHardSelection, IsUnique, UseSuggestionMode, suggestionModeItem, DefaultSuggestionModeItem, Trigger, CommitTrackingSpanEndPoint, DismissIfEmpty)); }
public CustomCommitCompletion( CompletionPresenterSession completionPresenterSession, PresentationItem presentationItem) : base() { // PERF: Note that the base class contains a constructor taking the displayText string // but we're intentionally NOT using that here because it allocates a private CompletionState // object. By overriding the public property getters (DisplayText, InsertionText, etc.) the // extra allocation is avoided. _completionPresenterSession = completionPresenterSession; this.PresentationItem = presentationItem; _imageMoniker = ImageMonikers.GetImageMoniker(PresentationItem.Item.Tags, presentationItem.CompletionService.Language); }
public CustomCommitCompletion( CompletionPresenterSession completionPresenterSession, PresentationItem presentationItem) : base() { // PERF: Note that the base class contains a constructor taking the displayText string // but we're intentionally NOT using that here because it allocates a private CompletionState // object. By overriding the public property getters (DisplayText, InsertionText, etc.) the // extra allocation is avoided. _completionPresenterSession = completionPresenterSession; this.PresentationItem = presentationItem; _imageMoniker = ImageMonikers.GetImageMoniker(PresentationItem.Item.Tags); }
private VSCompletion GetVSCompletion(PresentationItem item) { VSCompletion value; if (!_presentationItemMap.TryGetValue(item, out value)) { value = new CustomCommitCompletion( _completionPresenterSession, item); _presentationItemMap.Add(item, value); } return(value); }
private bool IsHardSelection( Model model, PresentationItem bestFilterMatch, ITextSnapshot textSnapshot, CompletionHelper completionRules, CompletionTrigger trigger, CompletionFilterReason reason) { if (model.SuggestionModeItem != null) { return(bestFilterMatch != null && bestFilterMatch.Item.DisplayText == model.SuggestionModeItem.Item.DisplayText); } if (bestFilterMatch == null || model.UseSuggestionMode) { return(false); } // We don't have a builder and we have a best match. Normally this will be hard // selected, except for a few cases. Specifically, if no filter text has been // provided, and this is not a preselect match then we will soft select it. This // happens when the completion list comes up implicitly and there is something in // the MRU list. In this case we do want to select it, but not with a hard // selection. Otherwise you can end up with the following problem: // // dim i as integer =<space> // // Completion will comes up after = with 'integer' selected (Because of MRU). We do // not want 'space' to commit this. var viewSpan = model.GetViewBufferSpan(bestFilterMatch.Item.Span); var fullFilterText = model.GetCurrentTextInSnapshot(viewSpan, textSnapshot, endPoint: null); var shouldSoftSelect = completionRules.ShouldSoftSelectItem(bestFilterMatch.Item, fullFilterText, trigger); if (shouldSoftSelect) { return(false); } // If the user moved the caret left after they started typing, the 'best' match may not match at all // against the full text span that this item would be replacing. if (!completionRules.MatchesFilterText(bestFilterMatch.Item, fullFilterText, trigger, reason, this.Controller.GetRecentItems())) { return(false); } // There was either filter text, or this was a preselect match. In either case, we // can hard select this. return(true); }
private void CommitItem(PresentationItem item) { AssertIsForeground(); // We should not be getting called if we didn't even have a computation running. Contract.ThrowIfNull(this.sessionOpt); Contract.ThrowIfNull(this.sessionOpt.Computation.InitialUnfilteredModel); // If the selected item is the builder, there's not actually any work to do to commit if (item.IsSuggestionModeItem) { this.StopModelComputation(); return; } this.Commit(item, this.sessionOpt.Computation.InitialUnfilteredModel, commitChar: null); }
private void Commit(PresentationItem item, Model model, char?commitChar) { AssertIsForeground(); // We could only be called if we had a model at this point. Contract.ThrowIfNull(model); // Now that we've captured the model at this point, we can stop ourselves entirely. // This is also desirable as we may have reentrancy problems when we call into // custom commit completion providers. I.e. if the custom provider moves the caret, // then we do not want to process that move as it may put us into an unexpected state. // // TODO(cyrusn): We still have a general reentrancy problem where calling into a custom // commit provider (or just calling into the editor) may cause something to call back // into us. However, for now, we just hope that no such craziness will occur. this.StopModelComputation(); Commit(item, model, commitChar, CancellationToken.None); }
private void Commit(PresentationItem item, Model model, char? commitChar) { AssertIsForeground(); // We could only be called if we had a model at this point. Contract.ThrowIfNull(model); // Now that we've captured the model at this point, we can stop ourselves entirely. // This is also desirable as we may have reentrancy problems when we call into // custom commit completion providers. I.e. if the custom provider moves the caret, // then we do not want to process that move as it may put us into an unexpected state. // // TODO(cyrusn): We still have a general reentrancy problem where calling into a custom // commit provider (or just calling into the editor) may cause something to call back // into us. However, for now, we just hope that no such craziness will occur. this.StopModelComputation(); Commit(item, model, commitChar, CancellationToken.None); }
private Model( DisconnectedBufferGraph disconnectedBufferGraph, CompletionList originalList, ImmutableArray<PresentationItem> totalItems, ImmutableArray<PresentationItem> filteredItems, PresentationItem selectedItem, ImmutableArray<CompletionItemFilter> completionItemFilters, ImmutableDictionary<CompletionItemFilter, bool> filterState, IReadOnlyDictionary<CompletionItem, string> completionItemToFilterText, bool isHardSelection, bool isUnique, bool useSuggestionMode, PresentationItem suggestionModeItem, PresentationItem defaultSuggestionModeItem, CompletionTrigger trigger, ITrackingPoint commitSpanEndPoint, bool dismissIfEmpty) { Contract.ThrowIfNull(selectedItem); Contract.ThrowIfFalse(totalItems.Length != 0, "Must have at least one item."); Contract.ThrowIfFalse(filteredItems.Length != 0, "Must have at least one filtered item."); Contract.ThrowIfFalse(filteredItems.Contains(selectedItem) || defaultSuggestionModeItem == selectedItem, "Selected item must be in filtered items."); _disconnectedBufferGraph = disconnectedBufferGraph; this.OriginalList = originalList; this.TotalItems = totalItems; this.FilteredItems = filteredItems; this.FilterState = filterState; this.SelectedItem = selectedItem; this.CompletionItemFilters = completionItemFilters; this.CompletionItemToFilterText = completionItemToFilterText; this.IsHardSelection = isHardSelection; this.IsUnique = isUnique; this.UseSuggestionMode = useSuggestionMode; this.SuggestionModeItem = suggestionModeItem; this.DefaultSuggestionModeItem = defaultSuggestionModeItem; this.Trigger = trigger; this.CommitTrackingSpanEndPoint = commitSpanEndPoint; this.DismissIfEmpty = dismissIfEmpty; }
private Model( DisconnectedBufferGraph disconnectedBufferGraph, CompletionList originalList, ImmutableArray <PresentationItem> totalItems, ImmutableArray <PresentationItem> filteredItems, PresentationItem selectedItem, ImmutableArray <CompletionItemFilter> completionItemFilters, ImmutableDictionary <CompletionItemFilter, bool> filterState, IReadOnlyDictionary <CompletionItem, string> completionItemToFilterText, bool isHardSelection, bool isUnique, bool useSuggestionMode, PresentationItem suggestionModeItem, PresentationItem defaultSuggestionModeItem, CompletionTrigger trigger, ITrackingPoint commitSpanEndPoint, bool dismissIfEmpty) { Contract.ThrowIfNull(selectedItem); Contract.ThrowIfFalse(totalItems.Length != 0, "Must have at least one item."); Contract.ThrowIfFalse(filteredItems.Length != 0, "Must have at least one filtered item."); Contract.ThrowIfFalse(filteredItems.Contains(selectedItem) || defaultSuggestionModeItem == selectedItem, "Selected item must be in filtered items."); _disconnectedBufferGraph = disconnectedBufferGraph; this.OriginalList = originalList; this.TotalItems = totalItems; this.FilteredItems = filteredItems; this.FilterState = filterState; this.SelectedItem = selectedItem; this.CompletionItemFilters = completionItemFilters; this.CompletionItemToFilterText = completionItemToFilterText; this.IsHardSelection = isHardSelection; this.IsUnique = isUnique; this.UseSuggestionMode = useSuggestionMode; this.SuggestionModeItem = suggestionModeItem; this.DefaultSuggestionModeItem = defaultSuggestionModeItem; this.Trigger = trigger; this.CommitTrackingSpanEndPoint = commitSpanEndPoint; this.DismissIfEmpty = dismissIfEmpty; }
public Model WithSelectedItem(PresentationItem selectedItem) { return With(selectedItem: selectedItem); }
private void Commit( PresentationItem item, Model model, char? commitChar, ITextSnapshot initialTextSnapshot, Action nextHandler) { AssertIsForeground(); // We could only be called if we had a model at this point. Contract.ThrowIfNull(model); // Now that we've captured the model at this point, we can stop ourselves entirely. // This is also desirable as we may have reentrancy problems when we call into // custom commit completion providers. I.e. if the custom provider moves the caret, // then we do not want to process that move as it may put us into an unexpected state. // // TODO(cyrusn): We still have a general reentrancy problem where calling into a custom // commit provider (or just calling into the editor) may cause something to call back // into us. However, for now, we just hope that no such craziness will occur. this.StopModelComputation(); CompletionChange completionChange; using (var transaction = new CaretPreservingEditTransaction( EditorFeaturesResources.IntelliSense, TextView, _undoHistoryRegistry, _editorOperationsFactoryService)) { // We want to merge with any of our other programmatic edits (e.g. automatic brace completion) transaction.MergePolicy = AutomaticCodeChangeMergePolicy.Instance; var provider = GetCompletionProvider(item.Item) as ICustomCommitCompletionProvider; if (provider != null) { provider.Commit(item.Item, this.TextView, this.SubjectBuffer, model.TriggerSnapshot, commitChar); } else { // Right before calling Commit, we may have passed the commitChar through to the // editor. That was so that undoing completion will get us back to the state we // we would be in if completion had done nothing. However, now that we're going // to actually commit, we want to roll back to where we were before we pushed // commit character into the buffer. This has multiple benefits: // // 1) the buffer is in a state we expect it to be in. i.e. we don't have to // worry about what might have happened (like brace-completion) when the // commit char was inserted. // 2) after we commit the item, we'll pass the commit character again into the // buffer (unless the items asks us not to). By doing this, we can make sure // that things like brace-completion or formatting trigger as we expect them // to. var characterWasSentIntoBuffer = commitChar != null && initialTextSnapshot.Version.VersionNumber != this.SubjectBuffer.CurrentSnapshot.Version.VersionNumber; if (characterWasSentIntoBuffer) { RollbackToBeforeTypeChar(initialTextSnapshot); } // Now, get the change the item wants to make. Note that the change will be relative // to the initial snapshot/document the item was triggered from. We'll map that change // forward, then apply it to our current snapshot. var triggerDocument = model.TriggerDocument; var triggerSnapshot = model.TriggerSnapshot; var completionService = CompletionService.GetService(triggerDocument); Contract.ThrowIfNull(completionService, nameof(completionService)); completionChange = completionService.GetChangeAsync( triggerDocument, item.Item, commitChar, CancellationToken.None).WaitAndGetResult(CancellationToken.None); var textChange = completionChange.TextChange; var triggerSnapshotSpan = new SnapshotSpan(triggerSnapshot, textChange.Span.ToSpan()); var mappedSpan = triggerSnapshotSpan.TranslateTo( this.SubjectBuffer.CurrentSnapshot, SpanTrackingMode.EdgeInclusive); // Now actually make the text change to the document. using (var textEdit = this.SubjectBuffer.CreateEdit(EditOptions.None, reiteratedVersionNumber: null, editTag: null)) { var adjustedNewText = AdjustForVirtualSpace(textChange); textEdit.Replace(mappedSpan.Span, adjustedNewText); textEdit.Apply(); } // adjust the caret position if requested by completion service if (completionChange.NewPosition != null) { TextView.Caret.MoveTo(new SnapshotPoint( this.SubjectBuffer.CurrentSnapshot, completionChange.NewPosition.Value)); } // Now, pass along the commit character unless the completion item said not to if (characterWasSentIntoBuffer && !completionChange.IncludesCommitCharacter) { nextHandler(); } // If the insertion is long enough, the caret will scroll out of the visible area. // Re-center the view. this.TextView.Caret.EnsureVisible(); } transaction.Complete(); } // Let the completion rules know that this item was committed. this.MakeMostRecentItem(item.Item.DisplayText); }
private void CommitOnNonTypeChar( PresentationItem item, Model model) { Commit(item, model, commitChar: null, initialTextSnapshot: null, nextHandler: null); }
void ICompletionSet.SetCompletionItems(IList<PresentationItem> completionItems, PresentationItem selectedItem, PresentationItem presetBuilder, bool suggestionMode, bool isSoftSelected, ImmutableArray<CompletionItemFilter> completionItemFilters, IReadOnlyDictionary<CompletionItem, string> completionItemToFilterText) { _roslynCompletionSet.SetCompletionItems(completionItems, selectedItem, presetBuilder, suggestionMode, isSoftSelected, completionItemFilters, completionItemToFilterText); }
public void PresentItems( ITrackingSpan triggerSpan, IList <PresentationItem> completionItems, PresentationItem selectedItem, PresentationItem suggestionModeItem, bool suggestionMode, bool isSoftSelected, ImmutableArray <CompletionItemFilter> completionItemFilters, string filterText) { AssertIsForeground(); // check if this update is still relevant if (_textView.IsClosed || _isDismissed) { return; } if (triggerSpan != null) { _completionSet.SetTrackingSpan(triggerSpan); } _ignoreSelectionStatusChangedEvent = true; try { _completionSet.SetCompletionItems( completionItems, selectedItem, suggestionModeItem, suggestionMode, isSoftSelected, completionItemFilters, filterText); } finally { _ignoreSelectionStatusChangedEvent = false; } if (_editorSessionOpt == null) { // We're tracking the caret. Don't have the editor do it. // Map the span instead of a point to avoid affinity problems. _editorSessionOpt = _completionBroker.CreateCompletionSession( _textView, triggerSpan.GetStartTrackingPoint(PointTrackingMode.Negative), trackCaret: false); var debugTextView = _textView as IDebuggerTextView; if (debugTextView != null && !debugTextView.IsImmediateWindow) { debugTextView.HACK_StartCompletionSession(_editorSessionOpt); } _editorSessionOpt.Dismissed += (s, e) => OnEditorSessionDismissed(); // So here's the deal. We cannot create the editor session and give it the right // items (even though we know what they are). Instead, the session will call // back into the ICompletionSourceProvider (which is us) to get those values. It // will pass itself along with the calls back into ICompletionSourceProvider. // So, in order to make that connection work, we add properties to the session // so that we can call back into ourselves, get the items and add it to the // session. _editorSessionOpt.Properties.AddProperty(Key, this); _editorSessionOpt.Start(); } // Call so that the editor will refresh the completion text to embolden. _editorSessionOpt?.Match(); }
public FilterResult(PresentationItem presentationItem, string filterText, bool matchedFilterText) { PresentationItem = presentationItem; MatchedFilterText = matchedFilterText; FilterText = filterText; }
private void Commit(PresentationItem item, Model model, char? commitChar, CancellationToken cancellationToken) { var textChanges = ImmutableArray<TextChange>.Empty; // NOTE(cyrusn): It is intentional that we get the undo history for the // surface buffer and not the subject buffer. // There have been some watsons where the ViewBuffer hadn't been registered, // so use TryGetHistory instead. ITextUndoHistory undoHistory; _undoHistoryRegistry.TryGetHistory(this.TextView.TextBuffer, out undoHistory); using (var transaction = undoHistory?.CreateTransaction(EditorFeaturesResources.IntelliSense)) { // We want to merge with any of our other programmatic edits (e.g. automatic brace completion) if (transaction != null) { transaction.MergePolicy = AutomaticCodeChangeMergePolicy.Instance; } // Check if the provider wants to perform custom commit itself. Otherwise we will // handle things. var provider = GetCompletionProvider(item.Item) as ICustomCommitCompletionProvider; if (provider == null) { var viewBuffer = this.TextView.TextBuffer; var commitDocument = this.SubjectBuffer.CurrentSnapshot.AsText().GetDocumentWithFrozenPartialSemanticsAsync(cancellationToken).WaitAndGetResult(cancellationToken); // adjust commit item span foward to match current document that is passed to GetChangeAsync below var commitItem = item.Item; var currentItemSpan = GetCurrentItemSpan(commitItem, model); commitItem = commitItem.WithSpan(currentItemSpan); var completionService = CompletionService.GetService(commitDocument); var commitChange = completionService.GetChangeAsync(commitDocument, commitItem, commitChar, cancellationToken).WaitAndGetResult(cancellationToken); textChanges = commitChange.TextChanges; // Use character based diffing here to avoid overwriting the commit character placed into the editor. var editOptions = new EditOptions(new StringDifferenceOptions { DifferenceType = StringDifferenceTypes.Character, IgnoreTrimWhiteSpace = EditOptions.DefaultMinimalChange.DifferenceOptions.IgnoreTrimWhiteSpace }); // edit subject buffer (not view) because text changes are in terms of current document. using (var textEdit = this.SubjectBuffer.CreateEdit(editOptions, reiteratedVersionNumber: null, editTag: null)) { for (int iChange = 0; iChange < textChanges.Length; iChange++) { var textChange = textChanges[iChange]; var isFirst = iChange == 0; var isLast = iChange == textChanges.Length - 1; // add commit char to end of last change if not already included if (isLast && !commitChange.IncludesCommitCharacter && commitChar.HasValue) { textChange = new TextChange(textChange.Span, textChange.NewText + commitChar.Value); } var currentSpan = new SnapshotSpan(this.SubjectBuffer.CurrentSnapshot, new Span(textChange.Span.Start, textChange.Span.Length)); // In order to play nicely with automatic brace completion, we need to // not touch the opening paren. We'll check our span and textchange // for ( and adjust them accordingly if we find them. // all this is needed since we don't use completion set mechanism provided by VS but we implement everything ourselves. // due to that, existing brace completion engine in editor that should take care of interaction between brace completion // and intellisense doesn't work for us. so we need this kind of workaround to support it nicely. bool textChanged; string newText = textChange.NewText; if (isFirst) { newText = AdjustFirstText(textChange); } if (isLast) { newText = AdjustLastText(newText, commitChar.GetValueOrDefault(), out textChanged); currentSpan = AdjustLastSpan(currentSpan, commitChar.GetValueOrDefault(), textChanged); } var caretPoint = this.TextView.GetCaretPoint(this.SubjectBuffer); var virtualCaretPoint = this.TextView.GetVirtualCaretPoint(this.SubjectBuffer); if (caretPoint.HasValue && virtualCaretPoint.HasValue) { // TODO(dustinca): We need to call a different API here. TryMoveCaretToAndEnsureVisible might center within the view. this.TextView.TryMoveCaretToAndEnsureVisible(new VirtualSnapshotPoint(caretPoint.Value)); } caretPoint = this.TextView.GetCaretPoint(this.SubjectBuffer); // Now that we're doing character level diffing, we need to move the caret to the end of // the span being replaced. Otherwise, we can replace M|ai with Main and wind up with // M|ain, since character based diffing makes that quite legit. if (caretPoint.HasValue) { var endInSubjectBuffer = this.TextView.BufferGraph.MapDownToBuffer(currentSpan.End, PointTrackingMode.Positive, caretPoint.Value.Snapshot.TextBuffer, PositionAffinity.Predecessor); if (caretPoint.Value < endInSubjectBuffer) { this.TextView.TryMoveCaretToAndEnsureVisible(new SnapshotPoint(currentSpan.Snapshot.TextBuffer.CurrentSnapshot, currentSpan.End.Position)); } } textEdit.Replace(currentSpan, newText); } textEdit.Apply(); } // adjust the caret position if requested by completion service if (commitChange.NewPosition != null) { var target = new SnapshotPoint(this.SubjectBuffer.CurrentSnapshot, commitChange.NewPosition.Value); this.TextView.TryMoveCaretToAndEnsureVisible(target); } // We've manipulated the caret position in order to generate the correct edit. However, // if the insertion is long enough, the caret will scroll out of the visible area. // Re-center the view. using (var textEdit = viewBuffer.CreateEdit(editOptions, reiteratedVersionNumber: null, editTag: null)) { var caretPoint = this.TextView.GetCaretPoint(this.SubjectBuffer); if (caretPoint.HasValue) { this.TextView.Caret.EnsureVisible(); } } transaction?.Complete(); } else { // Let the provider handle this. provider.Commit(item.Item, this.TextView, this.SubjectBuffer, model.TriggerSnapshot, commitChar); transaction?.Complete(); } } var document = this.SubjectBuffer.CurrentSnapshot.GetOpenDocumentInCurrentContextWithChanges(); var formattingService = document.GetLanguageService<IEditorFormattingService>(); var commitCharTriggersFormatting = commitChar != null && (formattingService?.SupportsFormattingOnTypedCharacter(document, commitChar.GetValueOrDefault()) ?? false); if (formattingService != null && (item.Item.Rules.FormatOnCommit || commitCharTriggersFormatting)) { // Formatting the completion item affected span is done as a separate transaction because this gives the user // the flexibility to undo the formatting but retain the changes associated with the completion item using (var formattingTransaction = _undoHistoryRegistry.GetHistory(this.TextView.TextBuffer).CreateTransaction(EditorFeaturesResources.IntelliSenseCommitFormatting)) { var caretPoint = this.TextView.GetCaretPoint(this.SubjectBuffer); IList<TextChange> changes = null; if (commitCharTriggersFormatting && caretPoint.HasValue) { // if the commit character is supported by formatting service, then let the formatting service // find the appropriate range to format. changes = formattingService.GetFormattingChangesAsync(document, commitChar.Value, caretPoint.Value.Position, cancellationToken).WaitAndGetResult(cancellationToken); } else if (textChanges.Length > 0) { // if this is not a supported trigger character for formatting service (space or tab etc.) // then format the span of the textchange. var totalSpan = TextSpan.FromBounds(textChanges.Min(c => c.Span.Start), textChanges.Max(c => c.Span.End)); changes = formattingService.GetFormattingChangesAsync(document, totalSpan, cancellationToken).WaitAndGetResult(cancellationToken); } if (changes != null && !changes.IsEmpty()) { document.Project.Solution.Workspace.ApplyTextChanges(document.Id, changes, cancellationToken); } formattingTransaction.Complete(); } } // Let the completion rules know that this item was committed. this.MakeMostRecentItem(item.Item.DisplayText); }
public FilterResult(PresentationItem presentationItem, string filterText, bool matchedFilterText) { PresentationItem = presentationItem; MatchedFilterText = matchedFilterText; FilterText = filterText; }
private VSCompletion GetVSCompletion(PresentationItem item) { VSCompletion value; if (!PresentationItemMap.TryGetValue(item, out value)) { value = new CustomCommitCompletion( CompletionPresenterSession, item); PresentationItemMap.Add(item, value); } return value; }
public void SetCompletionItems( IList<PresentationItem> completionItems, PresentationItem selectedItem, PresentationItem presetBuilder, bool suggestionMode, bool isSoftSelected, ImmutableArray<CompletionItemFilter> completionItemFilters, string filterText) { this.AssertIsForeground(); VSCompletion selectedCompletionItem = null; // Initialize the completion map to a reasonable default initial size (+1 for the builder) PresentationItemMap = PresentationItemMap ?? new Dictionary<PresentationItem, VSCompletion>(completionItems.Count + 1); FilterText = filterText; try { VsCompletionSet.WritableCompletionBuilders.BeginBulkOperation(); VsCompletionSet.WritableCompletionBuilders.Clear(); this.SetupFilters(completionItemFilters); var applicableToText = VsCompletionSet.ApplicableTo.GetText( VsCompletionSet.ApplicableTo.TextBuffer.CurrentSnapshot); SimplePresentationItem filteredSuggestionModeItem = null; if (selectedItem != null) { var completionItem = CompletionItem.Create(displayText: applicableToText); completionItem.Span = VsCompletionSet.ApplicableTo.GetSpan( VsCompletionSet.ApplicableTo.TextBuffer.CurrentSnapshot).Span.ToTextSpan(); filteredSuggestionModeItem = new SimplePresentationItem( completionItem, selectedItem.CompletionService, isSuggestionModeItem: true); } var showBuilder = suggestionMode || presetBuilder != null; var bestSuggestionModeItem = applicableToText.Length > 0 ? filteredSuggestionModeItem : presetBuilder ?? filteredSuggestionModeItem; if (showBuilder && bestSuggestionModeItem != null) { var suggestionModeCompletion = GetVSCompletion(bestSuggestionModeItem); VsCompletionSet.WritableCompletionBuilders.Add(suggestionModeCompletion); if (selectedItem != null && selectedItem.IsSuggestionModeItem) { selectedCompletionItem = suggestionModeCompletion; } } } finally { VsCompletionSet.WritableCompletionBuilders.EndBulkOperation(); } try { VsCompletionSet.WritableCompletions.BeginBulkOperation(); VsCompletionSet.WritableCompletions.Clear(); foreach (var item in completionItems) { var completionItem = GetVSCompletion(item); VsCompletionSet.WritableCompletions.Add(completionItem); if (item == selectedItem) { selectedCompletionItem = completionItem; } } } finally { VsCompletionSet.WritableCompletions.EndBulkOperation(); } VsCompletionSet.SelectionStatus = new CompletionSelectionStatus( selectedCompletionItem, isSelected: !isSoftSelected, isUnique: selectedCompletionItem != null); }
private void Commit(PresentationItem item, Model model, char?commitChar, CancellationToken cancellationToken) { var textChanges = ImmutableArray <TextChange> .Empty; // NOTE(cyrusn): It is intentional that we get the undo history for the // surface buffer and not the subject buffer. // There have been some watsons where the ViewBuffer hadn't been registered, // so use TryGetHistory instead. ITextUndoHistory undoHistory; _undoHistoryRegistry.TryGetHistory(this.TextView.TextBuffer, out undoHistory); using (var transaction = undoHistory?.CreateTransaction(EditorFeaturesResources.IntelliSense)) { // We want to merge with any of our other programmatic edits (e.g. automatic brace completion) if (transaction != null) { transaction.MergePolicy = AutomaticCodeChangeMergePolicy.Instance; } // Check if the provider wants to perform custom commit itself. Otherwise we will // handle things. var provider = GetCompletionProvider(item.Item) as ICustomCommitCompletionProvider; if (provider == null) { var viewBuffer = this.TextView.TextBuffer; var commitDocument = this.SubjectBuffer.CurrentSnapshot.AsText().GetDocumentWithFrozenPartialSemanticsAsync(cancellationToken).WaitAndGetResult(cancellationToken); // adjust commit item span foward to match current document that is passed to GetChangeAsync below var commitItem = item.Item; var currentItemSpan = GetCurrentItemSpan(commitItem, model); commitItem = commitItem.WithSpan(currentItemSpan); var completionService = CompletionService.GetService(commitDocument); var commitChange = completionService.GetChangeAsync(commitDocument, commitItem, commitChar, cancellationToken).WaitAndGetResult(cancellationToken); textChanges = commitChange.TextChanges; // Use character based diffing here to avoid overwriting the commit character placed into the editor. var editOptions = new EditOptions(new StringDifferenceOptions { DifferenceType = StringDifferenceTypes.Character, IgnoreTrimWhiteSpace = EditOptions.DefaultMinimalChange.DifferenceOptions.IgnoreTrimWhiteSpace }); // edit subject buffer (not view) because text changes are in terms of current document. using (var textEdit = this.SubjectBuffer.CreateEdit(editOptions, reiteratedVersionNumber: null, editTag: null)) { for (int iChange = 0; iChange < textChanges.Length; iChange++) { var textChange = textChanges[iChange]; var isFirst = iChange == 0; var isLast = iChange == textChanges.Length - 1; // add commit char to end of last change if not already included if (isLast && !commitChange.IncludesCommitCharacter && commitChar.HasValue) { textChange = new TextChange(textChange.Span, textChange.NewText + commitChar.Value); } var currentSpan = new SnapshotSpan(this.SubjectBuffer.CurrentSnapshot, new Span(textChange.Span.Start, textChange.Span.Length)); // In order to play nicely with automatic brace completion, we need to // not touch the opening paren. We'll check our span and textchange // for ( and adjust them accordingly if we find them. // all this is needed since we don't use completion set mechanism provided by VS but we implement everything ourselves. // due to that, existing brace completion engine in editor that should take care of interaction between brace completion // and intellisense doesn't work for us. so we need this kind of workaround to support it nicely. bool textChanged; string newText = textChange.NewText; if (isFirst) { newText = AdjustFirstText(textChange); } if (isLast) { newText = AdjustLastText(newText, commitChar.GetValueOrDefault(), out textChanged); currentSpan = AdjustLastSpan(currentSpan, commitChar.GetValueOrDefault(), textChanged); } var caretPoint = this.TextView.GetCaretPoint(this.SubjectBuffer); var virtualCaretPoint = this.TextView.GetVirtualCaretPoint(this.SubjectBuffer); if (caretPoint.HasValue && virtualCaretPoint.HasValue) { // TODO(dustinca): We need to call a different API here. TryMoveCaretToAndEnsureVisible might center within the view. this.TextView.TryMoveCaretToAndEnsureVisible(new VirtualSnapshotPoint(caretPoint.Value)); } caretPoint = this.TextView.GetCaretPoint(this.SubjectBuffer); // Now that we're doing character level diffing, we need to move the caret to the end of // the span being replaced. Otherwise, we can replace M|ai with Main and wind up with // M|ain, since character based diffing makes that quite legit. if (caretPoint.HasValue) { var endInSubjectBuffer = this.TextView.BufferGraph.MapDownToBuffer(currentSpan.End, PointTrackingMode.Positive, caretPoint.Value.Snapshot.TextBuffer, PositionAffinity.Predecessor); if (caretPoint.Value < endInSubjectBuffer) { this.TextView.TryMoveCaretToAndEnsureVisible(new SnapshotPoint(currentSpan.Snapshot.TextBuffer.CurrentSnapshot, currentSpan.End.Position)); } } textEdit.Replace(currentSpan, newText); } textEdit.Apply(); } // adjust the caret position if requested by completion service if (commitChange.NewPosition != null) { var target = new SnapshotPoint(this.SubjectBuffer.CurrentSnapshot, commitChange.NewPosition.Value); this.TextView.TryMoveCaretToAndEnsureVisible(target); } // We've manipulated the caret position in order to generate the correct edit. However, // if the insertion is long enough, the caret will scroll out of the visible area. // Re-center the view. using (var textEdit = viewBuffer.CreateEdit(editOptions, reiteratedVersionNumber: null, editTag: null)) { var caretPoint = this.TextView.GetCaretPoint(this.SubjectBuffer); if (caretPoint.HasValue) { this.TextView.Caret.EnsureVisible(); } } transaction?.Complete(); } else { // Let the provider handle this. provider.Commit(item.Item, this.TextView, this.SubjectBuffer, model.TriggerSnapshot, commitChar); transaction?.Complete(); } } var document = this.SubjectBuffer.CurrentSnapshot.GetOpenDocumentInCurrentContextWithChanges(); var formattingService = document.GetLanguageService <IEditorFormattingService>(); var commitCharTriggersFormatting = commitChar != null && (formattingService?.SupportsFormattingOnTypedCharacter(document, commitChar.GetValueOrDefault()) ?? false); if (formattingService != null && (item.Item.Rules.FormatOnCommit || commitCharTriggersFormatting)) { // Formatting the completion item affected span is done as a separate transaction because this gives the user // the flexibility to undo the formatting but retain the changes associated with the completion item using (var formattingTransaction = _undoHistoryRegistry.GetHistory(this.TextView.TextBuffer).CreateTransaction(EditorFeaturesResources.IntelliSenseCommitFormatting)) { var caretPoint = this.TextView.GetCaretPoint(this.SubjectBuffer); IList <TextChange> changes = null; if (commitCharTriggersFormatting && caretPoint.HasValue) { // if the commit character is supported by formatting service, then let the formatting service // find the appropriate range to format. changes = formattingService.GetFormattingChangesAsync(document, commitChar.Value, caretPoint.Value.Position, cancellationToken).WaitAndGetResult(cancellationToken); } else if (textChanges.Length > 0) { // if this is not a supported trigger character for formatting service (space or tab etc.) // then format the span of the textchange. var totalSpan = TextSpan.FromBounds(textChanges.Min(c => c.Span.Start), textChanges.Max(c => c.Span.End)); changes = formattingService.GetFormattingChangesAsync(document, totalSpan, cancellationToken).WaitAndGetResult(cancellationToken); } if (changes != null && !changes.IsEmpty()) { document.Project.Solution.Workspace.ApplyTextChanges(document.Id, changes, cancellationToken); } formattingTransaction.Complete(); } } // Let the completion rules know that this item was committed. this.MakeMostRecentItem(item.Item.DisplayText); }
void ICompletionSet.SetCompletionItems( IList<PresentationItem> completionItems, PresentationItem selectedItem, PresentationItem presetBuilder, bool suggestionMode, bool isSoftSelected, ImmutableArray<CompletionItemFilter> completionItemFilters, IReadOnlyDictionary<CompletionItem, string> completionItemToFilterText) { this._foregroundObject.AssertIsForeground(); VSCompletion selectedCompletionItem = null; // Initialize the completion map to a reasonable default initial size (+1 for the builder) _presentationItemMap = _presentationItemMap ?? new Dictionary<PresentationItem, VSCompletion>(completionItems.Count + 1); _completionItemToFilterText = completionItemToFilterText; try { this.WritableCompletionBuilders.BeginBulkOperation(); this.WritableCompletionBuilders.Clear(); #if DEV15 // If more than one filter was provided, then present it to the user. if (_filters == null && completionItemFilters.Length > 1) { _filters = completionItemFilters.Select(f => new IntellisenseFilter2(this, f, GetLanguage())) .ToArray(); } #endif var applicableToText = this.ApplicableTo.GetText(this.ApplicableTo.TextBuffer.CurrentSnapshot); SimplePresentationItem filteredSuggestionModeItem = null; if (selectedItem != null) { filteredSuggestionModeItem = new SimplePresentationItem( CompletionItem.Create( displayText: applicableToText, span: this.ApplicableTo.GetSpan(this.ApplicableTo.TextBuffer.CurrentSnapshot).Span.ToTextSpan()), selectedItem.CompletionService, isSuggestionModeItem: true); } var showBuilder = suggestionMode || presetBuilder != null; var bestSuggestionModeItem = applicableToText.Length > 0 ? filteredSuggestionModeItem : presetBuilder ?? filteredSuggestionModeItem; if (showBuilder && bestSuggestionModeItem != null) { var suggestionModeCompletion = GetVSCompletion(bestSuggestionModeItem); this.WritableCompletionBuilders.Add(suggestionModeCompletion); if (selectedItem != null && selectedItem.IsSuggestionModeItem) { selectedCompletionItem = suggestionModeCompletion; } } } finally { this.WritableCompletionBuilders.EndBulkOperation(); } try { this.WritableCompletions.BeginBulkOperation(); this.WritableCompletions.Clear(); foreach (var item in completionItems) { var completionItem = GetVSCompletion(item); this.WritableCompletions.Add(completionItem); if (item == selectedItem) { selectedCompletionItem = completionItem; } } } finally { this.WritableCompletions.EndBulkOperation(); } this.SelectionStatus = new CompletionSelectionStatus( selectedCompletionItem, isSelected: !isSoftSelected, isUnique: selectedCompletionItem != null); }
public void SetCompletionItems( IList <PresentationItem> completionItems, PresentationItem selectedItem, PresentationItem presetBuilder, bool suggestionMode, bool isSoftSelected, ImmutableArray <CompletionItemFilter> completionItemFilters, IReadOnlyDictionary <CompletionItem, string> completionItemToFilterText) { this.AssertIsForeground(); VSCompletion selectedCompletionItem = null; // Initialize the completion map to a reasonable default initial size (+1 for the builder) PresentationItemMap = PresentationItemMap ?? new Dictionary <PresentationItem, VSCompletion>(completionItems.Count + 1); CompletionItemToFilterText = completionItemToFilterText; try { VsCompletionSet.WritableCompletionBuilders.BeginBulkOperation(); VsCompletionSet.WritableCompletionBuilders.Clear(); this.SetupFilters(completionItemFilters); var applicableToText = VsCompletionSet.ApplicableTo.GetText( VsCompletionSet.ApplicableTo.TextBuffer.CurrentSnapshot); SimplePresentationItem filteredSuggestionModeItem = null; if (selectedItem != null) { filteredSuggestionModeItem = new SimplePresentationItem( CompletionItem.Create( displayText: applicableToText, span: VsCompletionSet.ApplicableTo.GetSpan( VsCompletionSet.ApplicableTo.TextBuffer.CurrentSnapshot).Span.ToTextSpan()), selectedItem.CompletionService, isSuggestionModeItem: true); } var showBuilder = suggestionMode || presetBuilder != null; var bestSuggestionModeItem = applicableToText.Length > 0 ? filteredSuggestionModeItem : presetBuilder ?? filteredSuggestionModeItem; if (showBuilder && bestSuggestionModeItem != null) { var suggestionModeCompletion = GetVSCompletion(bestSuggestionModeItem); VsCompletionSet.WritableCompletionBuilders.Add(suggestionModeCompletion); if (selectedItem != null && selectedItem.IsSuggestionModeItem) { selectedCompletionItem = suggestionModeCompletion; } } } finally { VsCompletionSet.WritableCompletionBuilders.EndBulkOperation(); } try { VsCompletionSet.WritableCompletions.BeginBulkOperation(); VsCompletionSet.WritableCompletions.Clear(); foreach (var item in completionItems) { var completionItem = GetVSCompletion(item); VsCompletionSet.WritableCompletions.Add(completionItem); if (item == selectedItem) { selectedCompletionItem = completionItem; } } } finally { VsCompletionSet.WritableCompletions.EndBulkOperation(); } VsCompletionSet.SelectionStatus = new CompletionSelectionStatus( selectedCompletionItem, isSelected: !isSoftSelected, isUnique: selectedCompletionItem != null); }
public Model WithSuggestionModeItem(PresentationItem suggestionModeItem) { return With(suggestionModeItem: suggestionModeItem); }
private bool IsHardSelection( Model model, PresentationItem bestFilterMatch, ITextSnapshot textSnapshot, CompletionHelper completionHelper, CompletionTrigger trigger, CompletionFilterReason reason) { if (model.SuggestionModeItem != null) { return bestFilterMatch != null && bestFilterMatch.Item.DisplayText == model.SuggestionModeItem.Item.DisplayText; } if (bestFilterMatch == null || model.UseSuggestionMode) { return false; } // We don't have a builder and we have a best match. Normally this will be hard // selected, except for a few cases. Specifically, if no filter text has been // provided, and this is not a preselect match then we will soft select it. This // happens when the completion list comes up implicitly and there is something in // the MRU list. In this case we do want to select it, but not with a hard // selection. Otherwise you can end up with the following problem: // // dim i as integer =<space> // // Completion will comes up after = with 'integer' selected (Because of MRU). We do // not want 'space' to commit this. var viewSpan = model.GetViewBufferSpan(bestFilterMatch.Item.Span); var fullFilterText = model.GetCurrentTextInSnapshot(viewSpan, textSnapshot, endPoint: null); var shouldSoftSelect = ShouldSoftSelectItem(bestFilterMatch.Item, fullFilterText, trigger); if (shouldSoftSelect) { return false; } // If the user moved the caret left after they started typing, the 'best' match may not match at all // against the full text span that this item would be replacing. if (!MatchesFilterText(completionHelper, bestFilterMatch.Item, fullFilterText, trigger, reason, this.Controller.GetRecentItems())) { return false; } // There was either filter text, or this was a preselect match. In either case, we // can hard select this. return true; }
void ICompletionSet.SetCompletionItems(IList <PresentationItem> completionItems, PresentationItem selectedItem, PresentationItem presetBuilder, bool suggestionMode, bool isSoftSelected, ImmutableArray <CompletionItemFilter> completionItemFilters, string filterText) { _roslynCompletionSet.SetCompletionItems(completionItems, selectedItem, presetBuilder, suggestionMode, isSoftSelected, completionItemFilters, filterText); }
internal void OnCompletionItemCommitted(PresentationItem presentationItem) { AssertIsForeground(); this.ItemCommitted?.Invoke(this, new PresentationItemEventArgs(presentationItem)); }
private void Commit( PresentationItem item, Model model, char?commitChar, ITextSnapshot initialTextSnapshot, Action nextHandler) { AssertIsForeground(); // We could only be called if we had a model at this point. Contract.ThrowIfNull(model); // Now that we've captured the model at this point, we can stop ourselves entirely. // This is also desirable as we may have reentrancy problems when we call into // custom commit completion providers. I.e. if the custom provider moves the caret, // then we do not want to process that move as it may put us into an unexpected state. // // TODO(cyrusn): We still have a general reentrancy problem where calling into a custom // commit provider (or just calling into the editor) may cause something to call back // into us. However, for now, we just hope that no such craziness will occur. this.StopModelComputation(); CompletionChange completionChange; using (var transaction = new CaretPreservingEditTransaction( EditorFeaturesResources.IntelliSense, TextView, _undoHistoryRegistry, _editorOperationsFactoryService)) { // We want to merge with any of our other programmatic edits (e.g. automatic brace completion) transaction.MergePolicy = AutomaticCodeChangeMergePolicy.Instance; var provider = GetCompletionProvider(item.Item) as ICustomCommitCompletionProvider; if (provider != null) { provider.Commit(item.Item, this.TextView, this.SubjectBuffer, model.TriggerSnapshot, commitChar); } else { // Right before calling Commit, we may have passed the commitChar through to the // editor. That was so that undoing completion will get us back to the state we // we would be in if completion had done nothing. However, now that we're going // to actually commit, we want to roll back to where we were before we pushed // commit character into the buffer. This has multiple benefits: // // 1) the buffer is in a state we expect it to be in. i.e. we don't have to // worry about what might have happened (like brace-completion) when the // commit char was inserted. // 2) after we commit the item, we'll pass the commit character again into the // buffer (unless the items asks us not to). By doing this, we can make sure // that things like brace-completion or formatting trigger as we expect them // to. var characterWasSentIntoBuffer = commitChar != null && initialTextSnapshot.Version.VersionNumber != this.SubjectBuffer.CurrentSnapshot.Version.VersionNumber; if (characterWasSentIntoBuffer) { RollbackToBeforeTypeChar(initialTextSnapshot); } // Now, get the change the item wants to make. Note that the change will be relative // to the initial snapshot/document the item was triggered from. We'll map that change // forward, then apply it to our current snapshot. var triggerDocument = model.TriggerDocument; var triggerSnapshot = model.TriggerSnapshot; var completionService = CompletionService.GetService(triggerDocument); completionChange = completionService.GetChangeAsync( triggerDocument, item.Item, commitChar, CancellationToken.None).WaitAndGetResult(CancellationToken.None); var textChange = completionChange.TextChange; var triggerSnapshotSpan = new SnapshotSpan(triggerSnapshot, textChange.Span.ToSpan()); var mappedSpan = triggerSnapshotSpan.TranslateTo( this.SubjectBuffer.CurrentSnapshot, SpanTrackingMode.EdgeInclusive); // Now actually make the text change to the document. using (var textEdit = this.SubjectBuffer.CreateEdit(EditOptions.None, reiteratedVersionNumber: null, editTag: null)) { var adjustedNewText = AdjustForVirtualSpace(textChange); textEdit.Replace(mappedSpan.Span, adjustedNewText); textEdit.Apply(); } // adjust the caret position if requested by completion service if (completionChange.NewPosition != null) { TextView.Caret.MoveTo(new SnapshotPoint( this.SubjectBuffer.CurrentSnapshot, completionChange.NewPosition.Value)); } // Now, pass along the commit character unless the completion item said not to if (characterWasSentIntoBuffer && !completionChange.IncludesCommitCharacter) { nextHandler(); } // If the insertion is long enough, the caret will scroll out of the visible area. // Re-center the view. this.TextView.Caret.EnsureVisible(); } transaction.Complete(); } // Let the completion rules know that this item was committed. this.MakeMostRecentItem(item.Item.DisplayText); }
private Model FilterModelInBackgroundWorker( Model model, int id, SnapshotPoint caretPosition, bool recheckCaretPosition, bool dismissIfEmptyAllowed, CompletionFilterReason filterReason) { if (model == null) { return(null); } var filterState = model.FilterState; // If all the filters are on, or all the filters are off then we don't actually // need to filter. if (filterState != null) { if (filterState.Values.All(b => b) || filterState.Values.All(b => !b)) { filterState = null; } } // We want to dismiss the session if the caret ever moved outside our bounds. if (recheckCaretPosition && Controller.IsCaretOutsideAllItemBounds(model, caretPosition)) { return(null); } if (id != _filterId) { return(model); } var textSnapshot = caretPosition.Snapshot; var allFilteredItems = new List <PresentationItem>(); var textSpanToText = new Dictionary <TextSpan, string>(); var helper = this.Controller.GetCompletionHelper(); // isUnique tracks if there is a single bool? isUnique = null; PresentationItem bestFilterMatch = null; bool filterTextIsPotentialIdentifier = false; var recentItems = this.Controller.GetRecentItems(); var itemToFilterText = new Dictionary <CompletionItem, string>(); model = model.WithCompletionItemToFilterText(itemToFilterText); foreach (var currentItem in model.TotalItems) { // Check if something new has happened and there's a later on filter operation // in the chain. If so, there's no need for us to do any more work (as it will // just be superceded by the later work). if (id != _filterId) { return(model); } // We may have wrapped some items in the list in DescriptionModifying items, // but we should use the actual underlying items when filtering. That way // our rules can access the underlying item's provider. if (ItemIsFilteredOut(currentItem.Item, filterState)) { continue; } var filterText = model.GetCurrentTextInSnapshot(currentItem.Item.Span, textSnapshot, textSpanToText); var matchesFilterText = helper.MatchesFilterText(currentItem.Item, filterText, model.Trigger, filterReason, recentItems); itemToFilterText[currentItem.Item] = filterText; if (matchesFilterText) { allFilteredItems.Add(currentItem); // If we have no best match, or this match is better than the last match, // then the current item is the best filter match. if (bestFilterMatch == null || helper.IsBetterFilterMatch(currentItem.Item, bestFilterMatch.Item, filterText, model.Trigger, filterReason, recentItems)) { bestFilterMatch = currentItem; } // If isUnique is null, then this is the first time we've seen an item that // matches the filter text. That item is now considered unique. However, if // isUnique is non-null, then this is the second (or third, or fourth, etc.) // that a provider said to include. It's no longer unique. // // Note: We only want to do this if any filter text was actually provided. // This is so we can handle the following cases properly: // // Console.WriteLi$$ // // If they try to commit unique item there, we want to commit to // "WriteLine". However, if they just have: // // Console.$$ // // And they try to commit unique item, we won't commit something just // because it was in the MRU list. if (filterText != string.Empty) { isUnique = isUnique == null || false; } } else { if (filterText.Length <= 1) { // Even though the rule provider didn't match this, we'll still include it // since we want to allow a user typing a single character and seeing all // possibly completions. However, we don't consider it either unique or a // filter match, so we won't select it. allFilteredItems.Add(currentItem); } // We want to dismiss the list if the user is typing a # and nothing matches filterTextIsPotentialIdentifier = filterTextIsPotentialIdentifier || filterText.Length == 0 || (!char.IsDigit(filterText[0]) && filterText[0] != '-' && filterText[0] != '.'); } } if (!filterTextIsPotentialIdentifier && bestFilterMatch == null) { // We had no matches, and the user is typing a #, dismiss the list return(null); } if (allFilteredItems.Count == 0) { if (dismissIfEmptyAllowed && model.DismissIfEmpty && filterReason != CompletionFilterReason.BackspaceOrDelete) { return(null); } if (model.FilterState != null && model.FilterState.Values.Any(b => b)) { // If the user has turned on some filtering states, and we filtered down to // nothing, then we do want the UI to show that to them. return(model.WithFilteredItems(allFilteredItems.ToImmutableArray()) .WithHardSelection(false) .WithIsUnique(false)); } else { // If we are going to filter everything out, then just preserve the existing // model, but switch over to soft selection. Also, nothing is unique at that // point. return(model.WithHardSelection(false) .WithIsUnique(false)); } } // If we have a best item, then select it. Otherwise just use the first item // in the list. var selectedItem = bestFilterMatch ?? allFilteredItems.First(); // If we have a best item, then we want to hard select it. Otherwise we want // soft selection. However, no hard selection if there's a builder. var hardSelection = IsHardSelection(model, bestFilterMatch, textSnapshot, helper, model.Trigger, filterReason); var result = model.WithFilteredItems(allFilteredItems.ToImmutableArray()) .WithSelectedItem(selectedItem) .WithHardSelection(hardSelection) .WithIsUnique(isUnique.HasValue && isUnique.Value); return(result); }
private void CommitOnNonTypeChar( PresentationItem item, Model model) { Commit(item, model, commitChar: null, initialTextSnapshot: null, nextHandler: null); }
public Model WithSuggestionModeItem(PresentationItem suggestionModeItem) { return suggestionModeItem == this.SuggestionModeItem ? this : new Model(_disconnectedBufferGraph, OriginalList, TotalItems, FilteredItems, SelectedItem, CompletionItemFilters, FilterState, CompletionItemToFilterText, IsHardSelection, IsUnique, UseSuggestionMode, suggestionModeItem, DefaultSuggestionModeItem, Trigger, CommitTrackingSpanEndPoint, DismissIfEmpty); }
internal void OnCompletionItemCommitted(PresentationItem presentationItem) { AssertIsForeground(); this.ItemCommitted?.Invoke(this, new PresentationItemEventArgs(presentationItem)); }
public Model WithSelectedItem(PresentationItem selectedItem) { return(With(selectedItem: selectedItem)); }
public void PresentItems( ITrackingSpan triggerSpan, IList<PresentationItem> completionItems, PresentationItem selectedItem, PresentationItem suggestionModeItem, bool suggestionMode, bool isSoftSelected, ImmutableArray<CompletionItemFilter> completionItemFilters, IReadOnlyDictionary<CompletionItem, string> completionItemToFilterText) { AssertIsForeground(); // check if this update is still relevant if (_textView.IsClosed || _isDismissed) { return; } if (triggerSpan != null) { _completionSet.SetTrackingSpan(triggerSpan); } _ignoreSelectionStatusChangedEvent = true; try { _completionSet.SetCompletionItems( completionItems, selectedItem, suggestionModeItem, suggestionMode, isSoftSelected, completionItemFilters, completionItemToFilterText); } finally { _ignoreSelectionStatusChangedEvent = false; } if (_editorSessionOpt == null) { // We're tracking the caret. Don't have the editor do it. // Map the span instead of a point to avoid affinity problems. _editorSessionOpt = _completionBroker.CreateCompletionSession( _textView, triggerSpan.GetStartTrackingPoint(PointTrackingMode.Negative), trackCaret: false); var debugTextView = _textView as IDebuggerTextView; if (debugTextView != null && !debugTextView.IsImmediateWindow) { debugTextView.HACK_StartCompletionSession(_editorSessionOpt); } _editorSessionOpt.Dismissed += (s, e) => OnEditorSessionDismissed(); // So here's the deal. We cannot create the editor session and give it the right // items (even though we know what they are). Instead, the session will call // back into the ICompletionSourceProvider (which is us) to get those values. It // will pass itself along with the calls back into ICompletionSourceProvider. // So, in order to make that connection work, we add properties to the session // so that we can call back into ourselves, get the items and add it to the // session. _editorSessionOpt.Properties.AddProperty(Key, this); _editorSessionOpt.Start(); } // Call so that the editor will refresh the completion text to embolden. _editorSessionOpt?.Match(); }
public Model WithSuggestionModeItem(PresentationItem suggestionModeItem) { return(With(suggestionModeItem: suggestionModeItem)); }
void ICompletionSet.SetCompletionItems( IList <PresentationItem> completionItems, PresentationItem selectedItem, PresentationItem presetBuilder, bool suggestionMode, bool isSoftSelected, ImmutableArray <CompletionItemFilter> completionItemFilters, IReadOnlyDictionary <CompletionItem, string> completionItemToFilterText) { this._foregroundObject.AssertIsForeground(); VSCompletion selectedCompletionItem = null; // Initialize the completion map to a reasonable default initial size (+1 for the builder) _presentationItemMap = _presentationItemMap ?? new Dictionary <PresentationItem, VSCompletion>(completionItems.Count + 1); _completionItemToFilterText = completionItemToFilterText; try { this.WritableCompletionBuilders.BeginBulkOperation(); this.WritableCompletionBuilders.Clear(); #if DEV15 // If more than one filter was provided, then present it to the user. if (_filters == null && completionItemFilters.Length > 1) { _filters = completionItemFilters.Select(f => new IntellisenseFilter2(this, f, GetLanguage())) .ToArray(); } #endif var applicableToText = this.ApplicableTo.GetText(this.ApplicableTo.TextBuffer.CurrentSnapshot); var filteredSuggestionModeItem = new SimplePresentationItem( CompletionItem.Create( displayText: applicableToText, span: this.ApplicableTo.GetSpan(this.ApplicableTo.TextBuffer.CurrentSnapshot).Span.ToTextSpan()), selectedItem.CompletionService, isSuggestionModeItem: true); var showBuilder = suggestionMode || presetBuilder != null; var bestSuggestionModeItem = applicableToText.Length > 0 ? filteredSuggestionModeItem : presetBuilder ?? filteredSuggestionModeItem; if (showBuilder && bestSuggestionModeItem != null) { var suggestionModeCompletion = GetVSCompletion(bestSuggestionModeItem); this.WritableCompletionBuilders.Add(suggestionModeCompletion); if (selectedItem != null && selectedItem.IsSuggestionModeItem) { selectedCompletionItem = suggestionModeCompletion; } } } finally { this.WritableCompletionBuilders.EndBulkOperation(); } try { this.WritableCompletions.BeginBulkOperation(); this.WritableCompletions.Clear(); foreach (var item in completionItems) { var completionItem = GetVSCompletion(item); this.WritableCompletions.Add(completionItem); if (item == selectedItem) { selectedCompletionItem = completionItem; } } } finally { this.WritableCompletions.EndBulkOperation(); } this.SelectionStatus = new CompletionSelectionStatus( selectedCompletionItem, isSelected: !isSoftSelected, isUnique: selectedCompletionItem != null); }
protected bool Equals(PresentationItem other) { return(string.Equals(Title, other.Title) && string.Equals(AddedBy, other.AddedBy) && ImageUrl == other.ImageUrl); }