int IOleCommandTarget.Exec(ref Guid pguidCmdGroup, uint nCmdID, uint nCmdexecopt, IntPtr pvaIn, IntPtr pvaOut) { if (pguidCmdGroup == commandGroup && nCmdID == commandId) { targetCommand.Execute(null); return(VSConstants.S_OK); } return(next?.Exec(ref pguidCmdGroup, nCmdID, nCmdexecopt, pvaIn, pvaOut) ?? 0); }
int IOleCommandTarget.Exec(ref Guid pguidCmdGroup, uint nCmdID, uint nCmdexecopt, IntPtr pvaIn, IntPtr pvaOut) { if (pguidCmdGroup == commandGroup && nCmdID == commandId) { Exec?.Invoke(this, EventArgs.Empty); return(0); } return(next?.Exec(ref pguidCmdGroup, nCmdID, nCmdexecopt, pvaIn, pvaOut) ?? 0); }
int IOleCommandTarget.Exec(ref Guid pguidCmdGroup, uint nCmdID, uint nCmdexecopt, IntPtr pvaIn, IntPtr pvaOut) { if (pguidCmdGroup == Constants.VS2017CmdSet && nCmdID == Constants.GotoImplementationCmdId) { var caretPosition = _context.WpfTextView.Caret.Position.BufferPosition; var lyzer = new CodeAnalyzer(_context.ServiceProvider); var result = lyzer.IsResourceDesignerProperty(caretPosition).Result; if (result.result) { return(lyzer.FindResourceReferences(result.document, result.designerProperty)); } } return(_nextCommandTarget?.Exec(pguidCmdGroup, nCmdID, nCmdexecopt, pvaIn, pvaOut) ?? VSConstants.S_OK); }
protected override bool Execute(uint nCmdID, uint nCmdexecopt, IntPtr pvaIn, IntPtr pvaOut, IOleCommandTarget nextCommandTarget) { var groupId = CommandGroupId; if (nextCommandTarget.Exec(ref groupId, nCmdID, nCmdexecopt, pvaIn, pvaOut) == VSConstants.S_OK) { // parse the content var tokenizer = new RwHtmlTokenizer(); var text = TextView.TextSnapshot.GetText(); tokenizer.Tokenize(new StringReader(text)); var parser = new RwHtmlParser(); var node = parser.Parse(tokenizer.Tokens); // prepare the metadata control resolver var completionSource = TextView.TextBuffer.Properties.GetProperty<RwHtmlCompletionSource>(typeof(RwHtmlCompletionSource)); var metadataControlResolver = completionSource.MetadataControlResolver; metadataControlResolver.ReloadAllControls(completionSource.GetCompletionContext()); try { CompletionHelper.DTE.UndoContext.Open("Format RWHTML document"); var edit = TextView.TextBuffer.CreateEdit(EditOptions.None, null, null); // fix the casing of all elements var editText = new StringBuilder(text); foreach (var element in node.EnumerateNodes().OfType<RwHtmlElementNode>()) { FixElement(editText, metadataControlResolver, TextView.TextBuffer, element); } edit.Replace(0, editText.Length, editText.ToString()); edit.Apply(); } finally { CompletionHelper.DTE.UndoContext.Close(); } } return true; }
/// <summary> /// Try and process the KeyInput from the Exec method. This method decides whether or not /// a key should be processed directly by IVimBuffer or if should be going through /// IOleCommandTarget. Generally the key is processed by IVimBuffer but for many intellisense /// scenarios we want the key to be routed to Visual Studio directly. Issues to consider /// here are ... /// /// - How should the KeyInput participate in Macro playback? /// - Does both VsVim and Visual Studio need to process the key (Escape mainly) /// /// </summary> private bool TryProcessWithBuffer(KeyInput keyInput) { // If the IVimBuffer can't process it then it doesn't matter if (!_vimBuffer.CanProcess(keyInput)) { return(false); } // In the middle of a word completion session let insert mode handle the input. It's // displaying the intellisense itself and this method is meant to let custom intellisense // operate normally if (_vimBuffer.ModeKind == ModeKind.Insert && _vimBuffer.InsertMode.ActiveWordCompletionSession.IsSome()) { return(_vimBuffer.Process(keyInput).IsAnyHandled); } // If we are in a peek definition window and normal mode we need to let the Escape key // pass on to the next command target. This is necessary to close the peek definition // window if (_vimBuffer.ModeKind == ModeKind.Normal && _textView.Roles.Contains(VsVimConstants.TextViewRoleEmbeddedPeekTextView) && keyInput == KeyInputUtil.EscapeKey) { return(false); } // The only time we actively intercept keys and route them through IOleCommandTarget // is when one of the IDisplayWindowBroker windows is active // // In those cases if the KeyInput is a command which should be handled by the // display window we route it through IOleCommandTarget to get the proper // experience for those features if (!_broker.IsAnyDisplayActive()) { return(_vimBuffer.Process(keyInput).IsAnyHandled); } // Next we need to consider here are Key mappings. The CanProcess and Process APIs // will automatically map the KeyInput under the hood at the IVimBuffer level but // not at the individual IMode. Have to manually map here and test against the // mapped KeyInput if (!TryGetSingleMapping(keyInput, out KeyInput mapped)) { return(_vimBuffer.Process(keyInput).IsAnyHandled); } bool handled; if (IsDisplayWindowKey(mapped)) { // If the key which actually needs to be processed is a display window key, say // down, up, etc..., then forward it on to the next IOleCommandTarget. It is responsible // for mapping that key to action against the display window handled = ErrorHandler.Succeeded(_nextOleCommandTarget.Exec(mapped)); } else { // Intentionally using keyInput here and not mapped. Process will do mapping on the // provided input hence we should be using the original keyInput here not mapped handled = _vimBuffer.Process(keyInput).IsAnyHandled; } // The Escape key should always dismiss the active completion session. However Vim // itself is mostly ignorant of display windows and typically won't dismiss them // as part of processing Escape (one exception is insert mode). Dismiss it here if // it's still active if (mapped.Key == VimKey.Escape && _broker.IsAnyDisplayActive()) { _broker.DismissDisplayWindows(); } return(handled); }
public int Exec(ref Guid pguidCmdGroup, uint nCmdId, uint nCmdexecopt, IntPtr pvaIn, IntPtr pvaOut) { return(_commandTarget?.Exec(ref pguidCmdGroup, nCmdId, nCmdexecopt, pvaIn, pvaOut) ?? (int)Constants.OLECMDERR_E_NOTSUPPORTED); }
public int Exec(ref Guid pguidCmdGroup, uint nCmdID, uint nCmdexecopt, IntPtr pvaIn, IntPtr pvaOut) { int hr; // disable JavaScript language services auto formatting features, this is because // they are not aware that we have an extra level of indentation if (pguidCmdGroup == VSConstants.VSStd2K) { JavaScriptOutliningTaggerProvider.OutliningTagger tagger; switch ((VSConstants.VSStd2KCmdID)nCmdID) { case VSConstants.VSStd2KCmdID.FORMATSELECTION: FormatSelection(); return VSConstants.S_OK; case VSConstants.VSStd2KCmdID.FORMATDOCUMENT: FormatDocument(); return VSConstants.S_OK; case VSConstants.VSStd2KCmdID.RETURN: if (_intellisenseStack.TopSession != null && _intellisenseStack.TopSession is ICompletionSession && !_intellisenseStack.TopSession.IsDismissed) { ((ICompletionSession)_intellisenseStack.TopSession).Commit(); } else { SnapshotPoint start, end; var startEndFound = GetStartAndEndOfCurrentLine(out start, out end); hr = _next.Exec(ref pguidCmdGroup, nCmdID, nCmdexecopt, pvaIn, pvaOut); if (startEndFound) { FormatOnEnter(start, end); } return hr; } return VSConstants.S_OK; case VSConstants.VSStd2KCmdID.TYPECHAR: if (!_incSearch.IsActive) { var ch = (char)(ushort)System.Runtime.InteropServices.Marshal.GetObjectForNativeVariant(pvaIn); int res = _next.Exec(ref pguidCmdGroup, nCmdID, nCmdexecopt, pvaIn, pvaOut); switch (ch) { case '}': case ';': FormatAfterTyping(ch); break; } if (_activeSession != null && !_activeSession.IsDismissed) { _activeSession.Filter(); } return res; } break; case VSConstants.VSStd2KCmdID.PASTE: return Paste(ref pguidCmdGroup, nCmdID, nCmdexecopt, pvaIn, pvaOut, out hr); case VSConstants.VSStd2KCmdID.COMMENT_BLOCK: case VSConstants.VSStd2KCmdID.COMMENTBLOCK: if (_textView.CommentOrUncommentBlock(comment: true)) { return VSConstants.S_OK; } break; case VSConstants.VSStd2KCmdID.UNCOMMENT_BLOCK: case VSConstants.VSStd2KCmdID.UNCOMMENTBLOCK: if (_textView.CommentOrUncommentBlock(comment: false)) { return VSConstants.S_OK; } break; case VSConstants.VSStd2KCmdID.OUTLN_STOP_HIDING_ALL: tagger = _textView.GetOutliningTagger(); if (tagger != null) { tagger.Disable(); } // let VS get the event as well break; case VSConstants.VSStd2KCmdID.OUTLN_START_AUTOHIDING: tagger = _textView.GetOutliningTagger(); if (tagger != null) { tagger.Enable(); } // let VS get the event as well break; } } else if (pguidCmdGroup == VSConstants.GUID_VSStandardCommandSet97) { switch ((VSConstants.VSStd97CmdID)nCmdID) { case VSConstants.VSStd97CmdID.GotoDefn: return GotoDefinition(); case VSConstants.VSStd97CmdID.FindReferences: return FindAllReferences(); case VSConstants.VSStd97CmdID.Paste: return Paste(ref pguidCmdGroup, nCmdID, nCmdexecopt, pvaIn, pvaOut, out hr); } } return _next.Exec(ref pguidCmdGroup, nCmdID, nCmdexecopt, pvaIn, pvaOut); }
public static void Tab(this IOleCommandTarget target) { var guid = VSConstants.VSStd2K; target.Exec(ref guid, (int)VSConstants.VSStd2KCmdID.TAB, 0, IntPtr.Zero, IntPtr.Zero); }
public static void MemberList(this IOleCommandTarget target) { var guid = VSConstants.VSStd2K; ErrorHandler.ThrowOnFailure(target.Exec(ref guid, (int)VSConstants.VSStd2KCmdID.SHOWMEMBERLIST, 0, IntPtr.Zero, IntPtr.Zero)); }
private int PreLanguageCommandFilterExec(ref Guid pguidCmdGroup, uint nCmdID, uint nCmdexecopt, IntPtr pvaIn, IntPtr pvaOut) { var nextTarget = firstLanguageServiceCommandFilter ?? _editorServicesCommandFilter; if (pguidCmdGroup == Guids.InteractiveCommandSetId) { switch ((CommandIds)nCmdID) { case CommandIds.AbortExecution: _window.Evaluator.AbortExecution(); return(VSConstants.S_OK); case CommandIds.Reset: _window.Operations.ResetAsync(); return(VSConstants.S_OK); case CommandIds.SmartExecute: _window.Operations.ExecuteInput(); return(VSConstants.S_OK); case CommandIds.HistoryNext: _window.Operations.HistoryNext(); return(VSConstants.S_OK); case CommandIds.HistoryPrevious: _window.Operations.HistoryPrevious(); return(VSConstants.S_OK); case CommandIds.ClearScreen: _window.Operations.ClearView(); return(VSConstants.S_OK); case CommandIds.CopyCode: { var operation = _window.Operations as IInteractiveWindowOperations2; if (operation != null) { operation.CopyCode(); } return(VSConstants.S_OK); } case CommandIds.SearchHistoryNext: _window.Operations.HistorySearchNext(); return(VSConstants.S_OK); case CommandIds.SearchHistoryPrevious: _window.Operations.HistorySearchPrevious(); return(VSConstants.S_OK); } } else if (pguidCmdGroup == VSConstants.VSStd2K) { switch ((VSConstants.VSStd2KCmdID)nCmdID) { case VSConstants.VSStd2KCmdID.RETURN: if (_window.Operations.TrySubmitStandardInput()) { return(VSConstants.S_OK); } break; case VSConstants.VSStd2KCmdID.SHOWCONTEXTMENU: ShowContextMenu(); return(VSConstants.S_OK); } } else if (currentBufferCommandHandler != null && pguidCmdGroup == VSConstants.GUID_VSStandardCommandSet97) { // undo/redo support: switch ((VSConstants.VSStd97CmdID)nCmdID) { // TODO: remove (https://github.com/dotnet/roslyn/issues/5642) case VSConstants.VSStd97CmdID.FindReferences: return(VSConstants.S_OK); case VSConstants.VSStd97CmdID.Undo: case VSConstants.VSStd97CmdID.MultiLevelUndo: case VSConstants.VSStd97CmdID.MultiLevelUndoList: case VSConstants.VSStd97CmdID.Redo: case VSConstants.VSStd97CmdID.MultiLevelRedo: case VSConstants.VSStd97CmdID.MultiLevelRedoList: return(currentBufferCommandHandler.Exec(ref pguidCmdGroup, nCmdID, nCmdexecopt, pvaIn, pvaOut)); } } int res = nextTarget.Exec(ref pguidCmdGroup, nCmdID, nCmdexecopt, pvaIn, pvaOut); #if DUMP_COMMANDS DumpCmd("Exec", result, ref pguidCmdGroup, nCmdID, 0); #endif return(res); }
private int ExecWorker(ref Guid pguidCmdGroup, uint nCmdID, uint nCmdexecopt, IntPtr pvaIn, IntPtr pvaOut) { // preprocessing if (pguidCmdGroup == VSConstants.GUID_VSStandardCommandSet97) { switch ((VSConstants.VSStd97CmdID)nCmdID) { case VSConstants.VSStd97CmdID.Paste: if (!_pyService.AdvancedOptions.PasteRemovesReplPrompts) { // Not stripping prompts, so don't use our logic break; } var beforePaste = _textView.TextSnapshot; if (_editorOps.Paste()) { var afterPaste = _textView.TextSnapshot; var um = _undoManagerProvider.GetTextBufferUndoManager(afterPaste.TextBuffer); using (var undo = um.TextBufferUndoHistory.CreateTransaction(Strings.RemoveReplPrompts)) { if (ReplPromptHelpers.RemovePastedPrompts(beforePaste, afterPaste)) { undo.Complete(); } } return(VSConstants.S_OK); } break; case VSConstants.VSStd97CmdID.GotoDefn: GotoDefinition(); return(VSConstants.S_OK); case VSConstants.VSStd97CmdID.FindReferences: FindAllReferences(); return(VSConstants.S_OK); } } else if (pguidCmdGroup == CommonConstants.Std2KCmdGroupGuid) { SnapshotPoint?pyPoint; switch ((VSConstants.VSStd2KCmdID)nCmdID) { case VSConstants.VSStd2KCmdID.RETURN: pyPoint = _textView.GetPythonCaret(); if (pyPoint != null) { // https://github.com/Microsoft/PTVS/issues/241 // If the current line is a full line comment and we // are splitting the text, automatically insert the // comment marker on the new line. var line = pyPoint.Value.GetContainingLine(); var lineText = pyPoint.Value.Snapshot.GetText(line.Start, pyPoint.Value - line.Start); int comment = lineText.IndexOf('#'); if (comment >= 0 && pyPoint.Value < line.End && line.Start + comment < pyPoint.Value && string.IsNullOrWhiteSpace(lineText.Remove(comment)) ) { int extra = lineText.Skip(comment + 1).TakeWhile(char.IsWhiteSpace).Count() + 1; using (var edit = line.Snapshot.TextBuffer.CreateEdit()) { edit.Insert( pyPoint.Value.Position, _textView.Options.GetNewLineCharacter() + lineText.Substring(0, comment + extra) ); edit.Apply(); } return(VSConstants.S_OK); } } break; case VSConstants.VSStd2KCmdID.FORMATDOCUMENT: pyPoint = _textView.GetPythonCaret(); if (pyPoint != null) { FormatCode(new SnapshotSpan(pyPoint.Value.Snapshot, 0, pyPoint.Value.Snapshot.Length), false); } return(VSConstants.S_OK); case VSConstants.VSStd2KCmdID.FORMATSELECTION: foreach (var span in _textView.BufferGraph.MapDownToFirstMatch( _textView.Selection.StreamSelectionSpan.SnapshotSpan, SpanTrackingMode.EdgeInclusive, EditorExtensions.IsPythonContent )) { FormatCode(span, true); } return(VSConstants.S_OK); case VSConstants.VSStd2KCmdID.SHOWMEMBERLIST: case VSConstants.VSStd2KCmdID.COMPLETEWORD: var controller = _textView.Properties.GetProperty <IntellisenseController>(typeof(IntellisenseController)); if (controller != null) { IntellisenseController.ForceCompletions = true; try { controller.TriggerCompletionSession( (VSConstants.VSStd2KCmdID)nCmdID == VSConstants.VSStd2KCmdID.COMPLETEWORD, true ); } finally { IntellisenseController.ForceCompletions = false; } return(VSConstants.S_OK); } break; case VSConstants.VSStd2KCmdID.QUICKINFO: controller = _textView.Properties.GetProperty <IntellisenseController>(typeof(IntellisenseController)); if (controller != null) { controller.TriggerQuickInfo(); return(VSConstants.S_OK); } break; case VSConstants.VSStd2KCmdID.PARAMINFO: controller = _textView.Properties.GetProperty <IntellisenseController>(typeof(IntellisenseController)); if (controller != null) { controller.TriggerSignatureHelp(); return(VSConstants.S_OK); } break; case VSConstants.VSStd2KCmdID.OUTLN_STOP_HIDING_ALL: _textView.GetOutliningTagger()?.Disable(); // let VS get the event as well break; case VSConstants.VSStd2KCmdID.OUTLN_START_AUTOHIDING: _textView.GetOutliningTagger()?.Enable(); // let VS get the event as well break; case VSConstants.VSStd2KCmdID.COMMENT_BLOCK: case VSConstants.VSStd2KCmdID.COMMENTBLOCK: if (_textView.CommentOrUncommentBlock(comment: true)) { return(VSConstants.S_OK); } break; case VSConstants.VSStd2KCmdID.UNCOMMENT_BLOCK: case VSConstants.VSStd2KCmdID.UNCOMMENTBLOCK: if (_textView.CommentOrUncommentBlock(comment: false)) { return(VSConstants.S_OK); } break; case VSConstants.VSStd2KCmdID.EXTRACTMETHOD: ExtractMethod(); return(VSConstants.S_OK); case VSConstants.VSStd2KCmdID.RENAME: RefactorRename(); return(VSConstants.S_OK); } } else if (pguidCmdGroup == GuidList.guidPythonToolsCmdSet) { switch (nCmdID) { case PkgCmdIDList.cmdidRefactorRenameIntegratedShell: RefactorRename(); return(VSConstants.S_OK); case PkgCmdIDList.cmdidExtractMethodIntegratedShell: ExtractMethod(); return(VSConstants.S_OK); case CommonConstants.StartDebuggingCmdId: case CommonConstants.StartWithoutDebuggingCmdId: PythonToolsPackage.LaunchFile(_serviceProvider, _textView.GetFilePath(), nCmdID == CommonConstants.StartDebuggingCmdId, true); return(VSConstants.S_OK); } } return(_next.Exec(pguidCmdGroup, nCmdID, nCmdexecopt, pvaIn, pvaOut)); }
public int Exec(ref Guid pguidCmdGroup, uint nCmdID, uint nCmdexecopt, IntPtr pvaIn, IntPtr pvaOut) { try { if (VsShellUtilities.IsInAutomationFunction(m_provider.ServiceProvider)) { return(m_nextCommandHandler.Exec(ref pguidCmdGroup, nCmdID, nCmdexecopt, pvaIn, pvaOut)); } // make a copy of this so we can look at it after forwarding some commands uint commandID = nCmdID; char typedChar = char.MinValue; // make sure the input is a char before getting it if (pguidCmdGroup == VSConstants.VSStd2K && nCmdID == (uint)VSConstants.VSStd2KCmdID.TYPECHAR) { typedChar = (char)(ushort)Marshal.GetObjectForNativeVariant(pvaIn); } // check for the triple slash if (typedChar == '/' && m_dte != null) { string currentLine = m_textView.TextSnapshot.GetLineFromPosition( m_textView.Caret.Position.BufferPosition.Position).GetText(); if ((currentLine + "/").Trim() == "///") { // Calculate how many spaces string spaces = currentLine.Replace(currentLine.TrimStart(), ""); TextSelection ts = m_dte.ActiveDocument.Selection as TextSelection; int oldLine = ts.ActivePoint.Line; int oldOffset = ts.ActivePoint.LineCharOffset; ts.LineDown(); ts.EndOfLine(); CodeElement codeElement = null; FileCodeModel fcm = m_dte.ActiveDocument.ProjectItem.FileCodeModel; if (fcm != null) { codeElement = fcm.CodeElementFromPoint(ts.ActivePoint, vsCMElement.vsCMElementFunction); } ts.MoveToLineAndOffset(oldLine, oldOffset - 2); ts.Delete(2); if (codeElement != null && codeElement is CodeFunction) { ts.Insert(createJavaStyleComment(codeElement, spaces)); ts.MoveToLineAndOffset(oldLine, oldOffset); ts.LineDown(); ts.EndOfLine(); return(VSConstants.S_OK); } else { ts.Insert("/**\r\n" + spaces + "* \r\n" + spaces + "* \r\n" + spaces + "*/"); ts.MoveToLineAndOffset(oldLine, oldOffset); ts.LineDown(); ts.EndOfLine(); return(VSConstants.S_OK); } } } if (m_session != null && !m_session.IsDismissed) { // check for a commit character if (nCmdID == (uint)VSConstants.VSStd2KCmdID.RETURN || nCmdID == (uint)VSConstants.VSStd2KCmdID.TAB || typedChar == '>') { // check for a selection // if the selection is fully selected, commit the current session if (m_session.SelectedCompletionSet.SelectionStatus.IsSelected) { string selectedCompletion = m_session.SelectedCompletionSet.SelectionStatus.Completion.DisplayText; m_session.Commit(); TextSelection ts = m_dte.ActiveDocument.Selection as TextSelection; switch (selectedCompletion) { case "<!-->": ts.CharLeft(false, 3); break; case "<![CDATA[>": ts.CharLeft(false, 3); break; case "<c>": ts.CharLeft(false, 4); break; case "<code>": ts.CharLeft(false, 7); break; case "<example>": ts.CharLeft(false, 10); break; case "<exception>": ts.CharLeft(false, 14); break; case "<include>": ts.CharLeft(false, 21); break; case "<list>": ts.CharLeft(false, 7); break; case "<para>": ts.CharLeft(false, 7); break; case "<param>": ts.CharLeft(false, 10); break; case "<paramref>": ts.CharLeft(false, 13); break; case "<permission>": ts.CharLeft(false, 15); break; case "<remarks>": ts.CharLeft(false, 10); break; case "<returns>": ts.CharLeft(false, 10); break; case "<see>": ts.CharLeft(false, 3); break; case "<seealso>": ts.CharLeft(false, 3); break; case "<typeparam>": ts.CharLeft(false, 14); break; case "<value>": ts.CharLeft(false, 8); break; default: break; } // also, don't add the character to the buffer return(VSConstants.S_OK); } else { // if there is no selection, dismiss the session m_session.Dismiss(); } } } else { if (pguidCmdGroup == VSConstants.VSStd2K && nCmdID == (uint)VSConstants.VSStd2KCmdID.RETURN) { string currentLine = m_textView.TextSnapshot.GetLineFromPosition( m_textView.Caret.Position.BufferPosition.Position).GetText(); if (currentLine.TrimStart().StartsWith("///")) { TextSelection ts = m_dte.ActiveDocument.Selection as TextSelection; string spaces = currentLine.Replace(currentLine.TrimStart(), ""); ts.Insert("\r\n" + spaces + "/// "); return(VSConstants.S_OK); } } } // pass along the command so the char is added to the buffer int retVal = m_nextCommandHandler.Exec(ref pguidCmdGroup, nCmdID, nCmdexecopt, pvaIn, pvaOut); if (typedChar == '<') { string currentLine = m_textView.TextSnapshot.GetLineFromPosition( m_textView.Caret.Position.BufferPosition.Position).GetText(); if (currentLine.TrimStart().StartsWith("///")) { if (m_session == null || m_session.IsDismissed) // If there is no active session, bring up completion { if (this.TriggerCompletion()) { m_session.Filter(); return(VSConstants.S_OK); } } } } else if ( commandID == (uint)VSConstants.VSStd2KCmdID.BACKSPACE || commandID == (uint)VSConstants.VSStd2KCmdID.DELETE || char.IsLetter(typedChar)) { if (m_session != null && !m_session.IsDismissed) // the completion session is already active, so just filter { m_session.Filter(); return(VSConstants.S_OK); } } return(retVal); } catch { } return(VSConstants.E_FAIL); }
private int ExecWorker(ref Guid pguidCmdGroup, uint nCmdID, uint nCmdexecopt, IntPtr pvaIn, IntPtr pvaOut) { // preprocessing if (pguidCmdGroup == VSConstants.GUID_VSStandardCommandSet97) { switch ((VSConstants.VSStd97CmdID)nCmdID) { case VSConstants.VSStd97CmdID.Paste: if (!_editorServices.Python.AdvancedOptions.PasteRemovesReplPrompts) { // Not stripping prompts, so don't use our logic break; } var beforePaste = _textView.TextSnapshot; if (_editorServices.EditOperationsFactory.GetEditorOperations(_textView).Paste()) { var afterPaste = _textView.TextSnapshot; var um = _editorServices.UndoManagerFactory.GetTextBufferUndoManager(afterPaste.TextBuffer); using (var undo = um.TextBufferUndoHistory.CreateTransaction(Strings.RemoveReplPrompts)) { if (ReplPromptHelpers.RemovePastedPrompts(beforePaste, afterPaste)) { undo.Complete(); } } return(VSConstants.S_OK); } break; case VSConstants.VSStd97CmdID.GotoDefn: GotoDefinition(); return(VSConstants.S_OK); case VSConstants.VSStd97CmdID.FindReferences: FindAllReferences(); return(VSConstants.S_OK); } } else if (pguidCmdGroup == VSConstants.VsStd12) { switch ((VSConstants.VSStd12CmdID)nCmdID) { case VSConstants.VSStd12CmdID.PeekDefinition: if (_editorServices.PeekBroker != null && !_textView.Roles.Contains(PredefinedTextViewRoles.EmbeddedPeekTextView) && !_textView.Roles.Contains(PredefinedTextViewRoles.CodeDefinitionView)) { _editorServices.PeekBroker.TriggerPeekSession(_textView, PredefinedPeekRelationships.Definitions.Name); return(VSConstants.S_OK); } break; } } else if (pguidCmdGroup == CommonConstants.Std2KCmdGroupGuid) { SnapshotPoint? pyPoint; IntellisenseController controller; switch ((VSConstants.VSStd2KCmdID)nCmdID) { case VSConstants.VSStd2KCmdID.RETURN: pyPoint = _textView.GetPythonCaret(); if (pyPoint != null) { // https://github.com/Microsoft/PTVS/issues/241 // If the current line is a full line comment and we // are splitting the text, automatically insert the // comment marker on the new line. var line = pyPoint.Value.GetContainingLine(); var lineText = pyPoint.Value.Snapshot.GetText(line.Start, pyPoint.Value - line.Start); int comment = lineText.IndexOf('#'); if (comment >= 0 && pyPoint.Value < line.End && line.Start + comment < pyPoint.Value && string.IsNullOrWhiteSpace(lineText.Remove(comment)) ) { int extra = lineText.Skip(comment + 1).TakeWhile(char.IsWhiteSpace).Count() + 1; using (var edit = line.Snapshot.TextBuffer.CreateEdit()) { edit.Insert( pyPoint.Value.Position, _textView.Options.GetNewLineCharacter() + lineText.Substring(0, comment + extra) ); edit.Apply(); } return(VSConstants.S_OK); } } break; case VSConstants.VSStd2KCmdID.FORMATDOCUMENT: FormatDocumentAsync().DoNotWait(); return(VSConstants.S_OK); case VSConstants.VSStd2KCmdID.FORMATSELECTION: FormatSelectionAsync().DoNotWait(); return(VSConstants.S_OK); case VSConstants.VSStd2KCmdID.SHOWMEMBERLIST: case VSConstants.VSStd2KCmdID.COMPLETEWORD: if (_textView.Properties.TryGetProperty(typeof(IntellisenseController), out controller)) { controller.TriggerCompletionSession( (VSConstants.VSStd2KCmdID)nCmdID == VSConstants.VSStd2KCmdID.COMPLETEWORD, '\0', true ).DoNotWait(); return(VSConstants.S_OK); } break; case VSConstants.VSStd2KCmdID.QUICKINFO: if (_textView.Properties.TryGetProperty(typeof(IntellisenseController), out controller)) { controller.TriggerQuickInfoAsync().DoNotWait(); return(VSConstants.S_OK); } break; case VSConstants.VSStd2KCmdID.PARAMINFO: if (_textView.Properties.TryGetProperty(typeof(IntellisenseController), out controller)) { controller.TriggerSignatureHelp(); return(VSConstants.S_OK); } break; case VSConstants.VSStd2KCmdID.OUTLN_STOP_HIDING_ALL: _textView.GetOutliningTagger()?.Disable(_textView.TextSnapshot); // let VS get the event as well break; case VSConstants.VSStd2KCmdID.OUTLN_START_AUTOHIDING: _textView.GetOutliningTagger()?.Enable(_textView.TextSnapshot); // let VS get the event as well break; case VSConstants.VSStd2KCmdID.COMMENT_BLOCK: case VSConstants.VSStd2KCmdID.COMMENTBLOCK: if (_textView.CommentOrUncommentBlock(comment: true)) { return(VSConstants.S_OK); } break; case VSConstants.VSStd2KCmdID.UNCOMMENT_BLOCK: case VSConstants.VSStd2KCmdID.UNCOMMENTBLOCK: if (_textView.CommentOrUncommentBlock(comment: false)) { return(VSConstants.S_OK); } break; case VSConstants.VSStd2KCmdID.EXTRACTMETHOD: ExtractMethod(); return(VSConstants.S_OK); case VSConstants.VSStd2KCmdID.RENAME: RefactorRename(); return(VSConstants.S_OK); } } else if (pguidCmdGroup == GuidList.guidPythonToolsCmdSet) { switch (nCmdID) { case PkgCmdIDList.cmdidRefactorRenameIntegratedShell: RefactorRename(); return(VSConstants.S_OK); case PkgCmdIDList.cmdidExtractMethodIntegratedShell: ExtractMethod(); return(VSConstants.S_OK); case CommonConstants.StartDebuggingCmdId: case CommonConstants.StartWithoutDebuggingCmdId: PythonToolsPackage.LaunchFile(_editorServices.Site, _textView.GetFilePath(), nCmdID == CommonConstants.StartDebuggingCmdId, true); return(VSConstants.S_OK); } } return(_next.Exec(pguidCmdGroup, nCmdID, nCmdexecopt, pvaIn, pvaOut)); }
int IOleCommandTarget.Exec(ref Guid pguidCmdGroup, uint nCmdID, uint nCmdexecopt, IntPtr pvaIn, IntPtr pvaOut) { ThreadHelper.ThrowIfNotOnUIThread(); return(_editorCommandTarget.Exec(ref pguidCmdGroup, nCmdID, nCmdexecopt, pvaIn, pvaOut)); }
/// <summary> /// Handles a new command. /// </summary> /// <param name="CommandGroupGuid">The GUID of the command group.</param> /// <param name="CommandID">The command ID.</param> /// <param name="ExecOptions">Not used.</param> /// <param name="InputArgs">The input arguments of the command.</param> /// <param name="OutputArgs">The output arguments of the command.</param> /// <returns>A status code, either S_OK on a successful command exection or some other /// code that describes what happened if the command failed.</returns> public int Exec(ref Guid CommandGroupGuid, uint CommandID, uint ExecOptions, IntPtr InputArgs, IntPtr OutputArgs) { ThreadHelper.ThrowIfNotOnUIThread(); try { // If we're in an automation function, we don't actually need to do anything. if (VsShellUtilities.IsInAutomationFunction(Provider.ServiceProvider)) { return(NextCommandHandler.Exec(ref CommandGroupGuid, CommandID, ExecOptions, InputArgs, OutputArgs)); } // Get the character that was just typed (if there was one) char typedChar = char.MinValue; if (CommandGroupGuid == VSConstants.VSStd2K && CommandID == (uint)VSConstants.VSStd2KCmdID.TYPECHAR) { typedChar = (char)Marshal.GetObjectForNativeVariant <ushort>(InputArgs); } // Check if the user just entered a triple slash if (typedChar == '/' && Dte != null) { if (UserTypedTripleSlash()) { Logger.Debug("User entered a triple slash, handling it..."); HandleTripleSlash(); return(VSConstants.S_OK); } } // Check if there's an autocomplete session open and the user just tried to accept one // of the autocomplete suggestions else if (MarkdownCompletionSession?.IsDismissed == false) { if (CommandID == (uint)VSConstants.VSStd2KCmdID.RETURN || CommandID == (uint)VSConstants.VSStd2KCmdID.TAB) { if (MarkdownCompletionSession.SelectedCompletionSet.SelectionStatus.IsSelected) { Logger.Debug("User selected a Markdown header autocompletion suggestion."); MarkdownCompletionSession.Commit(); return(VSConstants.S_OK); } } } // Handle the user pressing enter inside of a comment else if (CommandGroupGuid == VSConstants.VSStd2K && CommandID == (uint)VSConstants.VSStd2KCmdID.RETURN) { if (HandleNewlineInCommentBlock()) { Logger.Debug("User added a new line to a comment block."); return(VSConstants.S_OK); } } // If none of the above happened, pass the event onto the regular handler. int nextCommandResult = NextCommandHandler.Exec(ref CommandGroupGuid, CommandID, ExecOptions, InputArgs, OutputArgs); // Check to see if the user typed "#" so we need to start an autocomplete session if (typedChar == '#') { string currentLine = TextView.TextSnapshot.GetLineFromPosition( TextView.Caret.Position.BufferPosition.Position).GetText(); if (currentLine.TrimStart().StartsWith("/// #")) { // Create a new autocompletion session if there isn't one already Logger.Debug("User entered # on a triple-slashed line, starting a new autocomplete session..."); if (MarkdownCompletionSession == null || MarkdownCompletionSession.IsDismissed) { if (StartMarkdownAutocompleteSession()) { MarkdownCompletionSession.SelectedCompletionSet.SelectBestMatch(); MarkdownCompletionSession.SelectedCompletionSet.Recalculate(); return(VSConstants.S_OK); } } } } // Check if there's an active autocomplete session, and the user just modified the text // in the editor else if (CommandID == (uint)VSConstants.VSStd2KCmdID.BACKSPACE || CommandID == (uint)VSConstants.VSStd2KCmdID.DELETE || char.IsLetter(typedChar)) { if (MarkdownCompletionSession?.IsDismissed == false) { MarkdownCompletionSession.SelectedCompletionSet.SelectBestMatch(); MarkdownCompletionSession.SelectedCompletionSet.Recalculate(); return(VSConstants.S_OK); } } return(nextCommandResult); } catch (Exception ex) { Logger.Error($"Error handling command: {ex.GetType().Name} - {ex.Message}"); Logger.Trace(ex.StackTrace); return(VSConstants.E_FAIL); } }
private int PreLanguageCommandFilterExec(ref Guid pguidCmdGroup, uint nCmdID, uint nCmdexecopt, IntPtr pvaIn, IntPtr pvaOut) { var nextTarget = firstLanguageServiceCommandFilter ?? _editorServicesCommandFilter; if (pguidCmdGroup == Guids.InteractiveCommandSetId) { switch ((CommandIds)nCmdID) { case CommandIds.AbortExecution: _window.AbortCommand(); return(VSConstants.S_OK); case CommandIds.Reset: _window.Operations.ResetAsync(); return(VSConstants.S_OK); case CommandIds.SmartExecute: _window.Operations.ExecuteInput(); return(VSConstants.S_OK); case CommandIds.HistoryNext: _window.Operations.HistoryNext(); return(VSConstants.S_OK); case CommandIds.HistoryPrevious: _window.Operations.HistoryPrevious(); return(VSConstants.S_OK); case CommandIds.ClearScreen: _window.Operations.ClearView(); return(VSConstants.S_OK); case CommandIds.SearchHistoryNext: _window.Operations.HistorySearchNext(); return(VSConstants.S_OK); case CommandIds.SearchHistoryPrevious: _window.Operations.HistorySearchPrevious(); return(VSConstants.S_OK); } } else if (pguidCmdGroup == VSConstants.VSStd2K) { switch ((VSConstants.VSStd2KCmdID)nCmdID) { case VSConstants.VSStd2KCmdID.TYPECHAR: _window.Operations.Delete(); break; case VSConstants.VSStd2KCmdID.RETURN: if (_window.Operations.TrySubmitStandardInput()) { return(VSConstants.S_OK); } break; case VSConstants.VSStd2KCmdID.SHOWCONTEXTMENU: ShowContextMenu(); return(VSConstants.S_OK); } } else if (currentBufferCommandHandler != null && pguidCmdGroup == VSConstants.GUID_VSStandardCommandSet97) { // undo/redo support: switch ((VSConstants.VSStd97CmdID)nCmdID) { case VSConstants.VSStd97CmdID.Undo: case VSConstants.VSStd97CmdID.MultiLevelUndo: case VSConstants.VSStd97CmdID.MultiLevelUndoList: case VSConstants.VSStd97CmdID.Redo: case VSConstants.VSStd97CmdID.MultiLevelRedo: case VSConstants.VSStd97CmdID.MultiLevelRedoList: return(currentBufferCommandHandler.Exec(ref pguidCmdGroup, nCmdID, nCmdexecopt, pvaIn, pvaOut)); } } int res = nextTarget.Exec(ref pguidCmdGroup, nCmdID, nCmdexecopt, pvaIn, pvaOut); #if DUMP_COMMANDS DumpCmd("Exec", result, ref pguidCmdGroup, nCmdID, 0); #endif return(res); }
public int Exec(ref Guid pguidCmdGroup, uint nCmdID, uint nCmdexecopt, IntPtr pvaIn, IntPtr pvaOut) { char typedChar = char.MinValue; int result = VSConstants.S_OK; Guid cmdGroup = pguidCmdGroup; ThreadHelper.ThrowIfNotOnUIThread(); // 1. Pre-process if (XSettings.DisableParameterInfo) { ; } else if (pguidCmdGroup == VSConstants.VSStd2K) { switch (nCmdID) { case (int)VSConstants.VSStd2KCmdID.PARAMINFO: StartSignatureSession(true); break; case (int)VSConstants.VSStd2KCmdID.COMPLETEWORD: case (int)VSConstants.VSStd2KCmdID.AUTOCOMPLETE: case (int)VSConstants.VSStd2KCmdID.SHOWMEMBERLIST: CancelSignatureSession(); break; case (int)VSConstants.VSStd2KCmdID.BACKSPACE: if (_signatureSession != null) { int pos = _textView.Caret.Position.BufferPosition; if (pos > 0) { // get previous char var previous = _textView.TextBuffer.CurrentSnapshot.GetText().Substring(pos - 1, 1); if (previous == "(" || previous == "{") { _signatureSession.Dismiss(); } } } break; } } else if (pguidCmdGroup == VSConstants.GUID_VSStandardCommandSet97) { switch (nCmdID) { case (int)VSConstants.VSStd97CmdID.Undo: case (int)VSConstants.VSStd97CmdID.Redo: CancelSignatureSession(); break; } } var completionActive = IsCompletionActive(); // 2. Let others do their thing result = m_nextCommandHandler.Exec(ref cmdGroup, nCmdID, nCmdexecopt, pvaIn, pvaOut); // 3. Post process if (ErrorHandler.Succeeded(result) && !XSettings.DisableParameterInfo) { if (pguidCmdGroup == VSConstants.VSStd2K) { switch (nCmdID) { case (int)VSConstants.VSStd2KCmdID.TYPECHAR: typedChar = (char)(ushort)Marshal.GetObjectForNativeVariant(pvaIn); switch (typedChar) { case '(': case '{': CancelSignatureSession(); StartSignatureSession(false, triggerchar: typedChar); break; case ')': case '}': CancelSignatureSession(); if (hasopenSignatureSession()) { StartSignatureSession(false, triggerchar: typedChar); } break; case ',': StartSignatureSession(true, triggerchar: typedChar); //MoveSignature(); break; case ':': case '.': CancelSignatureSession(); break; } break; case (int)VSConstants.VSStd2KCmdID.RETURN: if (!completionActive) { CancelSignatureSession(); } break; case (int)VSConstants.VSStd2KCmdID.LEFT: case (int)VSConstants.VSStd2KCmdID.RIGHT: MoveSignature(); break; } } } return(result); }
public int Exec(ref Guid pguidCmdGroup, uint nCmdID, uint nCmdexecopt, IntPtr pvaIn, IntPtr pvaOut) { ThreadHelper.ThrowIfNotOnUIThread(); if (VsShellUtilities.IsInAutomationFunction(_provider.ServiceProvider)) { return(_nextCommandHandler.Exec(ref pguidCmdGroup, nCmdID, nCmdexecopt, pvaIn, pvaOut)); } if (IsStringOrComment()) { this.Cancel(); return(_nextCommandHandler.Exec(ref pguidCmdGroup, nCmdID, nCmdexecopt, pvaIn, pvaOut)); } int retVal = VSConstants.S_OK; bool itIsCompletionSession = false; uint commandID = nCmdID; //make a copy of this so we can look at it after forwarding some commands char typedChar = char.MinValue; if (pguidCmdGroup == VSConstants.VSStd2K) { switch ((VSConstants.VSStd2KCmdID)nCmdID) { case VSConstants.VSStd2KCmdID.AUTOCOMPLETE: case VSConstants.VSStd2KCmdID.COMPLETEWORD: itIsCompletionSession = this.StartSession(); break; case VSConstants.VSStd2KCmdID.RETURN: //commit char case VSConstants.VSStd2KCmdID.TAB: //commit char itIsCompletionSession = this.Commit(); break; case VSConstants.VSStd2KCmdID.CANCEL: itIsCompletionSession = this.Cancel(); break; case VSConstants.VSStd2KCmdID.TYPECHAR: typedChar = (char)(ushort)Marshal.GetObjectForNativeVariant(pvaIn); if (char.IsWhiteSpace(typedChar) || NotLetter(typedChar)) { itIsCompletionSession = this.Cancel(); } break; } } if (!itIsCompletionSession) // pass along the command so the char is added to the buffer { retVal = _nextCommandHandler.Exec(ref pguidCmdGroup, nCmdID, nCmdexecopt, pvaIn, pvaOut); } switch ((VSConstants.VSStd2KCmdID)nCmdID) { case VSConstants.VSStd2KCmdID.TYPECHAR: if (!NotLetter(typedChar) && !char.IsWhiteSpace(typedChar)) { if (_currentSession == null || _currentSession.IsDismissed) // If there is no active session, bring up completion { if (StartSession()) { _currentSession.Filter(); } } else //the completion session is already active, so just filter { _currentSession.Filter(); } itIsCompletionSession = true; } break; case VSConstants.VSStd2KCmdID.BACKSPACE: case VSConstants.VSStd2KCmdID.DELETE: // redo the filter if there is a deletion if (_currentSession != null && !_currentSession.IsDismissed) { _currentSession.Filter(); } itIsCompletionSession = true; break; } if (itIsCompletionSession) { return(VSConstants.S_OK); } return(retVal); }
/// <summary> /// Called from VS when we should handle a command or pass it on. /// </summary> public int Exec(ref Guid pguidCmdGroup, uint nCmdID, uint nCmdexecopt, IntPtr pvaIn, IntPtr pvaOut) { return(_next.Exec(pguidCmdGroup, nCmdID, nCmdexecopt, pvaIn, pvaOut)); }
/// <summary> /// Called from VS when we should handle a command or pass it on. /// </summary> public int Exec(ref Guid pguidCmdGroup, uint nCmdID, uint nCmdexecopt, IntPtr pvaIn, IntPtr pvaOut) { if (IntellisenseControllerProvider.Instance != null && IntellisenseControllerProvider.Instance.GeneroCommandTarget != null && pguidCmdGroup == IntellisenseControllerProvider.Instance.GeneroCommandTarget.PackageGuid) { if (_textView != null && _textView.TextBuffer != null) { string path = _textView.TextBuffer.GetFilePath(); if (IntellisenseControllerProvider.Instance.GeneroCommandTarget.Exec(path, nCmdID)) { return(VSConstants.S_OK); } } } // preprocessing if (pguidCmdGroup == VSConstants.GUID_VSStandardCommandSet97) { switch ((VSConstants.VSStd97CmdID)nCmdID) { case VSConstants.VSStd97CmdID.Paste: //PythonReplEvaluator eval; //if (_textView.Properties.TryGetProperty(typeof(PythonReplEvaluator), out eval)) //{ // string pasting = eval.FormatClipboard() ?? Clipboard.GetText(); // if (pasting != null) // { // PasteReplCode(eval, pasting); // return VSConstants.S_OK; // } //} //else //{ // string updated = RemoveReplPrompts(_textView.Options.GetNewLineCharacter()); // if (updated != null) // { // _editorOps.ReplaceSelection(updated); // return VSConstants.S_OK; // } //} break; case VSConstants.VSStd97CmdID.GotoDefn: return(GotoDefinition()); case VSConstants.VSStd97CmdID.FindReferences: return(FindAllReferences()); } } else if (pguidCmdGroup == VSGeneroConstants.Std2KCmdGroupGuid) { OutliningTaggerProvider.OutliningTagger tagger; IntellisenseController controller = null; switch ((VSConstants.VSStd2KCmdID)nCmdID) { case (VSConstants.VSStd2KCmdID) 147: // ECMD_SMARTTASKS defined in stdidcmd.h, but not in MPF // if the user is typing to fast for us to update the smart tags on the idle event // then we want to update them before VS pops them up. UpdateSmartTags(); break; //case VSConstants.VSStd2KCmdID.FORMATDOCUMENT: // FormatCode(new SnapshotSpan(_textView.TextBuffer.CurrentSnapshot, 0, _textView.TextBuffer.CurrentSnapshot.Length), false); // return VSConstants.S_OK; case VSConstants.VSStd2KCmdID.FORMATSELECTION: if (_textView != null) { FormatCode(_textView.Selection.StreamSelectionSpan.SnapshotSpan, true); } return(VSConstants.S_OK); case VSConstants.VSStd2KCmdID.SHOWMEMBERLIST: case VSConstants.VSStd2KCmdID.COMPLETEWORD: if (_textView != null) { controller = _textView.Properties.GetProperty <IntellisenseController>(typeof(IntellisenseController)); if (controller != null) { IntellisenseController.ForceCompletions = true; try { controller.TriggerCompletionSession((VSConstants.VSStd2KCmdID)nCmdID == VSConstants.VSStd2KCmdID.COMPLETEWORD, (VSConstants.VSStd2KCmdID)nCmdID == VSConstants.VSStd2KCmdID.SHOWMEMBERLIST); } finally { IntellisenseController.ForceCompletions = false; } return(VSConstants.S_OK); } } break; case VSConstants.VSStd2KCmdID.QUICKINFO: if (_textView != null) { controller = _textView.Properties.GetProperty <IntellisenseController>(typeof(IntellisenseController)); if (controller != null) { controller.TriggerQuickInfo(); return(VSConstants.S_OK); } } break; case VSConstants.VSStd2KCmdID.PARAMINFO: if (_textView != null) { controller = _textView.Properties.GetProperty <IntellisenseController>(typeof(IntellisenseController)); if (controller != null) { controller.TriggerSignatureHelp(); return(VSConstants.S_OK); } } break; case VSConstants.VSStd2KCmdID.OUTLN_STOP_HIDING_ALL: tagger = _textView.GetOutliningTagger(); tagger?.Disable(); // let VS get the event as well break; case VSConstants.VSStd2KCmdID.OUTLN_START_AUTOHIDING: tagger = _textView.GetOutliningTagger(); tagger?.Enable(); // let VS get the event as well break; case VSConstants.VSStd2KCmdID.COMMENT_BLOCK: case VSConstants.VSStd2KCmdID.COMMENTBLOCK: if (VSGenero.EditorExtensions.EditorExtensions.CommentOrUncommentBlock(_textView, comment: true)) { return(VSConstants.S_OK); } break; case VSConstants.VSStd2KCmdID.UNCOMMENT_BLOCK: case VSConstants.VSStd2KCmdID.UNCOMMENTBLOCK: if (VSGenero.EditorExtensions.EditorExtensions.CommentOrUncommentBlock(_textView, comment: false)) { return(VSConstants.S_OK); } break; case VSConstants.VSStd2KCmdID.EXTRACTMETHOD: ExtractMethod(); return(VSConstants.S_OK); case VSConstants.VSStd2KCmdID.RENAME: RefactorRename(); return(VSConstants.S_OK); } } try { return(_next.Exec(pguidCmdGroup, nCmdID, nCmdexecopt, pvaIn, pvaOut)); } catch (Exception ex) { return(VSConstants.S_FALSE); } }
public int Exec(ref Guid pguidCmdGroup, uint nCmdID, uint nCmdexecopt, IntPtr pvaIn, IntPtr pvaOut) { uint cmdID = nCmdID; char typedChar = char.MinValue; if (pguidCmdGroup == VSConstants.VSStd2K && nCmdID == (uint)VSConstants.VSStd2KCmdID.TYPECHAR) { typedChar = (char)(ushort)Marshal.GetObjectForNativeVariant(pvaIn); } if (nCmdID == (uint)VSConstants.VSStd2KCmdID.RETURN || cmdID == (uint)VSConstants.VSStd2KCmdID.TAB) { if (completionSession != null && !completionSession.IsDismissed) { if (completionSession.SelectedCompletionSet.SelectionStatus.IsSelected) { completionSession.Commit(); return(VSConstants.S_OK); } else { completionSession.Dismiss(); } } } int returnValue = nextCommandHandler.Exec(pguidCmdGroup, nCmdID, nCmdexecopt, pvaIn, pvaOut); bool isHandled = false; if (!typedChar.Equals(char.MinValue)) { if (completionSession == null || completionSession.IsDismissed) { TriggerCompletion(); if (completionSession != null) { completionSession.Filter(); } } else { completionSession.Filter(); } isHandled = true; } else if (cmdID == (uint)VSConstants.VSStd2KCmdID.BACKSPACE || cmdID == (uint)VSConstants.VSStd2KCmdID.DELETE) { if (completionSession != null && !completionSession.IsDismissed) { completionSession.Filter(); } isHandled = true; } if (isHandled) { return(VSConstants.S_OK); } return(returnValue); }
int IOleCommandTarget.Exec(ref Guid pguidCmdGroup, uint nCmdID, uint nCmdexecopt, IntPtr pvaIn, IntPtr pvaOut) { return(_commandTarget.Exec(ref pguidCmdGroup, nCmdID, nCmdexecopt, pvaIn, pvaOut)); }
public int Exec(ref Guid pguidCmdGroup, uint nCmdID, uint nCmdexecopt, IntPtr pvaIn, IntPtr pvaOut) { if (pguidCmdGroup == VSConstants.VSStd2K && nCmdID == (int)VSConstants.VSStd2KCmdID.TYPECHAR) { var ch = (char)(ushort)System.Runtime.InteropServices.Marshal.GetObjectForNativeVariant(pvaIn); if (_activeSession != null && !_activeSession.IsDismissed) { if (_activeSession.SelectedCompletionSet.SelectionStatus.IsSelected) { var completion = _activeSession.SelectedCompletionSet.SelectionStatus.Completion; string committedBy = String.Empty; if (_activeSession.SelectedCompletionSet.Moniker == CompletionSource.NodejsRequireCompletionSetMoniker) { if (completion.InsertionText.StartsWith("'")) // require( { committedBy = ")"; } else if (completion.InsertionText.EndsWith("'")) // require(' { committedBy = "'"; } else if (completion.InsertionText.EndsWith("\"")) // require(" { committedBy = "\""; } } else { committedBy = NodejsPackage.Instance != null && NodejsPackage.Instance.IntellisenseOptionsPage.OnlyTabOrEnterToCommit ? string.Empty : NodejsConstants.DefaultIntellisenseCompletionCommittedBy; } if (committedBy.IndexOf(ch) != -1) { _activeSession.Commit(); if ((completion.InsertionText.EndsWith("'") && ch == '\'') || (completion.InsertionText.EndsWith("\"") && ch == '"')) { // https://nodejstools.codeplex.com/workitem/960 // ' triggers the completion, but we don't want to insert the quote. return(VSConstants.S_OK); } } } else if (_activeSession.SelectedCompletionSet.Moniker.Equals(CompletionSource.NodejsRequireCompletionSetMoniker) && !IsRequireIdentifierChar(ch)) { _activeSession.Dismiss(); } else if (!_activeSession.SelectedCompletionSet.Moniker.Equals(CompletionSource.NodejsRequireCompletionSetMoniker) && !IsIdentifierChar(ch)) { _activeSession.Dismiss(); } } int res = _oldTarget.Exec(ref pguidCmdGroup, nCmdID, nCmdexecopt, pvaIn, pvaOut); if (_activeSession == null || !_activeSession.SelectedCompletionSet.Moniker.Equals(CompletionSource.NodejsRequireCompletionSetMoniker)) { //Only process the char if we are not in a require completion HandleChar((char)(ushort)System.Runtime.InteropServices.Marshal.GetObjectForNativeVariant(pvaIn)); } if (_activeSession != null && !_activeSession.IsDismissed) { _activeSession.Filter(); } return(res); } if (_activeSession != null) { if (pguidCmdGroup == VSConstants.VSStd2K) { switch ((VSConstants.VSStd2KCmdID)nCmdID) { case VSConstants.VSStd2KCmdID.RETURN: if (/*NodejsPackage.Instance.AdvancedEditorOptionsPage.EnterCommitsIntellisense*/ true && !_activeSession.IsDismissed && _activeSession.SelectedCompletionSet.SelectionStatus.IsSelected) { // If the user has typed all of the characters as the completion and presses // enter we should dismiss & let the text editor receive the enter. For example // when typing "import sys[ENTER]" completion starts after the space. After typing // sys the user wants a new line and doesn't want to type enter twice. bool enterOnComplete = /*NodejsPackage.Instance.AdvancedEditorOptionsPage.AddNewLineAtEndOfFullyTypedWord*/ true && EnterOnCompleteText(); _activeSession.Commit(); if (!enterOnComplete) { return(VSConstants.S_OK); } } else { _activeSession.Dismiss(); } break; case VSConstants.VSStd2KCmdID.TAB: if (!_activeSession.IsDismissed) { _activeSession.Commit(); return(VSConstants.S_OK); } break; case VSConstants.VSStd2KCmdID.BACKSPACE: case VSConstants.VSStd2KCmdID.DELETE: case VSConstants.VSStd2KCmdID.DELETEWORDLEFT: case VSConstants.VSStd2KCmdID.DELETEWORDRIGHT: int res = _oldTarget.Exec(ref pguidCmdGroup, nCmdID, nCmdexecopt, pvaIn, pvaOut); if (_activeSession != null && !_activeSession.IsDismissed) { _activeSession.Filter(); } return(res); } } } else if (_sigHelpSession != null) { if (pguidCmdGroup == VSConstants.VSStd2K) { switch ((VSConstants.VSStd2KCmdID)nCmdID) { case VSConstants.VSStd2KCmdID.BACKSPACE: bool fDeleted = Backspace(); if (fDeleted) { return(VSConstants.S_OK); } break; case VSConstants.VSStd2KCmdID.LEFT: _editOps.MoveToPreviousCharacter(false); UpdateCurrentParameter(); return(VSConstants.S_OK); case VSConstants.VSStd2KCmdID.RIGHT: _editOps.MoveToNextCharacter(false); UpdateCurrentParameter(); return(VSConstants.S_OK); case VSConstants.VSStd2KCmdID.HOME: case VSConstants.VSStd2KCmdID.BOL: case VSConstants.VSStd2KCmdID.BOL_EXT: case VSConstants.VSStd2KCmdID.EOL: case VSConstants.VSStd2KCmdID.EOL_EXT: case VSConstants.VSStd2KCmdID.END: case VSConstants.VSStd2KCmdID.WORDPREV: case VSConstants.VSStd2KCmdID.WORDPREV_EXT: case VSConstants.VSStd2KCmdID.DELETEWORDLEFT: _sigHelpSession.Dismiss(); _sigHelpSession = null; break; } } } if (pguidCmdGroup == VSConstants.VSStd2K) { switch ((VSConstants.VSStd2KCmdID)nCmdID) { case VSConstants.VSStd2KCmdID.QUICKINFO: TriggerQuickInfo(); return(VSConstants.S_OK); case VSConstants.VSStd2KCmdID.PARAMINFO: TriggerSignatureHelp(); return(VSConstants.S_OK); case VSConstants.VSStd2KCmdID.RETURN: if (_expansionMgr != null && _expansionClient.InSession && ErrorHandler.Succeeded(_expansionClient.EndCurrentExpansion(false))) { return(VSConstants.S_OK); } break; case VSConstants.VSStd2KCmdID.TAB: if (_expansionMgr != null && _expansionClient.InSession && ErrorHandler.Succeeded(_expansionClient.NextField())) { return(VSConstants.S_OK); } if (_textView.Selection.IsEmpty && _textView.Caret.Position.BufferPosition > 0) { if (TryTriggerExpansion()) { return(VSConstants.S_OK); } } break; case VSConstants.VSStd2KCmdID.BACKTAB: if (_expansionMgr != null && _expansionClient.InSession && ErrorHandler.Succeeded(_expansionClient.PreviousField())) { return(VSConstants.S_OK); } break; case VSConstants.VSStd2KCmdID.SURROUNDWITH: case VSConstants.VSStd2KCmdID.INSERTSNIPPET: TriggerSnippet(nCmdID); return(VSConstants.S_OK); case VSConstants.VSStd2KCmdID.SHOWMEMBERLIST: case VSConstants.VSStd2KCmdID.COMPLETEWORD: ForceCompletions = true; try { TriggerCompletionSession((VSConstants.VSStd2KCmdID)nCmdID == VSConstants.VSStd2KCmdID.COMPLETEWORD && !NodejsPackage.Instance.IntellisenseOptionsPage.OnlyTabOrEnterToCommit); } finally { ForceCompletions = false; } return(VSConstants.S_OK); } } return(_oldTarget.Exec(ref pguidCmdGroup, nCmdID, nCmdexecopt, pvaIn, pvaOut)); }
public int Exec(ref Guid pguidCmdGroup, uint nCmdID, uint nCmdexecopt, IntPtr pvaIn, IntPtr pvaOut) { if (VsShellUtilities.IsInAutomationFunction(_provider.ServiceProvider)) { return(_nextCommandHandler.Exec(ref pguidCmdGroup, nCmdID, nCmdexecopt, pvaIn, pvaOut)); } //make a copy of this so we can look at it after forwarding some commands uint commandID = nCmdID; char typedChar = char.MinValue; //make sure the input is a char before getting it if (pguidCmdGroup == VSConstants.VSStd2K && nCmdID == (uint)VSConstants.VSStd2KCmdID.TYPECHAR) { typedChar = (char)(ushort)Marshal.GetObjectForNativeVariant(pvaIn); } if (typedChar == '.') { Console.WriteLine(); } //check for a commit character if (nCmdID == (uint)VSConstants.VSStd2KCmdID.RETURN || nCmdID == (uint)VSConstants.VSStd2KCmdID.TAB || (char.IsWhiteSpace(typedChar) || char.IsPunctuation(typedChar))) { //check for a a selection if (_session != null && !_session.IsDismissed) { //if the selection is fully selected, commit the current session if (_session.SelectedCompletionSet.SelectionStatus.IsSelected) { var completion = _session.SelectedCompletionSet.SelectionStatus.Completion; if (completion.InsertionText != null && typedChar != ':' && (typedChar != '.' || !completion.InsertionText.Contains('.'))) { _session.Commit(); if (completion.Properties.ContainsProperty("RecommendedCursorOffset")) { int offset = (int)completion.Properties["RecommendedCursorOffset"]; var currp = _textView.Caret.Position.BufferPosition; var newp = currp - (completion.InsertionText.Length - offset); _textView.Caret.MoveTo(newp); } //also, don't add the character to the buffer return(VSConstants.S_OK); } else { nCmdID = (uint)VSConstants.VSStd2KCmdID.COMPLETEWORD; } } else { //if there is no selection, dismiss the session _session.Dismiss(); } } } //pass along the command so the char is added to the buffer int retVal = VSConstants.S_OK; bool handled = false; if (nCmdID == (uint)VSConstants.VSStd2KCmdID.COMPLETEWORD || (!typedChar.Equals(char.MinValue) && (char.IsLetterOrDigit(typedChar) || typedChar == '<' || typedChar == ' ' || typedChar == '.' || typedChar == ':'))) { if (typedChar != '\0') { if (typedChar == '.' || typedChar == ':' || typedChar == '<') { if (!_textView.Selection.IsEmpty) { foreach (var span in _textView.Selection.SelectedSpans.OrderByDescending(x => x.Start)) { _textView.TextBuffer.Replace(span, ""); } } _textView.TextBuffer.Insert(_textView.Caret.Position.BufferPosition.Position, typedChar.ToString()); } else { retVal = _realCommandHandler.Exec(ref pguidCmdGroup, nCmdID, nCmdexecopt, pvaIn, pvaOut); } } if (_session == null || _session.IsDismissed) // If there is no active session, bring up completion { TriggerCompletion(); if (typedChar != '<' && typedChar != 0 && _session != null) { _session.Filter(); } } else { _session.Filter(); } handled = true; } else if (commandID == (uint)VSConstants.VSStd2KCmdID.BACKSPACE || //redo the filter if there is a deletion commandID == (uint)VSConstants.VSStd2KCmdID.DELETE) { if (_session != null && !_session.IsDismissed) { _session.Filter(); } retVal = _nextCommandHandler.Exec(ref pguidCmdGroup, nCmdID, nCmdexecopt, pvaIn, pvaOut); handled = true; } else { retVal = _nextCommandHandler.Exec(ref pguidCmdGroup, nCmdID, nCmdexecopt, pvaIn, pvaOut); } if (handled) { return(VSConstants.S_OK); } return(retVal); }
public int Exec(ref Guid pguidCmdGroup, uint nCmdID, uint nCmdexecopt, IntPtr pvaIn, IntPtr pvaOut) { if (VsShellUtilities.IsInAutomationFunction(_provider.ServiceProvider)) { return(_nextCommandHandler.Exec(ref pguidCmdGroup, nCmdID, nCmdexecopt, pvaIn, pvaOut)); } uint commandID = nCmdID; char typedChar = char.MinValue; if (pguidCmdGroup == VSConstants.VSStd2K && nCmdID == (uint)VSConstants.VSStd2KCmdID.TYPECHAR) { typedChar = (char)(ushort)Marshal.GetObjectForNativeVariant(pvaIn); } // return and tab command commit the session and return if (nCmdID == (uint)VSConstants.VSStd2KCmdID.RETURN || nCmdID == (uint)VSConstants.VSStd2KCmdID.TAB) { if (_session != null && !_session.IsDismissed) { if (_session.SelectedCompletionSet.SelectionStatus.IsSelected) { _session.Commit(); return(VSConstants.S_OK); } else { _session.Dismiss(); } } } // whitespace and punctuation commit the session if (char.IsWhiteSpace(typedChar) || char.IsPunctuation(typedChar)) { if (_session != null && !_session.IsDismissed) { if (_session.SelectedCompletionSet.SelectionStatus.IsSelected) { _session.Commit(); } else { _session.Dismiss(); } } } int retVal = _nextCommandHandler.Exec(ref pguidCmdGroup, nCmdID, nCmdexecopt, pvaIn, pvaOut); bool handled = false; if (!typedChar.Equals(char.MinValue) && char.IsLetterOrDigit(typedChar)) { if (_session == null || _session.IsDismissed) { this.TriggerCompletion(); if (_session != null) { _session.Filter(); } } else { _session.Filter(); } handled = true; } else if (commandID == (uint)VSConstants.VSStd2KCmdID.BACKSPACE || commandID == (uint)VSConstants.VSStd2KCmdID.DELETE) { if (_session != null && _session.IsDismissed) { _session.Filter(); } handled = true; } if (handled) { return(VSConstants.S_OK); } return(retVal); }
/// <summary> /// Main method used to determine how to handle keystrokes within a ITextBuffer. /// </summary> /// <param name="pguidCmdGroup">The GUID of the command group.</param> /// <param name="nCmdId">The command ID.</param> /// <param name="nCmdexecopt"> /// Specifies how the object should execute the command. Possible values are taken from the /// Microsoft.VisualStudio.OLE.Interop.OLECMDEXECOPT and Microsoft.VisualStudio.OLE.Interop.OLECMDID_WINDOWSTATE_FLAG /// enumerations. /// </param> /// <param name="pvaIn">The input arguments of the command.</param> /// <param name="pvaOut">The output arguments of the command.</param> /// <returns></returns> public int Exec(ref Guid pguidCmdGroup, uint nCmdId, uint nCmdexecopt, IntPtr pvaIn, IntPtr pvaOut) { bool?isInStringArea = null; var command = (VSConstants.VSStd2KCmdID)nCmdId; if (VsShellUtilities.IsInAutomationFunction(_serviceProvider) || IsUnhandledCommand(pguidCmdGroup, command) || Utilities.IsCaretInCommentArea(_textView)) { Log.DebugFormat("Non-VSStd2K command: '{0}'", ToCommandName(pguidCmdGroup, nCmdId)); return(NextCommandHandler.Exec(ref pguidCmdGroup, nCmdId, nCmdexecopt, pvaIn, pvaOut)); } //make a copy of this so we can look at it after forwarding some commands var typedChar = char.MinValue; // Exit tab complete session if command is any recognized command other than tab if (_tabCompleteSession != null && command != VSConstants.VSStd2KCmdID.TAB && command != VSConstants.VSStd2KCmdID.BACKTAB) { _tabCompleteSession = null; _startTabComplete = false; } //make sure the input is a char before getting it if (command == VSConstants.VSStd2KCmdID.TYPECHAR) { typedChar = (char)(ushort)Marshal.GetObjectForNativeVariant(pvaIn); Log.DebugFormat("Typed Character: '{0}'", (typedChar == char.MinValue) ? "<null>" : typedChar.ToString()); if (_activeSession == null && IsNotIntelliSenseTriggerWhenInStringLiteral(typedChar)) { isInStringArea = this.IsInStringArea(isInStringArea); if (isInStringArea == true) { return(NextCommandHandler.Exec(ref pguidCmdGroup, nCmdId, nCmdexecopt, pvaIn, pvaOut)); } } } else { Log.DebugFormat("Non-TypeChar command: '{0}'", ToCommandName(pguidCmdGroup, nCmdId)); } switch (command) { case VSConstants.VSStd2KCmdID.RETURN: //check for a a selection if (_activeSession != null && !_activeSession.IsDismissed) { //if the selection is fully selected, commit the current session if (_activeSession.SelectedCompletionSet.SelectionStatus.IsSelected) { Log.Debug("Commit"); _activeSession.Commit(); //also, don't add the character to the buffer return(VSConstants.S_OK); } else { Log.Debug("Dismiss"); //if there is no selection, dismiss the session _activeSession.Dismiss(); } } break; case VSConstants.VSStd2KCmdID.TAB: case VSConstants.VSStd2KCmdID.BACKTAB: if (_activeSession != null && !_activeSession.IsDismissed) { var completions = _activeSession.SelectedCompletionSet.Completions; if (completions != null && completions.Count > 0) { var startPoint = _activeSession.SelectedCompletionSet.ApplicableTo.GetStartPoint(_textView.TextBuffer.CurrentSnapshot).Position; _tabCompleteSession = new TabCompleteSession(_activeSession.SelectedCompletionSet.Completions, _activeSession.SelectedCompletionSet.SelectionStatus, startPoint); _activeSession.Commit(); //also, don't add the character to the buffer return(VSConstants.S_OK); } else { Log.Debug("Dismiss"); //If there are no completions, dismiss the session _activeSession.Dismiss(); } } else if (_tabCompleteSession != null) { if (command == VSConstants.VSStd2KCmdID.TAB) { _tabCompleteSession.ReplaceWithNextCompletion(_textView.TextBuffer, _textView.Caret.Position.BufferPosition.Position); } else { _tabCompleteSession.ReplaceWithPreviousCompletion(_textView.TextBuffer, _textView.Caret.Position.BufferPosition.Position); } //don't add the character to the buffer return(VSConstants.S_OK); } else if (!Utilities.IsPrecedingTextInLineEmpty(_textView.Caret.Position.BufferPosition) && _textView.Selection.IsEmpty) { _startTabComplete = true; TriggerCompletion(); //don't add the character to the buffer return(VSConstants.S_OK); } break; case VSConstants.VSStd2KCmdID.COMPLETEWORD: isInStringArea = this.IsInStringArea(isInStringArea); if (isInStringArea == true) { return(NextCommandHandler.Exec(ref pguidCmdGroup, nCmdId, nCmdexecopt, pvaIn, pvaOut)); } TriggerCompletion(); return(VSConstants.S_OK); default: break; } //check for a commit character if (char.IsWhiteSpace(typedChar) && _activeSession != null && !_activeSession.IsDismissed) { // If user is typing a variable, SPACE shouldn't commit the selection. // If the selection is fully matched with user's input, commit the current session and add the commit character to text buffer. if (_activeSession.SelectedCompletionSet.SelectionStatus.IsSelected && !_activeSession.SelectedCompletionSet.SelectionStatus.Completion.InsertionText.StartsWith("$", StringComparison.InvariantCulture)) { Log.Debug("Commit"); _activeSession.Commit(); bool isCompletionFullyMatched = false; _textView.TextBuffer.Properties.TryGetProperty(BufferProperties.SessionCompletionFullyMatchedStatus, out isCompletionFullyMatched); if (isCompletionFullyMatched) { // If user types all characters in a completion and click Space, then we should commit the selection and add the Space into text buffer. return(NextCommandHandler.Exec(ref pguidCmdGroup, nCmdId, nCmdexecopt, pvaIn, pvaOut)); } //Don't add the character to the buffer if this commits the selection. return(VSConstants.S_OK); } else { Log.Debug("Dismiss"); //if there is no selection, dismiss the session _activeSession.Dismiss(); } } bool justCommitIntelliSense = false; if (IsIntelliSenseTriggerDot(typedChar) && _activeSession != null && !_activeSession.IsDismissed) { var selectionStatus = _activeSession.SelectedCompletionSet.SelectionStatus; if (selectionStatus.IsSelected) { // If user types the full completion text, which ends with a dot, then we should just commit IntelliSense session ignore user's last typing. ITrackingSpan lastWordSpan; var currentSnapshot = _textView.TextBuffer.CurrentSnapshot; _textView.TextBuffer.Properties.TryGetProperty <ITrackingSpan>(BufferProperties.LastWordReplacementSpan, out lastWordSpan); if (lastWordSpan != null) { string lastWordText = lastWordSpan.GetText(currentSnapshot); int completionSpanStart = lastWordSpan.GetStartPoint(currentSnapshot); int completionSpanEnd = _textView.Caret.Position.BufferPosition; var completionText = currentSnapshot.GetText(completionSpanStart, completionSpanEnd - completionSpanStart); completionText += typedChar; Log.DebugFormat("completionSpanStart: {0}", completionSpanStart); Log.DebugFormat("completionSpanEnd: {0}", completionSpanEnd); Log.DebugFormat("completionText: {0}", completionText); if (selectionStatus.Completion.InsertionText.Equals(completionText, StringComparison.OrdinalIgnoreCase)) { Log.Debug(String.Format("Commited by {0}", typedChar)); _activeSession.Commit(); return(VSConstants.S_OK); } } Log.Debug("Commit"); _activeSession.Commit(); justCommitIntelliSense = true; } else { Log.Debug("Dismiss"); //if there is no selection, dismiss the session _activeSession.Dismiss(); } } // Check the char at caret before pass along the command // If command is backspace and completion session is active, then we need to see if the char to be deleted is an IntelliSense triggering char // If yes, then after deleting the char, we also dismiss the completion session // Otherwise, just filter the completion lists char charAtCaret = char.MinValue; if (command == VSConstants.VSStd2KCmdID.BACKSPACE && _activeSession != null && !_activeSession.IsDismissed) { int caretPosition = _textView.Caret.Position.BufferPosition.Position - 1; if (caretPosition >= 0) { // caretPosition == -1 means caret is at the beginning of a file, which means no characters before it. ITrackingPoint caretCharPosition = _textView.TextSnapshot.CreateTrackingPoint(caretPosition, PointTrackingMode.Positive); charAtCaret = caretCharPosition.GetCharacter(_textView.TextSnapshot); } } // pass along the command so the char is added to the buffer int retVal = NextCommandHandler.Exec(ref pguidCmdGroup, nCmdId, nCmdexecopt, pvaIn, pvaOut); bool handled = false; if (IsIntellisenseTrigger(typedChar) || (justCommitIntelliSense || (IsIntelliSenseTriggerDot(typedChar) && IsPreviousTokenVariable())) || // If dot just commit a session or previous token before a dot was a variable, trigger intellisense (char.IsWhiteSpace(typedChar) && IsPreviousTokenParameter())) // If the previous token before a space was a parameter, trigger intellisense { isInStringArea = this.IsInStringArea(isInStringArea); if (isInStringArea == false) { TriggerCompletion(); } } if (!typedChar.Equals(char.MinValue) && IsFilterTrigger(typedChar)) { if (_activeSession != null) { if (_activeSession.IsStarted) { try { Log.Debug("Filter"); _activeSession.Filter(); } catch (Exception ex) { Log.Debug("Failed to filter session.", ex); } } } } else if (command == VSConstants.VSStd2KCmdID.BACKSPACE || command == VSConstants.VSStd2KCmdID.DELETE) //redo the filter if there is a deletion { if (_activeSession != null && !_activeSession.IsDismissed) { try { if (_textView.Caret.Position.BufferPosition <= _completionCaretPosition) { Log.Debug("Dismiss"); _activeSession.Dismiss(); } else { Log.Debug("Filter"); _activeSession.Filter(); } } catch (Exception ex) { Log.Debug("Failed to filter session.", ex); } } handled = true; } if (handled) { return(VSConstants.S_OK); } return(retVal); }
public static void Backspace(this IOleCommandTarget target) { var guid = VSConstants.VSStd2K; target.Exec(ref guid, (int)VSConstants.VSStd2KCmdID.BACKSPACE, 0, IntPtr.Zero, IntPtr.Zero); }
public int Exec(ref Guid pguidCmdGroup, uint nCmdID, uint nCmdexecopt, IntPtr pvaIn, IntPtr pvaOut) { if (VsShellUtilities.IsInAutomationFunction(m_provider.ServiceProvider)) { return(m_nextCommandHandler.Exec(ref pguidCmdGroup, nCmdID, nCmdexecopt, pvaIn, pvaOut)); } // Make a copy of this so we can look at it after forwarding some commands uint commandID = nCmdID; char typedChar = char.MinValue; // Make sure the input is a char before getting it if (pguidCmdGroup == VSConstants.VSStd2K && nCmdID == (uint)VSConstants.VSStd2KCmdID.TYPECHAR) { typedChar = (char)(ushort)Marshal.GetObjectForNativeVariant(pvaIn); } // Check for a commit character if (nCmdID == (uint)VSConstants.VSStd2KCmdID.RETURN || nCmdID == (uint)VSConstants.VSStd2KCmdID.TAB || char.IsWhiteSpace(typedChar)) { // Check for a a selection if (m_session != null && !m_session.IsDismissed) { // If the selection is fully selected, commit the current session if (m_session.SelectedCompletionSet.SelectionStatus.IsSelected) { m_session.Commit( ); // Also, don't add the character to the buffer return(VSConstants.S_OK); } else { // If there is no selection, dismiss the session m_session.Dismiss( ); } } } //pass along the command so the char is added to the buffer int retVal = m_nextCommandHandler.Exec(ref pguidCmdGroup, nCmdID, nCmdexecopt, pvaIn, pvaOut); bool handled = false; if (!typedChar.Equals(char.MinValue) && (char.IsLetterOrDigit(typedChar) || typedChar == '.')) { if (m_session == null || m_session.IsDismissed) // If there is no active session, bring up completion { if (TriggerCompletion( )) { if (m_session != null) { m_session.Filter( ); } } } else // The completion session is already active, so just filter { m_session.Filter( ); } handled = true; } else if (commandID == (uint)VSConstants.VSStd2KCmdID.BACKSPACE || // Redo the filter if there is a deletion commandID == (uint)VSConstants.VSStd2KCmdID.DELETE) { if (m_session != null && !m_session.IsDismissed) { m_session.Filter( ); } handled = true; } return(handled ? VSConstants.S_OK : retVal); }
public static void ParamInfo(this IOleCommandTarget target) { var guid = VSConstants.VSStd2K; ErrorHandler.ThrowOnFailure(target.Exec(ref guid, (int)VSConstants.VSStd2KCmdID.PARAMINFO, 0, IntPtr.Zero, IntPtr.Zero)); }
public int Exec(ref Guid pguidCmdGroup, uint nCmdID, uint nCmdexecopt, IntPtr pvaIn, IntPtr pvaOut) { ThreadHelper.ThrowIfNotOnUIThread(); if (VsShellUtilities.IsInAutomationFunction(m_provider.ServiceProvider)) { return(m_nextCommandHandler.Exec(ref pguidCmdGroup, nCmdID, nCmdexecopt, pvaIn, pvaOut)); } uint commandID = nCmdID; char typedChar = char.MinValue; if (pguidCmdGroup == VSConstants.VSStd2K && nCmdID == (uint)VSConstants.VSStd2KCmdID.TYPECHAR) { typedChar = (char)(ushort)Marshal.GetObjectForNativeVariant(pvaIn); } VSConstants.VSStd2KCmdID nCmdIDEnum = (VSConstants.VSStd2KCmdID)nCmdID; //System.Console.WriteLine("Keyboard command: " + nCmdIDEnum); if (nCmdID == (uint)VSConstants.VSStd2KCmdID.RETURN || nCmdID == (uint)VSConstants.VSStd2KCmdID.TAB /*|| (char.IsWhiteSpace(typedChar) || char.IsPunctuation(typedChar))*/)//this made auto complete on point or space { if (m_session != null && !m_session.IsDismissed) { if (m_session.SelectedCompletionSet.SelectionStatus.IsSelected) { m_session.Commit(); return(VSConstants.S_OK); } else { m_session.Dismiss(); } } } ThreadHelper.ThrowIfNotOnUIThread(); int retVal = m_nextCommandHandler.Exec(ref pguidCmdGroup, nCmdID, nCmdexecopt, pvaIn, pvaOut); bool handled = false; if (!typedChar.Equals(char.MinValue) && char.IsLetterOrDigit(typedChar) || nCmdIDEnum == VSConstants.VSStd2KCmdID.COMPLETEWORD) { if (m_session == null || m_session.IsDismissed) { TriggerCompletion(); } else { m_session.Filter(); } handled = true; } else if (commandID == (uint)VSConstants.VSStd2KCmdID.BACKSPACE || commandID == (uint)VSConstants.VSStd2KCmdID.DELETE) { if (m_session != null && !m_session.IsDismissed) { m_session.Filter(); } handled = true; } if (handled) { return(VSConstants.S_OK); } return(retVal); }
public static int WrapExec( IOleCommandTarget receiver, IOleCommandTarget implementer, ref System.Guid pguidCmdGroup, uint nCmdID, uint nCmdexecopt, System.IntPtr pvaIn, System.IntPtr pvaOut) { Debug.Assert(receiver != null); var commandId = new CommandID(pguidCmdGroup, (int)nCmdID); if (LogCommand(commandId)) { Logger.LogInfo("WrapExec: => recv={0}, impl={1}, parent={2}", receiver, GetImplementerString(implementer), GetParentTargetString(implementer)); } var hr = (implementer == null) ? (int)Constants.OLECMDERR_E_NOTSUPPORTED : implementer.Exec(ref pguidCmdGroup, nCmdID, nCmdexecopt, pvaIn, pvaOut); // Ensures OleMenuCommandService returns OLECMDERR_E_NOTSUPPORTED. if (hr == VSConstants.S_OK && implementer is OleMenuCommandService) { // Ensure we return OLECMDERR_E_NOTSUPPORTED instead of S_OK if our // command does not support the command id. This is necessary so that // the VS Shell chains the Exec call to other IOleCommandTarget // implementations. var service = (OleMenuCommandService)implementer; var command = service.FindCommand(commandId); if (command != null) { if (!command.Supported) { hr = (int)Constants.OLECMDERR_E_NOTSUPPORTED; } } } if (LogCommand(commandId)) { Logger.LogInfo("WrapExec: <= recv={0}, impl={1}, parent={2}, hr={3}", receiver, GetImplementerString(implementer), GetParentTargetString(implementer), HrToString(hr)); } return hr; }
public int Exec(ref Guid pguidCmdGroup, uint nCmdID, uint nCmdexecopt, IntPtr pvaIn, IntPtr pvaOut) { bool handled = false; int hresult = VSConstants.S_OK; // 1. Pre-process if (pguidCmdGroup == VSConstants.VSStd2K) { switch ((VSConstants.VSStd2KCmdID)nCmdID) { case VSConstants.VSStd2KCmdID.AUTOCOMPLETE: case VSConstants.VSStd2KCmdID.COMPLETEWORD: handled = StartAutoCompleteSession(); break; case VSConstants.VSStd2KCmdID.RETURN: handled = CommitAutoComplete(false); break; case VSConstants.VSStd2KCmdID.TAB: handled = CommitAutoComplete(true); break; case VSConstants.VSStd2KCmdID.CANCEL: handled = CancelAutoComplete(); break; } } if (!handled) { hresult = Next.Exec(pguidCmdGroup, nCmdID, nCmdexecopt, pvaIn, pvaOut); } if (ErrorHandler.Succeeded(hresult)) { if (pguidCmdGroup == VSConstants.VSStd2K) { switch ((VSConstants.VSStd2KCmdID)nCmdID) { case VSConstants.VSStd2KCmdID.TYPECHAR: var ch = GetTypeChar(pvaIn); if (ch == ' ') { StartAutoCompleteSession(); } else { FilterAutoComplete(); } break; case VSConstants.VSStd2KCmdID.BACKSPACE: FilterAutoComplete(); break; } } } return(hresult); }