/// <summary> /// Run the KeyInput through IOleCommandTarget /// </summary> private bool RunInOleCommandTarget(KeyInput keyInput) { var oleCommandData = OleCommandData.Empty; try { // It appears that Visual Studio will not use IOleCommandTarget to process alpha // characters when they are combined with the control key unless they are mapped // to a command. Instead it will just push the input to the window directly. // // TODO: Need to investigate why this is the case. if (Char.IsLetter(keyInput.Char) && keyInput.KeyModifiers == KeyModifiers.Control) { return(false); } Guid commandGroup; if (!OleCommandUtil.TryConvert(keyInput, out commandGroup, out oleCommandData)) { throw new Exception("Couldn't convert the KeyInput into OleCommandData"); } if (!RunQueryStatus(commandGroup, oleCommandData)) { return(false); } RunExec(commandGroup, oleCommandData); return(true); } finally { OleCommandData.Release(ref oleCommandData); } }
public void TryConvert_TextInputToOleCommandData() { var textView = CreateTextView(""); var buffer = Vim.CreateVimBuffer(textView); buffer.SwitchMode(ModeKind.Insert, ModeArgument.None); foreach (var cur in KeyInputUtil.VimKeyInputList) { if (!buffer.InsertMode.IsDirectInsert(cur)) { continue; } var oleCommandData = OleCommandData.Empty; try { Assert.True(OleCommandUtil.TryConvert(cur, out oleCommandData)); // We lose fidelity on these keys because they both get written out as numbers // at this point if (VimKeyUtil.IsKeypadKey(cur.Key)) { continue; } Assert.True(OleCommandUtil.TryConvert(oleCommandData, out KeyInput converted)); Assert.Equal(converted, cur); } finally { oleCommandData.Dispose(); } } }
public void TryConvert_TextInputToOleCommandData() { var textView = EditorUtil.CreateView(""); var buffer = EditorUtil.FactoryService.Vim.CreateBuffer(textView); buffer.SwitchMode(ModeKind.Insert, ModeArgument.None); foreach (var cur in KeyInputUtil.VimKeyInputList) { if (!buffer.InsertMode.IsTextInput(cur)) { continue; } Guid commandGroup; OleCommandData oleCommandData = new OleCommandData(); KeyInput converted; try { Assert.IsTrue(OleCommandUtil.TryConvert(cur, out commandGroup, out oleCommandData)); // We lose fidelity on these keys because they both get written out as numbers // at this point if (VimKeyUtil.IsKeypadKey(cur.Key)) { continue; } Assert.IsTrue(OleCommandUtil.TryConvert(commandGroup, oleCommandData, out converted)); Assert.AreEqual(converted, cur); } finally { OleCommandData.Release(ref oleCommandData); } } }
public void ArrowKey_WithModifiers() { var modifiers = VimKeyModifiers.Alt | VimKeyModifiers.Control; Assert.True(OleCommandUtil.TryConvert(VSConstants.VSStd2K, (uint)VSConstants.VSStd2KCmdID.LEFT, IntPtr.Zero, modifiers, out EditCommand command)); Assert.Equal(modifiers, command.KeyInput.KeyModifiers); }
internal EditCommand ConvertTypeChar(char data) { using (var ptr = CharPointer.Create(data)) { Assert.True(OleCommandUtil.TryConvert(VSConstants.VSStd2K, (uint)VSConstants.VSStd2KCmdID.TYPECHAR, ptr.IntPtr, VimKeyModifiers.None, out EditCommand command)); return(command); } }
private void VerifyConvert(VSConstants.VSStd97CmdID cmd, KeyInput ki, EditCommandKind kind) { EditCommand command; Assert.True(OleCommandUtil.TryConvert(VSConstants.GUID_VSStandardCommandSet97, (uint)cmd, IntPtr.Zero, KeyModifiers.None, out command)); Assert.Equal(ki, command.KeyInput); Assert.Equal(kind, command.EditCommandKind); }
private void VerifyConvert(VSConstants.VSStd2KCmdID cmd, KeyModifiers modifiers, KeyInput ki, EditCommandKind kind) { EditCommand command; Assert.True(OleCommandUtil.TryConvert(VSConstants.VSStd2K, (uint)cmd, IntPtr.Zero, modifiers, out command)); Assert.Equal(ki, command.KeyInput); Assert.Equal(kind, command.EditCommandKind); }
private void VerifyConvert(VSConstants.VSStd97CmdID cmd, KeyInput ki, EditCommandKind kind) { EditCommand command; Assert.IsTrue(OleCommandUtil.TryConvert(VSConstants.GUID_VSStandardCommandSet97, (uint)cmd, out command)); Assert.AreEqual(ki, command.KeyInput); Assert.AreEqual(kind, command.EditCommandKind); }
/// <summary> /// Verify we can convert the given VimKey to the specified command id /// </summary> private void VerifyConvert(VimKey vimKey, VSConstants.VSStd2KCmdID cmd) { var keyInput = KeyInputUtil.VimKeyToKeyInput(vimKey); Assert.True(OleCommandUtil.TryConvert(keyInput, false, out OleCommandData oleCommandData)); Assert.Equal(VSConstants.VSStd2K, oleCommandData.Group); Assert.Equal(new OleCommandData(cmd), oleCommandData); }
int IOleCommandTarget.Exec(ref Guid commandGroup, uint commandId, uint commandExecOpt, IntPtr variantIn, IntPtr variantOut) { if (!OleCommandUtil.TryConvert(commandGroup, commandId, variantIn, out KeyInput keyInput, out EditCommandKind editCommandKind) || !TryExec(keyInput)) { return(_nextCommandTarget.Exec(ref commandGroup, commandId, commandExecOpt, variantIn, variantOut)); } return(VSConstants.S_OK); }
/// <summary> /// Verify we can convert the given VimKey to the specified command id /// </summary> private void VerifyConvert(VimKey vimKey, VSConstants.VSStd2KCmdID cmd) { var keyInput = KeyInputUtil.VimKeyToKeyInput(vimKey); Guid commandGroup; OleCommandData oleCommandData; Assert.IsTrue(OleCommandUtil.TryConvert(keyInput, out commandGroup, out oleCommandData)); Assert.AreEqual(VSConstants.VSStd2K, commandGroup); Assert.AreEqual(new OleCommandData(cmd), oleCommandData); }
int IOleCommandTarget.Exec(ref Guid commandGroup, uint cmdId, uint cmdExecOpt, IntPtr variantIn, IntPtr variantOut) { if (!OleCommandUtil.TryConvert(commandGroup, cmdId, variantIn, VimKeyModifiers.None, out EditCommand editCommand)) { _lastExecEditCommand = null; return(VSConstants.E_FAIL); } _lastExecEditCommand = editCommand; return(TryExec(editCommand.KeyInput) ? VSConstants.S_OK : VSConstants.E_FAIL); }
/// <summary> /// Run the KeyInput value through Exec /// </summary> protected void RunExec(KeyInput keyInput) { Assert.True(OleCommandUtil.TryConvert(keyInput, out OleCommandData data)); try { _target.Exec(data); } finally { data.Dispose(); } }
int IOleCommandTarget.Exec(ref Guid commandGroup, uint cmdId, uint cmdExecOpt, IntPtr variantIn, IntPtr variantOut) { EditCommand editCommand; if (!OleCommandUtil.TryConvert(commandGroup, cmdId, variantIn, out editCommand) || editCommand.EditCommandKind != EditCommandKind.UserInput) { return(VSConstants.E_FAIL); } return(TryExec(editCommand.KeyInput) ? VSConstants.S_OK : VSConstants.E_FAIL); }
int IOleCommandTarget.QueryStatus(ref Guid commandGroup, uint commandCount, OLECMD[] commands, IntPtr commandText) { if (1 != commandCount || !OleCommandUtil.TryConvert(commandGroup, commands[0].cmdID, commandText, VimKeyModifiers.None, out EditCommand editCommand)) { _lastQueryStatusEditCommand = null; commands[0].cmdf = 0; return(NativeMethods.S_OK); } _lastQueryStatusEditCommand = editCommand; commands[0].cmdf = (uint)(OLECMDF.OLECMDF_ENABLED | OLECMDF.OLECMDF_SUPPORTED); return(NativeMethods.S_OK); }
/// <summary> /// Try and convert the provided KeyInput value into OleCommandData. This conversion is meant /// to simulate the standard converison of key input into OLE information in Visual Studio. This /// means we need to reproduce all of the behavior including not converting textual input /// here (unless it maps to a command). Textual input typcially gets routed through WPF and /// is routed to IOleCommandTarget in the default handler /// </summary> private bool TryConvertToOleCommandData(KeyInput keyInput, out OleCommandData oleCommandData) { if (keyInput.RawChar.IsSome()) { if (char.IsLetterOrDigit(keyInput.Char)) { oleCommandData = OleCommandData.Empty; return(false); } } return(OleCommandUtil.TryConvert(keyInput, SimulateStandardKeyMappings, out oleCommandData)); }
internal void RunExec(EditCommand editCommand) { var oleCommandData = OleCommandData.Empty; try { Assert.True(OleCommandUtil.TryConvert(editCommand, out oleCommandData)); _target.Exec(oleCommandData); } finally { oleCommandData.Dispose(); } }
public void TypeChar_WithModifiers() { var source = @"@£$€{[]}\"; var modifiers = VimKeyModifiers.Alt | VimKeyModifiers.Control; foreach (var c in source) { using (var ptr = CharPointer.Create(c)) { Assert.True(OleCommandUtil.TryConvert(VSConstants.VSStd2K, (uint)VSConstants.VSStd2KCmdID.TYPECHAR, ptr.IntPtr, modifiers, out EditCommand command)); Assert.Equal(c, command.KeyInput.Char); } } }
/// <summary> /// Run the KeyInput value through QueryStatus. Returns true if the QueryStatus call /// indicated the command was supported /// </summary> protected bool RunQueryStatus(KeyInput keyInput) { Assert.True(OleCommandUtil.TryConvert(keyInput, out OleCommandData data)); try { return (ErrorHandler.Succeeded(_target.QueryStatus(data, out OLECMD command)) && command.cmdf == (uint)(OLECMDF.OLECMDF_ENABLED | OLECMDF.OLECMDF_SUPPORTED)); } finally { data.Dispose(); } }
int IOleCommandTarget.QueryStatus(ref Guid commandGroup, uint commandCount, OLECMD[] commands, IntPtr commandText) { EditCommand editCommand; if (1 != commandCount || !OleCommandUtil.TryConvert(commandGroup, commands[0].cmdID, commandText, out editCommand) || editCommand.EditCommandKind != EditCommandKind.UserInput) { commands[0].cmdf = 0; return(NativeMethods.S_OK); } commands[0].cmdf = (uint)(OLECMDF.OLECMDF_ENABLED | OLECMDF.OLECMDF_SUPPORTED); return(NativeMethods.S_OK); }
/// <summary> /// Run the KeyInput value through Exec /// </summary> private void RunExec(KeyInput keyInput) { OleCommandData data; Guid commandGroup; Assert.IsTrue(OleCommandUtil.TryConvert(keyInput, out commandGroup, out data)); try { _target.Exec(ref commandGroup, data.CommandId, data.CommandExecOpt, data.VariantIn, data.VariantOut); } finally { OleCommandData.Release(ref data); } }
internal void RunExec(EditCommand editCommand) { var oleCommandData = OleCommandData.Empty; try { Assert.True(OleCommandUtil.TryConvert(editCommand, out oleCommandData)); _target.Exec(oleCommandData); } finally { oleCommandData.Dispose(); } TestableSynchronizationContext.RunAll(); }
/// <summary> /// Run the KeyInput value through QueryStatus. Returns true if the QueryStatus call /// indicated the command was supported /// </summary> private bool RunQueryStatus(KeyInput keyInput) { OleCommandData data; Guid commandGroup; Assert.IsTrue(OleCommandUtil.TryConvert(keyInput, out commandGroup, out data)); try { var cmds = new OLECMD[1]; cmds[0] = new OLECMD { cmdID = data.CommandId }; return (ErrorHandler.Succeeded(_target.QueryStatus(ref commandGroup, 1, cmds, data.VariantIn)) && cmds[0].cmdf == (uint)(OLECMDF.OLECMDF_ENABLED | OLECMDF.OLECMDF_SUPPORTED)); } finally { OleCommandData.Release(ref data); } }
// [Test, Description("Make sure we don't puke on missing data"),Ignore] public void TypeCharNoData() { EditCommand command; Assert.False(OleCommandUtil.TryConvert(VSConstants.GUID_VSStandardCommandSet97, (uint)VSConstants.VSStd2KCmdID.TYPECHAR, IntPtr.Zero, KeyModifiers.None, out command)); }