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 void TryProcessDrag(MouseEventArgs e, MouseButtonState state, VimKey vimKey)
{
if (state == MouseButtonState.Pressed)
{
e.Handled = TryProcess(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));
}
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);
}
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>
/// 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));
}
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 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));
}
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);
}
protected void RunExec(VimKey vimKey)
{
RunExec(KeyInputUtil.VimKeyToKeyInput(vimKey));
}
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);
}
