public void GetNonKeypadEquivalent_PreserveModifiers()
{
var keyInput = KeyInputUtil.ApplyModifiersToVimKey(VimKey.KeypadDivide, KeyModifiers.Control);
var equivalent = KeyInputUtil.GetNonKeypadEquivalent(keyInput);
Assert.Equal(KeyInputUtil.ApplyModifiersToVimKey(VimKey.Forwardslash, KeyModifiers.Control), equivalent.Value);
}
public void Issue328()
{
Assert.True(_map.MapWithNoRemap("<S-SPACE>", "<ESC>", KeyRemapMode.Insert));
var res = _map.GetKeyMapping(KeyInputUtil.ApplyModifiersToVimKey(VimKey.Space, KeyModifiers.Shift), KeyRemapMode.Insert);
Assert.Equal(KeyInputUtil.EscapeKey, res.Single());
}
public void StandardCommand_ExtendSelectionRight()
{
Create("dog", "cat", "tree");
_simulation.SimulateStandardKeyMappings = true;
_simulation.Run(KeyInputUtil.ApplyModifiersToVimKey(VimKey.Right, KeyModifiers.Shift));
Assert.Equal(ModeKind.VisualCharacter, _vimBuffer.ModeKind);
}
public void DontPreserveModifiers()
{
var keyInput = KeyInputUtil.ApplyModifiersToVimKey(VimKey.KeypadDivide, KeyModifiers.Control);
var equivalent = KeyInputUtil.GetNonKeypadEquivalent(keyInput);
Assert.Equal(KeyInputUtil.CharToKeyInput('/'), equivalent.Value);
}
public void AlternateControAndShift()
{
var keyInputSet = KeyNotationUtil.StringToKeyInputSet(@"<CS-A><CS-Enter>");
var list = keyInputSet.KeyInputs.ToList();
Assert.Equal(KeyInputUtil.CharWithControlToKeyInput('a'), list[0]);
Assert.Equal(KeyInputUtil.ApplyModifiersToVimKey(VimKey.Enter, KeyModifiers.Control | KeyModifiers.Shift), list[1]);
}
public void KeyMap_ShiftAndEnter()
{
Create("cat", "dog");
_vimBuffer.Process(":inoremap <S-CR> <Esc>", enter: true);
_vimBuffer.Process("i");
_simulation.Run(KeyInputUtil.ApplyModifiersToVimKey(VimKey.Enter, KeyModifiers.Shift));
Assert.Equal(ModeKind.Normal, _vimBuffer.ModeKind);
}
public void KeyStroke_WithShiftAndControlModifier()
{
var stroke = new KeyStroke(
KeyInputUtil.CharToKeyInput('#'),
KeyModifiers.Shift | KeyModifiers.Control);
Assert.Equal(KeyInputUtil.CharToKeyInput('#'), stroke.KeyInput);
Assert.Equal(KeyInputUtil.ApplyModifiersToVimKey(VimKey.Pound, KeyModifiers.Shift | KeyModifiers.Control), stroke.AggregateKeyInput);
Assert.Equal('#', stroke.Char);
}
public void KeyMap_ShiftAndReturn()
{
Create("cat", "dog");
_vimBuffer.Process(":map <S-RETURN> o<Esc>", enter: true);
_simulation.Run(KeyInputUtil.ApplyModifiersToVimKey(VimKey.Enter, KeyModifiers.Shift));
Assert.Equal(3, _textBuffer.CurrentSnapshot.LineCount);
Assert.Equal("cat", _textBuffer.GetLine(0).GetText());
Assert.Equal("", _textBuffer.GetLine(1).GetText());
Assert.Equal("dog", _textBuffer.GetLine(2).GetText());
}
public void NonCharWithModifierShouldCarryModifier()
{
var ki = KeyInputUtil.ApplyModifiersToVimKey(VimKey.Left, KeyModifiers.Shift);
_mockVimBuffer.Setup(x => x.CanProcess(ki)).Returns(true).Verifiable();
_mockVimBuffer.Setup(x => x.Process(ki)).Returns(ProcessResult.NewHandled(ModeSwitch.NoSwitch)).Verifiable();
var arg = CreateKeyEventArgs(Key.Left, ModifierKeys.Shift);
_processor.KeyDown(arg);
Assert.True(arg.Handled);
_mockVimBuffer.Verify();
}
public void VimKeyAndModifiersToKeyInput1()
{
foreach (var cur in Enum.GetValues(typeof(VimKey)).Cast <VimKey>())
{
if (cur == VimKey.None || cur == VimKey.RawCharacter)
{
continue;
}
var ki = KeyInputUtil.ApplyModifiersToVimKey(cur, KeyModifiers.Control);
Assert.Equal(cur, ki.Key);
Assert.Equal(KeyModifiers.Control, ki.KeyModifiers & KeyModifiers.Control);
}
}
public void ApplyModifiersControlToAllKeysNonAlpha()
{
foreach (var cur in Enum.GetValues(typeof(VimKey)).Cast <VimKey>())
{
if (cur == VimKey.None || cur == VimKey.RawCharacter)
{
continue;
}
if (Char.IsLetter(KeyInputUtil.VimKeyToKeyInput(cur).Char))
{
continue;
}
var keyInput = KeyInputUtil.ApplyModifiersToVimKey(cur, KeyModifiers.Control);
Assert.Equal(cur, keyInput.Key);
Assert.Equal(KeyModifiers.Control, keyInput.KeyModifiers & KeyModifiers.Control);
}
}
static ReportDesignerUtil()
{
// The set of keys which are special handled are defined by the CodeWindow::ProcessKeyMessage inside
// of Microsoft.ReportDesigner.dll
SpecialHandledSet.Add(KeyInputUtil.EnterKey);
SpecialHandledSet.Add(KeyInputUtil.TabKey);
SpecialHandledSet.Add(KeyInputUtil.EscapeKey);
SpecialHandledSet.Add(KeyInputUtil.VimKeyToKeyInput(VimKey.Delete));
SpecialHandledSet.Add(KeyInputUtil.VimKeyToKeyInput(VimKey.Back));
SpecialHandledSet.Add(KeyInputUtil.VimKeyToKeyInput(VimKey.PageUp));
SpecialHandledSet.Add(KeyInputUtil.ApplyModifiersToVimKey(VimKey.PageUp, KeyModifiers.Shift));
SpecialHandledSet.Add(KeyInputUtil.VimKeyToKeyInput(VimKey.PageDown));
SpecialHandledSet.Add(KeyInputUtil.ApplyModifiersToVimKey(VimKey.PageDown, KeyModifiers.Shift));
SpecialHandledSet.Add(KeyInputUtil.VimKeyToKeyInput(VimKey.End));
SpecialHandledSet.Add(KeyInputUtil.ApplyModifiersToVimKey(VimKey.End, KeyModifiers.Shift));
SpecialHandledSet.Add(KeyInputUtil.ApplyModifiersToVimKey(VimKey.End, KeyModifiers.Control));
SpecialHandledSet.Add(KeyInputUtil.ApplyModifiersToVimKey(VimKey.End, KeyModifiers.Control | KeyModifiers.Shift));
SpecialHandledSet.Add(KeyInputUtil.VimKeyToKeyInput(VimKey.Home));
SpecialHandledSet.Add(KeyInputUtil.ApplyModifiersToVimKey(VimKey.Home, KeyModifiers.Shift));
SpecialHandledSet.Add(KeyInputUtil.ApplyModifiersToVimKey(VimKey.Home, KeyModifiers.Control));
SpecialHandledSet.Add(KeyInputUtil.ApplyModifiersToVimKey(VimKey.Home, KeyModifiers.Control | KeyModifiers.Shift));
SpecialHandledSet.Add(KeyInputUtil.VimKeyToKeyInput(VimKey.Left));
SpecialHandledSet.Add(KeyInputUtil.ApplyModifiersToVimKey(VimKey.Left, KeyModifiers.Shift));
SpecialHandledSet.Add(KeyInputUtil.ApplyModifiersToVimKey(VimKey.Left, KeyModifiers.Control));
SpecialHandledSet.Add(KeyInputUtil.ApplyModifiersToVimKey(VimKey.Left, KeyModifiers.Control | KeyModifiers.Shift));
SpecialHandledSet.Add(KeyInputUtil.VimKeyToKeyInput(VimKey.Right));
SpecialHandledSet.Add(KeyInputUtil.ApplyModifiersToVimKey(VimKey.Right, KeyModifiers.Shift));
SpecialHandledSet.Add(KeyInputUtil.ApplyModifiersToVimKey(VimKey.Right, KeyModifiers.Control));
SpecialHandledSet.Add(KeyInputUtil.ApplyModifiersToVimKey(VimKey.Right, KeyModifiers.Control | KeyModifiers.Shift));
SpecialHandledSet.Add(KeyInputUtil.VimKeyToKeyInput(VimKey.Up));
SpecialHandledSet.Add(KeyInputUtil.ApplyModifiersToVimKey(VimKey.Up, KeyModifiers.Shift));
SpecialHandledSet.Add(KeyInputUtil.VimKeyToKeyInput(VimKey.Down));
SpecialHandledSet.Add(KeyInputUtil.ApplyModifiersToVimKey(VimKey.Down, KeyModifiers.Shift));
SpecialHandledSet.Add(KeyInputUtil.ApplyModifiersToChar('a', KeyModifiers.Control));
SpecialHandledSet.Add(KeyInputUtil.ApplyModifiersToChar('v', KeyModifiers.Control));
SpecialHandledSet.Add(KeyInputUtil.ApplyModifiersToChar('x', KeyModifiers.Control));
SpecialHandledSet.Add(KeyInputUtil.ApplyModifiersToChar('y', KeyModifiers.Control));
SpecialHandledSet.Add(KeyInputUtil.ApplyModifiersToChar('z', KeyModifiers.Control));
SpecialHandledSet.Add(KeyInputUtil.ApplyModifiersToChar('z', KeyModifiers.Control | KeyModifiers.Shift));
SpecialHandledSet.Add(KeyInputUtil.CharToKeyInput('\b'));
}
public void ShiftNumberShouldNotPromote()
{
AssertSingle("<S-1>", KeyInputUtil.ApplyModifiersToVimKey(VimKey.Number1, KeyModifiers.Shift));
AssertSingle("<s-1>", KeyInputUtil.ApplyModifiersToVimKey(VimKey.Number1, KeyModifiers.Shift));
}
public void AlphaWithControl()
{
AssertSingle("<C-x>", KeyInputUtil.ApplyModifiersToVimKey(VimKey.LowerX, KeyModifiers.Control));
AssertSingle("<c-X>", KeyInputUtil.ApplyModifiersToVimKey(VimKey.UpperX, KeyModifiers.Control));
}
public void NotationOfFunctionKey()
{
AssertSingle("<S-F11>", KeyInputUtil.ApplyModifiersToVimKey(VimKey.F11, KeyModifiers.Shift));
AssertSingle("<c-F11>", KeyInputUtil.ApplyModifiersToVimKey(VimKey.F11, KeyModifiers.Control));
}
public void AlphaWithAltIsCaseSensitive()
{
AssertSingle("<A-b>", KeyInputUtil.ApplyModifiersToVimKey(VimKey.LowerB, KeyModifiers.Alt));
AssertSingle("<A-B>", KeyInputUtil.ApplyModifiersToVimKey(VimKey.UpperB, KeyModifiers.Alt));
}
public void ShiftAndControlModifier()
{
AssertSingle("<C-S-A>", KeyInputUtil.ApplyModifiersToVimKey(VimKey.UpperA, KeyModifiers.Control));
}
private void VerifySpecial(VimKey vimKey, KeyModifiers keyModifiers = KeyModifiers.None)
{
var keyInput = KeyInputUtil.ApplyModifiersToVimKey(vimKey, keyModifiers);
Assert.True(_reportDesignerUtil.IsSpecialHandled(keyInput));
}
private void AssertMap(Key key, VimKey vimKey)
{
AssertMap(key, ModifierKeys.Control, KeyInputUtil.ApplyModifiersToVimKey(vimKey, KeyModifiers.Control));
}
/// <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);
}
public void NotationControlAndSymbol()
{
AssertSingle("<C-]>", KeyInputUtil.ApplyModifiersToVimKey(VimKey.CloseBracket, KeyModifiers.Control));
}
