public bool IsKeyDown(VimKey vimKey) { Key key; return(KeyUtil.TryConvertToKey(vimKey, out key) && IsKeyDown(key)); }
private void TryProcessDrag(MouseEventArgs e, MouseButtonState state, VimKey vimKey) { if (state == MouseButtonState.Pressed) { e.Handled = TryProcess(vimKey); } }
internal bool TryProcess(VimKey vimKey, int clickCount = 1) { var keyInput = KeyInputUtil.ApplyKeyModifiersToKey(vimKey, _keyboardDevice.KeyModifiers); keyInput = KeyInputUtil.ApplyClickCount(keyInput, clickCount); // If the user has explicitly set the mouse to be <nop> then we don't want to report this as // handled. Otherwise it will swallow the mouse event and as a consequence disable other // features that begin with a mouse click. // // There is really no other way for the user to opt out of mouse behavior besides mapping the // key to <nop> otherwise that would be done here. var keyInputSet = _vimBuffer.GetKeyInputMapping(keyInput).KeyInputSet; if (keyInputSet.Length > 0 && keyInputSet.KeyInputs[0].Key == VimKey.Nop) { return(false); } if (_vimBuffer.CanProcess(keyInput)) { return(_vimBuffer.Process(keyInput).IsAnyHandled); } return(false); }
private Key VimKeyToKey(VimKey vimKey) { switch (vimKey) { case VimKey.Escape: return(Key.Escape); case VimKey.Back: return(Key.Back); case VimKey.Up: return(Key.Up); case VimKey.Right: return(Key.Right); case VimKey.Down: return(Key.Down); case VimKey.Left: return(Key.Left); } var keyInput = KeyInputUtil.VimKeyToKeyInput(vimKey); if (char.IsLetter(keyInput.Char)) { return(StringToKey(keyInput.Char.ToString())); } throw new Exception(string.Format("Can't convert {0} to a Wpf Key", vimKey)); }
private void WellKnownBothWays(VimKey wellKnownKey, Key key) { var left = KeyInputUtil.VimKeyToKeyInput(wellKnownKey); KeyInput right; Assert.IsTrue(KeyUtil.TryConvertToKeyInput(key, out right)); Assert.AreEqual(left, right); }
/// <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); }
/// <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); OleCommandData oleCommandData; Assert.True(OleCommandUtil.TryConvert(keyInput, false, out oleCommandData)); Assert.Equal(VSConstants.VSStd2K, oleCommandData.Group); Assert.Equal(new OleCommandData(cmd), oleCommandData); }
private bool TryProcessDrag(MouseButtonState state, VimKey vimKey) { if (state == MouseButtonState.Pressed) { return(TryProcess(vimKey)); } return(false); }
/// <summary> /// Get the virtual key code for the provided VimKey. This will only work for Vim keys which /// are meant for very specific keys. It doesn't work for alphas /// /// All constant values derived from the list at the following /// location /// http://msdn.microsoft.com/en-us/library/ms645540(VS.85).aspx /// /// </summary> private static bool TrySpecialVimKeyToVirtualKey(VimKey vimKey, out uint virtualKeyCode) { var found = true; switch (vimKey) { case VimKey.Enter: virtualKeyCode = 0xD; break; case VimKey.Tab: virtualKeyCode = 0x9; break; case VimKey.Escape: virtualKeyCode = 0x1B; break; case VimKey.LineFeed: virtualKeyCode = 0; break; case VimKey.Back: virtualKeyCode = 0x8; break; case VimKey.Delete: virtualKeyCode = 0x2E; break; case VimKey.Left: virtualKeyCode = 0x25; break; case VimKey.Up: virtualKeyCode = 0x26; break; case VimKey.Right: virtualKeyCode = 0x27; break; case VimKey.Down: virtualKeyCode = 0x28; break; case VimKey.Help: virtualKeyCode = 0x2F; break; case VimKey.Insert: virtualKeyCode = 0x2D; break; case VimKey.Home: virtualKeyCode = 0x24; break; case VimKey.End: virtualKeyCode = 0x23; break; case VimKey.PageUp: virtualKeyCode = 0x21; break; case VimKey.PageDown: virtualKeyCode = 0x22; break; case VimKey.Break: virtualKeyCode = 0x03; break; case VimKey.F1: virtualKeyCode = 0x70; break; case VimKey.F2: virtualKeyCode = 0x71; break; case VimKey.F3: virtualKeyCode = 0x72; break; case VimKey.F4: virtualKeyCode = 0x73; break; case VimKey.F5: virtualKeyCode = 0x74; break; case VimKey.F6: virtualKeyCode = 0x75; break; case VimKey.F7: virtualKeyCode = 0x76; break; case VimKey.F8: virtualKeyCode = 0x77; break; case VimKey.F9: virtualKeyCode = 0x78; break; case VimKey.F10: virtualKeyCode = 0x79; break; case VimKey.F11: virtualKeyCode = 0x7a; break; case VimKey.F12: virtualKeyCode = 0x7b; break; case VimKey.KeypadMultiply: virtualKeyCode = 0x6A; break; case VimKey.KeypadPlus: virtualKeyCode = 0x6B; break; case VimKey.KeypadMinus: virtualKeyCode = 0x6D; break; case VimKey.KeypadDecimal: virtualKeyCode = 0x6E; break; case VimKey.KeypadDivide: virtualKeyCode = 0x6F; break; case VimKey.Keypad0: virtualKeyCode = 0x60; break; case VimKey.Keypad1: virtualKeyCode = 0x61; break; case VimKey.Keypad2: virtualKeyCode = 0x62; break; case VimKey.Keypad3: virtualKeyCode = 0x63; break; case VimKey.Keypad4: virtualKeyCode = 0x64; break; case VimKey.Keypad5: virtualKeyCode = 0x65; break; case VimKey.Keypad6: virtualKeyCode = 0x66; break; case VimKey.Keypad7: virtualKeyCode = 0x67; break; case VimKey.Keypad8: virtualKeyCode = 0x68; break; case VimKey.Keypad9: virtualKeyCode = 0x69; break; default: virtualKeyCode = 0; found = false; break; } return found; }
private bool TryProcess(VimKey vimKey) { var keyInput = KeyInputUtil.VimKeyToKeyInput(vimKey); if (_vimBuffer.CanProcess(keyInput)) { return _vimBuffer.Process(keyInput).IsAnyHandled; } return false; }
internal static KeyInput CreateKeyInput( VimKey key = VimKey.None, KeyModifiers mod = KeyModifiers.None, char?c = null) { return(new KeyInput( key, mod, c.HasValue ? FSharpOption <char> .Some(c.Value) : FSharpOption <char> .None)); }
internal static KeyInput CreateKeyInput( VimKey key = VimKey.NotWellKnown, KeyModifiers mod = KeyModifiers.None, char? c = null) { return new KeyInput( key, mod, c.HasValue ? FSharpOption<char>.Some(c.Value) : FSharpOption<char>.None); }
/// <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); }
internal bool TryProcess(VimKey vimKey) { var keyInput = KeyInputUtil.VimKeyToKeyInput(vimKey); if (_vimBuffer.CanProcess(keyInput)) { return(_vimBuffer.Process(keyInput).IsAnyHandled); } return(false); }
/// <summary> /// Try and convert the VimKey to a WPF key. Note this is a lossy conversion as modifiers /// will be dropped. So for example UpperN will still map to Key.N but the fidelity of /// shift will be lost /// </summary> internal bool TryConvertToKey(VimKey vimKey, out IEnumerable<Key> keys) { IEnumerable<KeyState> keyStates; if (GetOrCreateKeyboardMap().TryGetKey(vimKey, out keyStates)) { keys = keyStates.Select(x => x.Key); return true; } keys = null; return false; }
internal bool TryGetKey(VimKey vimKey, out Key key) { int virtualKeyCode; if (!TryVimKeyToVirtualKey(vimKey, out virtualKeyCode)) { key = Key.None; return false; } key = KeyInterop.KeyFromVirtualKey(virtualKeyCode); return true; }
internal bool TryGetKey(VimKey vimKey, out Key key) { int virtualKeyCode; if (!TryVimKeyToVirtualKey(vimKey, out virtualKeyCode)) { key = Key.None; return(false); } key = KeyInterop.KeyFromVirtualKey(virtualKeyCode); return(true); }
/// <summary> /// Try and convert the VimKey to a WPF key. Note this is a lossy conversion as modifiers /// will be dropped. So for example UpperN will still map to Key.N but the fidelity of /// shift will be lost /// </summary> internal bool TryConvertToKey(VimKey vimKey, out IEnumerable <Key> keys) { IEnumerable <KeyState> keyStates; if (GetOrCreateKeyboardMap().TryGetKey(vimKey, out keyStates)) { keys = keyStates.Select(x => x.Key); return(true); } keys = null; return(false); }
/// <summary> /// Try and get the WPF key for the given VimKey value /// </summary> internal bool TryGetKey(VimKey vimKey, out Key key, out ModifierKeys modifierKeys) { var keyInput = KeyInputUtil.VimKeyToKeyInput(vimKey); int virtualKeyCode; if (!TryGetVirtualKeyAndModifiers(_keyboardId, keyInput, out virtualKeyCode, out modifierKeys)) { key = Key.None; return(false); } key = KeyInterop.KeyFromVirtualKey(virtualKeyCode); return(true); }
/// <summary> /// Try and convert the VimKey to a WPF key. Note this is not a lossy conversion. If any /// ModifierKeys would be necessary to produce the VimKey then the conversion will fail /// </summary> internal bool TryConvertToKeyOnly(VimKey vimKey, out Key key) { IEnumerable <KeyState> keyStates; if (GetOrCreateKeyboardMap().TryGetKey(vimKey, out keyStates)) { var keyState = keyStates.FirstOrDefault(x => x.ModifierKeys == ModifierKeys.None); key = keyState.Key; return(key != default(Key)); } key = default(Key); return(false); }
/// <summary> /// Try and get the WPF keys which are associated with the given VimKey value. There /// can be multiple as several key combinations can map to a single WPF key /// </summary> internal bool TryGetKey(VimKey vimKey, out IEnumerable <KeyState> keys) { var keyInput = KeyInputUtil.VimKeyToKeyInput(vimKey); FrugalList <KeyState> frugalList; if (_keyInputToWpfKeyDataMap.TryGetValue(keyInput, out frugalList)) { keys = frugalList.GetValues(); return(true); } keys = null; return(false); }
/// <summary> /// Try and get the WPF key for the given VimKey value /// </summary> internal bool TryGetKey(VimKey vimKey, out Key key, out ModifierKeys modifierKeys) { var keyInput = KeyInputUtil.VimKeyToKeyInput(vimKey); KeyState wpfKeyData; if (_keyInputToWpfKeyDataMap.TryGetValue(keyInput, out wpfKeyData)) { key = wpfKeyData.Key; modifierKeys = wpfKeyData.ModifierKeys; return(true); } key = Key.None; modifierKeys = ModifierKeys.None; return(false); }
internal bool TryProcess(VimKey vimKey) { var keyInput = KeyInputUtil.VimKeyToKeyInput(vimKey); // If the user has explicitly set the mouse to be <nop> then we don't want to report this as // handled. Otherwise it will swallow the mouse event and as a consequence disable other // features that begin with a mouse click. // // There is really no other way for the user to opt out of mouse behavior besides mapping the // key to <nop> otherwise that would be done here. var keyInputSet = _vimBuffer.GetKeyInputMapping(keyInput).KeyInputSet; if (keyInputSet.Length > 0 && keyInputSet.KeyInputs[0].Key == VimKey.Nop) { return false; } if (_vimBuffer.CanProcess(keyInput)) { return _vimBuffer.Process(keyInput).IsAnyHandled; } return false; }
public static bool CanProcess(this IMode mode, VimKey key) { return mode.CanProcess(KeyInputUtil.VimKeyToKeyInput(key)); }
public bool IsKeyDown(VimKey vimKey) { Key key; return KeyUtil.TryConvertToKeyOnly(vimKey, out key) && IsKeyDown(key); }
/// <summary> /// Under the hood we map KeyInput values into actual input by one of two mechanisms /// /// 1. Straight mapping of a VimKey to a Virtual Key Code. /// 2. Mapping of the character to a virtual key code and set of modifier keys /// /// This method will return true if the VimKey is mapped using method 2 /// /// Generally speaking a KeyInput is mapped by character if it has an associated /// char value. This is not true for certain special cases like Enter, Tab and /// the Keypad values. /// </summary> internal static bool IsMappedByCharacter(VimKey vimKey) { int virtualKey; return(!TryVimKeyToVirtualKey(vimKey, out virtualKey)); }
/// <summary> /// Under the hood we map KeyInput values into actual input by one of two mechanisms /// /// 1. Straight mapping of a VimKey to a Virtual Key Code. /// 2. Mapping of the character to a virtual key code and set of modifier keys /// /// This method will return true if the VimKey is mapped using method 2 /// /// Generally speaking a KeyInput is mapped by character if it has an associated /// char value. This is not true for certain special cases like Enter, Tab and /// the Keypad values. /// </summary> internal static bool IsMappedByCharacter(VimKey vimKey) { int virtualKey; return !TryVimKeyToVirtualKey(vimKey, out virtualKey); }
/// <summary> /// Try and convert the VimKey to a WPF key and the associated modifiers /// </summary> public static bool TryConvertToKey(VimKey vimKey, out Key key, out ModifierKeys modifierKeys) { return GetOrCreateKeyboardMap().TryGetKey(vimKey, out key, out modifierKeys); }
public static bool IsMappedByChar(VimKey vimKey) { return KeyboardMap.IsMappedByCharacter(vimKey); }
public static bool TryConvertToKey(VimKey vimKey, out Key key) { return GetOrCreateKeyboardMap().TryGetKey(vimKey, out key); }
public static bool IsMappedByChar(VimKey vimKey) { return(KeyboardMap.IsMappedByCharacter(vimKey)); }
private Key VimKeyToKey(VimKey vimKey) { switch (vimKey) { case VimKey.Escape: return Key.Escape; case VimKey.Back: return Key.Back; case VimKey.Up: return Key.Up; case VimKey.Right: return Key.Right; case VimKey.Down: return Key.Down; case VimKey.Left: return Key.Left; } var keyInput = KeyInputUtil.VimKeyToKeyInput(vimKey); if (Char.IsLetter(keyInput.Char)) { return StringToKey(keyInput.Char.ToString()); } throw new Exception(String.Format("Can't convert {0} to a Wpf Key", vimKey)); }
/// <summary> /// Try and get the WPF keys which are associated with the given VimKey value. There /// can be multiple as several key combinations can map to a single WPF key /// </summary> internal bool TryGetKey(VimKey vimKey, out IEnumerable<KeyState> keys) { var keyInput = KeyInputUtil.VimKeyToKeyInput(vimKey); FrugalList<KeyState> frugalList; if (_keyInputToWpfKeyDataMap.TryGetValue(keyInput, out frugalList)) { keys = frugalList.GetValues(); return true; } keys = null; return false; }
private void AssertMap(Key key, VimKey vimKey) { AssertMap(key, ModifierKeys.Control, KeyInputUtil.ApplyKeyModifiersToKey(vimKey, VimKeyModifiers.Control)); }
public static bool Process(this IVimBuffer buf, VimKey key) { return buf.Process(KeyInputUtil.VimKeyToKeyInput(key)); }
public static bool Process(this IVimBuffer buf, VimKey key) { return(buf.Process(KeyInputUtil.VimKeyToKeyInput(key))); }
public static bool CanProcess(this IMode mode, VimKey key) { return(mode.CanProcess(KeyInputUtil.VimKeyToKeyInput(key))); }
/// <summary> /// Try and convert the VimKey to a WPF key. Note this is a lossy conversion as modifiers /// will be dropped. So for example UpperN will still map to Key.N but the fidelity of /// shift will be lost /// </summary> public static bool TryConvertToKey(VimKey vimKey, out Key key) { ModifierKeys modifierKeys; return TryConvertToKey(vimKey, out key, out modifierKeys); }
public static ProcessResult Process(this IMode mode, VimKey key) { return(mode.Process(KeyInputUtil.VimKeyToKeyInput(key))); }
/// <summary> /// Try and convert the VimKey to a WPF key. Note this is not a lossy conversion. If any /// ModifierKeys would be necessary to produce the VimKey then the conversion will fail /// </summary> public static bool TryConvertToKeyOnly(VimKey vimKey, out Key key) { ModifierKeys modifierKeys; return TryConvertToKey(vimKey, out key, out modifierKeys) && modifierKeys == ModifierKeys.None; }
/// <summary> /// Helper for the CanProcessAsCommand function which maps the VimKey to a KeyInput value /// </summary> public static bool CanProcessAsCommand(this IVimBuffer buffer, VimKey key) { var keyInput = KeyInputUtil.VimKeyToKeyInput(key); return(buffer.CanProcessAsCommand(keyInput)); }
protected void RunExec(VimKey vimKey) { RunExec(KeyInputUtil.VimKeyToKeyInput(vimKey)); }
public static BindResult <CommandRunData> Run(this ICommandRunner runner, VimKey key) { return(runner.Run(KeyInputUtil.VimKeyToKeyInput(key))); }
/// <summary> /// /// All constant values derived from the list at the following /// location /// http://msdn.microsoft.com/en-us/library/ms645540(VS.85).aspx /// /// </summary> private static bool TryVimKeyToVirtualKey(VimKey vimKey, out int virtualKeyCode) { var found = true; switch (vimKey) { case VimKey.Enter: virtualKeyCode = 0xD; break; case VimKey.Tab: virtualKeyCode = 0x9; break; case VimKey.Escape: virtualKeyCode = 0x1B; break; case VimKey.LineFeed: virtualKeyCode = 0; break; case VimKey.Back: virtualKeyCode = 0x8; break; case VimKey.Delete: virtualKeyCode = 0x2E; break; case VimKey.Left: virtualKeyCode = 0x25; break; case VimKey.Up: virtualKeyCode = 0x26; break; case VimKey.Right: virtualKeyCode = 0x27; break; case VimKey.Down: virtualKeyCode = 0x28; break; case VimKey.Help: virtualKeyCode = 0x2F; break; case VimKey.Insert: virtualKeyCode = 0x2D; break; case VimKey.Home: virtualKeyCode = 0x24; break; case VimKey.End: virtualKeyCode = 0x23; break; case VimKey.PageUp: virtualKeyCode = 0x21; break; case VimKey.PageDown: virtualKeyCode = 0x22; break; case VimKey.Break: virtualKeyCode = 0x03; break; case VimKey.F1: virtualKeyCode = 0x70; break; case VimKey.F2: virtualKeyCode = 0x71; break; case VimKey.F3: virtualKeyCode = 0x72; break; case VimKey.F4: virtualKeyCode = 0x73; break; case VimKey.F5: virtualKeyCode = 0x74; break; case VimKey.F6: virtualKeyCode = 0x75; break; case VimKey.F7: virtualKeyCode = 0x76; break; case VimKey.F8: virtualKeyCode = 0x77; break; case VimKey.F9: virtualKeyCode = 0x78; break; case VimKey.F10: virtualKeyCode = 0x79; break; case VimKey.F11: virtualKeyCode = 0x7a; break; case VimKey.F12: virtualKeyCode = 0x7b; break; case VimKey.KeypadMultiply: virtualKeyCode = 0x6A; break; case VimKey.KeypadPlus: virtualKeyCode = 0x6B; break; case VimKey.KeypadMinus: virtualKeyCode = 0x6D; break; case VimKey.KeypadDecimal: virtualKeyCode = 0x6E; break; case VimKey.KeypadDivide: virtualKeyCode = 0x6F; break; case VimKey.Keypad0: virtualKeyCode = 0x60; break; case VimKey.Keypad1: virtualKeyCode = 0x61; break; case VimKey.Keypad2: virtualKeyCode = 0x62; break; case VimKey.Keypad3: virtualKeyCode = 0x63; break; case VimKey.Keypad4: virtualKeyCode = 0x64; break; case VimKey.Keypad5: virtualKeyCode = 0x65; break; case VimKey.Keypad6: virtualKeyCode = 0x66; break; case VimKey.Keypad7: virtualKeyCode = 0x67; break; case VimKey.Keypad8: virtualKeyCode = 0x68; break; case VimKey.Keypad9: virtualKeyCode = 0x69; break; default: virtualKeyCode = 0; found = false; break; } return(found); }
internal static bool TrySpecialVimKeyToKey(VimKey vimKey, out NSKey key) { return(s_vimKeyToCocoaKeyMap.TryGetValue(vimKey, out key)); }
private void AssertMotion(VimKey key, Motion motion) { AssertMotion(KeyInputUtil.VimKeyToKeyInput(key), motion); }
private void VerifySpecial(VimKey vimKey, KeyModifiers keyModifiers = KeyModifiers.None) { var keyInput = KeyInputUtil.ApplyModifiersToVimKey(vimKey, keyModifiers); Assert.True(_reportDesignerUtil.IsSpecialHandled(keyInput)); }
public static ProcessResult Process(this IMode mode, VimKey key) { return mode.Process(KeyInputUtil.VimKeyToKeyInput(key)); }
internal static bool TrySpecialVimKeyToKey(VimKey vimKey, out Key key) { return s_vimKeyToWpfKeyMap.TryGetValue(vimKey, out key); }
/// <summary> /// Verify the given VimKey converts to the provided command id and vice versa /// </summary> private void VerifyBothWays(VSConstants.VSStd2KCmdID cmd, VimKey vimKey, EditCommandKind kind = EditCommandKind.UserInput) { VerifyConvert(cmd, vimKey, kind); }
protected static void AssertSingle(string input, VimKey? key = null) { AssertSingle(input, key.HasValue ? KeyInputUtil.VimKeyToKeyInput(key.Value) : null); }
private void VerifyConvert(VSConstants.VSStd97CmdID cmd, VimKey vimKey, EditCommandKind kind) { VerifyConvert(cmd, KeyInputUtil.VimKeyToKeyInput(vimKey), kind); }
public static bool TryConvertToKey(VimKey vimKey, out Key key) { return(GetOrCreateKeyboardMap().TryGetKey(vimKey, out key)); }
private void VerifyConvertWithShift(VSConstants.VSStd2KCmdID cmd, VimKey vimKey, EditCommandKind kind) { var keyInput = KeyInputUtil.ApplyModifiers(KeyInputUtil.VimKeyToKeyInput(vimKey), KeyModifiers.Shift); VerifyConvert(cmd, keyInput, kind); }