/// <summary>
/// Run the specified character against the buffer
/// </summary>
internal void Run(char c)
{
Run(KeyInputUtil.CharToKeyInput(c));
}
public void AlternateShiftandControlWithAlpha()
{
var keyInput = KeyNotationUtil.StringToKeyInput("<CS-A>");
Assert.Equal(KeyInputUtil.CharWithControlToKeyInput('a'), keyInput);
}
public void ShiftAlphaShouldPromote()
{
AssertSingle("<S-A>", KeyInputUtil.CharToKeyInput('A'));
AssertSingle("<s-a>", KeyInputUtil.CharToKeyInput('A'));
}
public void IsDirectInput_SpecialKeys()
{
Assert.False(_mode.IsDirectInsert(KeyInputUtil.EnterKey));
Assert.False(_mode.IsDirectInsert(KeyInputUtil.CharToKeyInput('\t')));
}
public void NotationOfFunctionKey()
{
AssertSingle("<S-F11>", KeyInputUtil.ApplyKeyModifiersToKey(VimKey.F11, VimKeyModifiers.Shift));
AssertSingle("<c-F11>", KeyInputUtil.ApplyKeyModifiersToKey(VimKey.F11, VimKeyModifiers.Control));
}
public void GetHashCode_ControlLetterIsCaseInsensitive2()
{
Assert.Equal(KeyInputUtil.CharWithControlToKeyInput('T').GetHashCode(), KeyInputUtil.CharWithControlToKeyInput('t').GetHashCode());
}
private static KeyInput GetKeyInput(char c)
{
return(KeyInputUtil.CharToKeyInput(c));
}
/// <summary>
/// Try and convert a Visual Studio 2000 style command into the associated KeyInput and EditCommand items
/// </summary>
internal static bool TryConvert(VSConstants.VSStd2KCmdID cmdId, IntPtr variantIn, out KeyInput keyInput, out EditCommandKind kind, out bool isRawText)
{
isRawText = false;
switch (cmdId)
{
case VSConstants.VSStd2KCmdID.TYPECHAR:
if (variantIn == IntPtr.Zero)
{
keyInput = KeyInputUtil.CharToKeyInput(Char.MinValue);
}
else
{
var obj = Marshal.GetObjectForNativeVariant(variantIn);
var c = (char)(ushort)obj;
keyInput = KeyInputUtil.CharToKeyInput(c);
}
kind = EditCommandKind.UserInput;
isRawText = true;
break;
case VSConstants.VSStd2KCmdID.RETURN:
keyInput = KeyInputUtil.EnterKey;
kind = EditCommandKind.UserInput;
break;
case VSConstants.VSStd2KCmdID.CANCEL:
keyInput = KeyInputUtil.EscapeKey;
kind = EditCommandKind.UserInput;
break;
case VSConstants.VSStd2KCmdID.DELETE:
keyInput = KeyInputUtil.VimKeyToKeyInput(VimKey.Delete);
kind = EditCommandKind.UserInput;
break;
case VSConstants.VSStd2KCmdID.BACKSPACE:
keyInput = KeyInputUtil.VimKeyToKeyInput(VimKey.Back);
kind = EditCommandKind.UserInput;
break;
case VSConstants.VSStd2KCmdID.LEFT:
keyInput = KeyInputUtil.VimKeyToKeyInput(VimKey.Left);
kind = EditCommandKind.UserInput;
break;
case VSConstants.VSStd2KCmdID.LEFT_EXT:
case VSConstants.VSStd2KCmdID.LEFT_EXT_COL:
keyInput = KeyInputUtil.ApplyModifiersToVimKey(VimKey.Left, KeyModifiers.Shift);
kind = EditCommandKind.VisualStudioCommand;
break;
case VSConstants.VSStd2KCmdID.RIGHT:
keyInput = KeyInputUtil.VimKeyToKeyInput(VimKey.Right);
kind = EditCommandKind.UserInput;
break;
case VSConstants.VSStd2KCmdID.RIGHT_EXT:
case VSConstants.VSStd2KCmdID.RIGHT_EXT_COL:
keyInput = KeyInputUtil.ApplyModifiersToVimKey(VimKey.Right, KeyModifiers.Shift);
kind = EditCommandKind.VisualStudioCommand;
break;
case VSConstants.VSStd2KCmdID.UP:
keyInput = KeyInputUtil.VimKeyToKeyInput(VimKey.Up);
kind = EditCommandKind.UserInput;
break;
case VSConstants.VSStd2KCmdID.UP_EXT:
case VSConstants.VSStd2KCmdID.UP_EXT_COL:
keyInput = KeyInputUtil.ApplyModifiersToVimKey(VimKey.Up, KeyModifiers.Shift);
kind = EditCommandKind.VisualStudioCommand;
break;
case VSConstants.VSStd2KCmdID.DOWN:
keyInput = KeyInputUtil.VimKeyToKeyInput(VimKey.Down);
kind = EditCommandKind.UserInput;
break;
case VSConstants.VSStd2KCmdID.DOWN_EXT:
case VSConstants.VSStd2KCmdID.DOWN_EXT_COL:
keyInput = KeyInputUtil.ApplyModifiersToVimKey(VimKey.Down, KeyModifiers.Shift);
kind = EditCommandKind.VisualStudioCommand;
break;
case VSConstants.VSStd2KCmdID.TAB:
keyInput = KeyInputUtil.TabKey;
kind = EditCommandKind.UserInput;
break;
case VSConstants.VSStd2KCmdID.BACKTAB:
keyInput = KeyInputUtil.ApplyModifiersToVimKey(VimKey.Tab, KeyModifiers.Shift);
kind = EditCommandKind.UserInput;
break;
case VSConstants.VSStd2KCmdID.PAGEDN:
keyInput = KeyInputUtil.VimKeyToKeyInput(VimKey.PageDown);
kind = EditCommandKind.UserInput;
break;
case VSConstants.VSStd2KCmdID.PAGEDN_EXT:
keyInput = KeyInputUtil.ApplyModifiersToVimKey(VimKey.PageDown, KeyModifiers.Shift);
kind = EditCommandKind.VisualStudioCommand;
break;
case VSConstants.VSStd2KCmdID.PAGEUP:
keyInput = KeyInputUtil.VimKeyToKeyInput(VimKey.PageUp);
kind = EditCommandKind.UserInput;
break;
case VSConstants.VSStd2KCmdID.PAGEUP_EXT:
keyInput = KeyInputUtil.ApplyModifiersToVimKey(VimKey.PageUp, KeyModifiers.Shift);
kind = EditCommandKind.VisualStudioCommand;
break;
case VSConstants.VSStd2KCmdID.UNDO:
case VSConstants.VSStd2KCmdID.UNDONOMOVE:
// Visual Studio was asked to undo. This happens when either the undo button
// was hit or the visual studio key combination bound to the undo command
// was executed
keyInput = KeyInput.DefaultValue;
kind = EditCommandKind.Undo;
break;
case VSConstants.VSStd2KCmdID.REDO:
case VSConstants.VSStd2KCmdID.REDONOMOVE:
// Visual Studio was asked to redo. This happens when either the redo button
// was hit or the visual studio key combination bound to the redo command
// was executed
keyInput = KeyInput.DefaultValue;
kind = EditCommandKind.Redo;
break;
case VSConstants.VSStd2KCmdID.BOL:
// Even though there as a HOME value defined, Visual Studio apparently maps the
// Home key to BOL
keyInput = KeyInputUtil.VimKeyToKeyInput(VimKey.Home);
kind = EditCommandKind.UserInput;
break;
case VSConstants.VSStd2KCmdID.BOL_EXT:
case VSConstants.VSStd2KCmdID.BOL_EXT_COL:
keyInput = KeyInputUtil.ApplyModifiersToVimKey(VimKey.Home, KeyModifiers.Shift);
kind = EditCommandKind.VisualStudioCommand;
break;
case VSConstants.VSStd2KCmdID.EOL:
// Even though there as a END value defined, Visual Studio apparently maps the
// Home key to EOL
keyInput = KeyInputUtil.VimKeyToKeyInput(VimKey.End);
kind = EditCommandKind.UserInput;
break;
case VSConstants.VSStd2KCmdID.EOL_EXT:
case VSConstants.VSStd2KCmdID.EOL_EXT_COL:
keyInput = KeyInputUtil.ApplyModifiersToVimKey(VimKey.End, KeyModifiers.Shift);
kind = EditCommandKind.VisualStudioCommand;
break;
case VSConstants.VSStd2KCmdID.TOGGLE_OVERTYPE_MODE:
// The <Insert> key is expressed in the toggle overtype mode flag. In general
// over write mode is referred to as overtype in the code / documentation
keyInput = KeyInputUtil.VimKeyToKeyInput(VimKey.Insert);
kind = EditCommandKind.UserInput;
break;
case VSConstants.VSStd2KCmdID.PASTE:
keyInput = KeyInput.DefaultValue;
kind = EditCommandKind.Paste;
break;
case VSConstants.VSStd2KCmdID.COMMENT_BLOCK:
case VSConstants.VSStd2KCmdID.COMMENTBLOCK:
keyInput = KeyInput.DefaultValue;
kind = EditCommandKind.Comment;
break;
case VSConstants.VSStd2KCmdID.UNCOMMENT_BLOCK:
case VSConstants.VSStd2KCmdID.UNCOMMENTBLOCK:
keyInput = KeyInput.DefaultValue;
kind = EditCommandKind.Uncomment;
break;
default:
keyInput = null;
kind = EditCommandKind.UserInput;
break;
}
return(keyInput != null);
}
private static void AssertSingle(string input, VimKey?key = null)
{
AssertSingle(input, key.HasValue ? KeyInputUtil.VimKeyToKeyInput(key.Value) : null);
}
public void Unmap2()
{
Assert.True(_map.MapWithNoRemap("a", "b", KeyRemapMode.Normal));
Assert.False(_map.Unmap("a", KeyRemapMode.Insert));
Assert.True(_map.GetKeyMappingResult(KeyInputUtil.CharToKeyInput('a'), KeyRemapMode.Normal).IsMapped);
}
/// <summary>
/// Try and convert the Visual Studio 97 based command into KeyInput and EditCommandKind values
/// </summary>
internal static bool TryConvert(VSConstants.VSStd97CmdID cmdId, IntPtr variantIn, out KeyInput ki, out EditCommandKind kind, out bool isRawText)
{
ki = null;
kind = EditCommandKind.UserInput;
isRawText = false;
switch (cmdId)
{
case VSConstants.VSStd97CmdID.SingleChar:
var obj = Marshal.GetObjectForNativeVariant(variantIn);
var c = (char)(ushort)obj;
ki = KeyInputUtil.CharToKeyInput(c);
kind = EditCommandKind.UserInput;
isRawText = true;
break;
case VSConstants.VSStd97CmdID.Escape:
ki = KeyInputUtil.EscapeKey;
kind = EditCommandKind.UserInput;
break;
case VSConstants.VSStd97CmdID.Delete:
ki = KeyInputUtil.VimKeyToKeyInput(VimKey.Delete);
kind = EditCommandKind.UserInput;
break;
case VSConstants.VSStd97CmdID.F1Help:
ki = KeyInputUtil.VimKeyToKeyInput(VimKey.F1);
kind = EditCommandKind.UserInput;
break;
case VSConstants.VSStd97CmdID.Undo:
ki = KeyInput.DefaultValue;
kind = EditCommandKind.Undo;
break;
case VSConstants.VSStd97CmdID.Redo:
ki = KeyInput.DefaultValue;
kind = EditCommandKind.Redo;
break;
case VSConstants.VSStd97CmdID.MultiLevelUndo:
// This occurs when the undo button is pressed. If it's just simply pressed we get
// a IntPtr.Zero 'variantIn' value and can proceed with Vim undo. Else user selected
// a very specific undo point and we shouldn't mess with it
if (variantIn == IntPtr.Zero)
{
ki = KeyInput.DefaultValue;
kind = EditCommandKind.Undo;
}
break;
case VSConstants.VSStd97CmdID.MultiLevelRedo:
// This occurs when the redo button is pressed. If it's just simply pressed we get
// a IntPtr.Zero 'variantIn' value and can proceed with Vim redo . Else user selected
// a very specific redo point and we shouldn't mess with it
if (variantIn == IntPtr.Zero)
{
ki = KeyInput.DefaultValue;
kind = EditCommandKind.Redo;
}
break;
case VSConstants.VSStd97CmdID.GotoDecl:
case VSConstants.VSStd97CmdID.GotoDefn:
ki = KeyInput.DefaultValue;
kind = EditCommandKind.GoToDefinition;
break;
case VSConstants.VSStd97CmdID.Paste:
ki = KeyInput.DefaultValue;
kind = EditCommandKind.Paste;
break;
}
return(ki != null);
}
private void AssertMotion(VimKey key, Motion motion)
{
AssertMotion(KeyInputUtil.VimKeyToKeyInput(key), motion);
}
public void VimKeyToKeyInput1()
{
KeyInputUtil.VimKeyToKeyInput(VimKey.None);
}
public void Tilde1()
{
var ki = KeyInputUtil.CharToKeyInput('~');
Assert.AreEqual('~', ki.Char);
}
public void IsDigit1()
{
var input = KeyInputUtil.CharToKeyInput('0');
Assert.True(input.IsDigit);
}
public void Single_NotationControlAndSymbol()
{
AssertSingle("<C-]>", KeyInputUtil.VimKeyAndModifiersToKeyInput(VimKey.CloseBracket, KeyModifiers.Control));
}
public void Equality_AlternatesAreEqual()
{
foreach (var pair in KeyInputUtil.AlternateKeyInputPairList)
{
var unit = EqualityUnit.Create(pair.Item1).WithEqualValues(pair.Item2).WithNotEqualValues(KeyInputUtil.VimKeyToKeyInput(VimKey.Colon));
EqualityUtil.RunAll(
(x, y) => x == y,
(x, y) => x != y,
values: unit);
}
}
public void Single_ShiftAndControlModifier()
{
AssertSingle("<C-S-A>", KeyInputUtil.VimKeyAndModifiersToKeyInput(VimKey.UpperA, KeyModifiers.Control));
}
public void Equality4()
{
Assert.True(KeyInputUtil.CharToKeyInput('a') != KeyInputUtil.CharToKeyInput('b'));
Assert.True(KeyInputUtil.CharToKeyInput('b') != KeyInputUtil.CharToKeyInput('c'));
Assert.True(KeyInputUtil.CharToKeyInput('c') != KeyInputUtil.CharToKeyInput('d'));
}
public void Single_ShiftNumberShouldNotPromote()
{
AssertSingle("<S-1>", KeyInputUtil.VimKeyAndModifiersToKeyInput(VimKey.Number1, KeyModifiers.Shift));
AssertSingle("<s-1>", KeyInputUtil.VimKeyAndModifiersToKeyInput(VimKey.Number1, KeyModifiers.Shift));
}
public void CanProcess_ActiveWordCompletion()
{
Create("");
SetupActiveWordCompletionSession();
Assert.True(_mode.CanProcess(KeyInputUtil.CharToKeyInput('a')));
}
public void Single_AlphaWithControl()
{
AssertSingle("<C-x>", KeyInputUtil.VimKeyAndModifiersToKeyInput(VimKey.LowerX, KeyModifiers.Control));
AssertSingle("<c-X>", KeyInputUtil.VimKeyAndModifiersToKeyInput(VimKey.UpperX, KeyModifiers.Control));
}
public void NotationControlAndSymbol()
{
AssertSingle("<C-]>", KeyInputUtil.ApplyKeyModifiersToChar(']', VimKeyModifiers.Control));
}
public void Single_AlphaWithAltIsCaseSensitive()
{
AssertSingle("<A-b>", KeyInputUtil.VimKeyAndModifiersToKeyInput(VimKey.LowerB, KeyModifiers.Alt));
AssertSingle("<A-B>", KeyInputUtil.VimKeyAndModifiersToKeyInput(VimKey.UpperB, KeyModifiers.Alt));
}
public void ShiftAndControlModifier()
{
AssertSingle("<C-S-A>", KeyInputUtil.ApplyKeyModifiersToChar('A', VimKeyModifiers.Control));
}
public static IObservable <Unit> OnAnyKeyDownAsObservable(this Component component) => KeyInputUtil.CreateSubject(KeyInputUtil.InputType.anyKeyDown) .TakeUntilDestroy(component);
public void LessThanChar()
{
AssertSingle("<", KeyInputUtil.CharToKeyInput('<'));
}
public static IObservable <Unit> OnKeyDownAsObservable(this Component component, KeyCode keyCode) => KeyInputUtil.CreateSubject(KeyInputUtil.InputType.GetKeyDown, keyCode) .TakeUntilDestroy(component);
public void AlphaAloneIsCaseSensitive()
{
AssertSingle("a", KeyInputUtil.CharToKeyInput('a'));
AssertSingle("A", KeyInputUtil.CharToKeyInput('A'));
}
/// <summary>
/// Convert the single character to a KeyInput. Visual Studio doesn't
/// differentiate between upper and lower case alpha characters.
/// Use all lower case for simplicity elsewhere
/// </summary>
private static KeyInput ConvertToKeyInput(char c)
{
c = Char.IsLetter(c) ? Char.ToLower(c) : c;
return(KeyInputUtil.CharToKeyInput(c));
}
