private void VerifyConvert(VSConstants.VSStd2KCmdID cmd, VimKeyModifiers 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);
}
internal static bool TryConvert(Guid commandGroup, uint commandId, IntPtr variantIn, out KeyInput keyInput, out EditCommandKind kind, out bool isRawText)
{
if (VSConstants.GUID_VSStandardCommandSet97 == commandGroup)
{
return TryConvert((VSConstants.VSStd97CmdID)commandId, variantIn, out keyInput, out kind, out isRawText);
}
if (VSConstants.VSStd2K == commandGroup)
{
return TryConvert((VSConstants.VSStd2KCmdID)commandId, variantIn, out keyInput, out kind, out isRawText);
}
if (commandGroup == HiddenCommand.Group && commandId == HiddenCommand.Id)
{
keyInput = KeyInputUtil.CharWithControlToKeyInput(';');
kind = EditCommandKind.UserInput;
isRawText = true;
return true;
}
keyInput = null;
kind = EditCommandKind.UserInput;
isRawText = false;
return false;
}
private void VerifyConvert(VSConstants.VSStd97CmdID cmd, KeyInput ki, EditCommandKind kind)
{
EditCommand command;
Assert.True(OleCommandUtil.TryConvert(VSConstants.GUID_VSStandardCommandSet97, (uint)cmd, IntPtr.Zero, VimKeyModifiers.None, out command));
Assert.Equal(ki, command.KeyInput);
Assert.Equal(kind, command.EditCommandKind);
}
internal EditCommand(
KeyInput input,
EditCommandKind kind,
Guid group,
uint id)
{
_keyInput = input;
EditCommandKind = kind;
Group = group;
Id = id;
}
internal static bool TryConvert(Guid commandGroup, uint commandId, IntPtr variantIn, out KeyInput keyInput, out EditCommandKind kind)
{
if (VSConstants.GUID_VSStandardCommandSet97 == commandGroup)
{
return TryConvert((VSConstants.VSStd97CmdID)commandId, variantIn, out keyInput, out kind);
}
if (VSConstants.VSStd2K == commandGroup)
{
return TryConvert((VSConstants.VSStd2KCmdID)commandId, variantIn, out keyInput, out kind);
}
keyInput = null;
kind = EditCommandKind.UserInput;
return false;
}
internal EditCommand Create(char c, EditCommandKind kind)
{
return Create(KeyInputUtil.CharToKeyInput(c), kind);
}
/// <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 ki, out EditCommandKind kind)
{
switch (cmdId)
{
case VSConstants.VSStd2KCmdID.TYPECHAR:
if (variantIn == IntPtr.Zero)
{
ki = KeyInputUtil.CharToKeyInput(Char.MinValue);
}
else
{
var obj = Marshal.GetObjectForNativeVariant(variantIn);
var c = (char)(ushort)obj;
ki = KeyInputUtil.CharToKeyInput(c);
}
kind = EditCommandKind.UserInput;
break;
case VSConstants.VSStd2KCmdID.RETURN:
ki = KeyInputUtil.EnterKey;
kind = EditCommandKind.UserInput;
break;
case VSConstants.VSStd2KCmdID.CANCEL:
ki = KeyInputUtil.EscapeKey;
kind = EditCommandKind.UserInput;
break;
case VSConstants.VSStd2KCmdID.DELETE:
ki = KeyInputUtil.VimKeyToKeyInput(VimKey.Delete);
kind = EditCommandKind.UserInput;
break;
case VSConstants.VSStd2KCmdID.BACKSPACE:
ki = KeyInputUtil.VimKeyToKeyInput(VimKey.Back);
kind = EditCommandKind.UserInput;
break;
case VSConstants.VSStd2KCmdID.LEFT:
case VSConstants.VSStd2KCmdID.LEFT_EXT:
case VSConstants.VSStd2KCmdID.LEFT_EXT_COL:
ki = KeyInputUtil.VimKeyToKeyInput(VimKey.Left);
kind = EditCommandKind.UserInput;
break;
case VSConstants.VSStd2KCmdID.RIGHT:
case VSConstants.VSStd2KCmdID.RIGHT_EXT:
case VSConstants.VSStd2KCmdID.RIGHT_EXT_COL:
ki = KeyInputUtil.VimKeyToKeyInput(VimKey.Right);
kind = EditCommandKind.UserInput;
break;
case VSConstants.VSStd2KCmdID.UP:
case VSConstants.VSStd2KCmdID.UP_EXT:
case VSConstants.VSStd2KCmdID.UP_EXT_COL:
ki = KeyInputUtil.VimKeyToKeyInput(VimKey.Up);
kind = EditCommandKind.UserInput;
break;
case VSConstants.VSStd2KCmdID.DOWN:
case VSConstants.VSStd2KCmdID.DOWN_EXT:
case VSConstants.VSStd2KCmdID.DOWN_EXT_COL:
ki = KeyInputUtil.VimKeyToKeyInput(VimKey.Down);
kind = EditCommandKind.UserInput;
break;
case VSConstants.VSStd2KCmdID.TAB:
ki = KeyInputUtil.TabKey;
kind = EditCommandKind.UserInput;
break;
case VSConstants.VSStd2KCmdID.PAGEDN:
case VSConstants.VSStd2KCmdID.PAGEDN_EXT:
ki = KeyInputUtil.VimKeyToKeyInput(VimKey.PageDown);
kind = EditCommandKind.UserInput;
break;
case VSConstants.VSStd2KCmdID.PAGEUP:
case VSConstants.VSStd2KCmdID.PAGEUP_EXT:
ki = KeyInputUtil.VimKeyToKeyInput(VimKey.PageUp);
kind = EditCommandKind.UserInput;
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
ki = 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
ki = KeyInput.DefaultValue;
kind = EditCommandKind.Redo;
break;
default:
ki = null;
kind = EditCommandKind.UserInput;
break;
}
return ki != null;
}
private void VerifyConvert(VSConstants.VSStd2KCmdID cmd, VimKeyModifiers modifiers, KeyInput ki, EditCommandKind kind)
{
Assert.True(OleCommandUtil.TryConvert(VSConstants.VSStd2K, (uint)cmd, IntPtr.Zero, modifiers, out EditCommand command));
Assert.Equal(ki, command.KeyInput);
Assert.Equal(kind, command.EditCommandKind);
}
private void VerifyConvertWithShift(VSConstants.VSStd2KCmdID cmd, VimKey vimKey, EditCommandKind kind)
{
var keyInput = KeyInputUtil.ApplyKeyModifiers(KeyInputUtil.VimKeyToKeyInput(vimKey), VimKeyModifiers.Shift);
VerifyConvert(cmd, keyInput, kind);
}
private void VerifyConvert(VSConstants.VSStd2KCmdID cmd, KeyInput ki, EditCommandKind kind)
{
VerifyConvert(cmd, KeyModifiers.None, ki, kind);
}
private void VerifyConvertWithShift(VSConstants.VSStd2KCmdID cmd, VimKey vimKey, EditCommandKind kind)
{
var keyInput = KeyInputUtil.ApplyModifiers(KeyInputUtil.VimKeyToKeyInput(vimKey), KeyModifiers.Shift);
VerifyConvert(cmd, keyInput, kind);
}
internal EditCommand Create(char c, EditCommandKind kind)
{
return(Create(KeyInputUtil.CharToKeyInput(c), kind));
}
internal static bool TryConvert(Guid commandGroup, uint commandId, out KeyInput ki, out EditCommandKind kind)
{
return(TryConvert(commandGroup, commandId, IntPtr.Zero, out ki, out kind));
}
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);
}
internal static EditCommand CreateEditCommand(EditCommandKind editCommandKind)
{
return new EditCommand(KeyInputUtil.CharToKeyInput('i'), editCommandKind, Guid.Empty, 42);
}
/// <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);
}
private void VerifyConvert(VSConstants.VSStd97CmdID cmd, KeyInput ki, EditCommandKind kind)
{
Assert.True(OleCommandUtil.TryConvert(VSConstants.GUID_VSStandardCommandSet97, (uint)cmd, IntPtr.Zero, VimKeyModifiers.None, out EditCommand command));
Assert.Equal(ki, command.KeyInput);
Assert.Equal(kind, command.EditCommandKind);
}
private void VerifyConvert(VSConstants.VSStd97CmdID cmd, VimKey vimKey, EditCommandKind kind)
{
VerifyConvert(cmd, KeyInputUtil.VimKeyToKeyInput(vimKey), kind);
}
/// <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;
default:
keyInput = null;
kind = EditCommandKind.UserInput;
break;
}
return(keyInput != null);
}
internal EditCommand Create(KeyInput ki, EditCommandKind kind)
{
return(new EditCommand(ki, kind, Guid.Empty, 0));
}
internal static bool TryConvert(Guid commandGroup, uint commandId, IntPtr pVariableIn, out KeyInput ki, out EditCommandKind kind)
{
if (VSConstants.GUID_VSStandardCommandSet97 == commandGroup)
{
return(TryConvert((VSConstants.VSStd97CmdID)commandId, pVariableIn, out ki, out kind));
}
if (VSConstants.VSStd2K == commandGroup)
{
return(TryConvert((VSConstants.VSStd2KCmdID)commandId, pVariableIn, out ki, out kind));
}
ki = null;
kind = EditCommandKind.UserInput;
return(false);
}
internal static bool TryConvert(Guid commandGroup, uint commandId, IntPtr pVariableIn, out KeyInput ki, out EditCommandKind kind)
{
if (VSConstants.GUID_VSStandardCommandSet97 == commandGroup)
{
return TryConvert((VSConstants.VSStd97CmdID)commandId, pVariableIn, out ki, out kind);
}
else if (VSConstants.VSStd2K == commandGroup)
{
return TryConvert((VSConstants.VSStd2KCmdID)commandId, pVariableIn, out ki, out kind);
}
else
{
ki = null;
kind = EditCommandKind.Unknown;
return false;
}
}
/// <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);
}
internal static bool TryConvert(Guid commandGroup, uint commandId, out KeyInput ki, out EditCommandKind kind)
{
return TryConvert(commandGroup, commandId, IntPtr.Zero, out ki, out kind);
}
private void VerifyConvert(VSConstants.VSStd97CmdID cmd, VimKey vimKey, EditCommandKind kind)
{
VerifyConvert(cmd, KeyInputUtil.VimKeyToKeyInput(vimKey), kind);
}
/// <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;
}
internal static EditCommand CreateEditCommand(EditCommandKind editCommandKind)
{
return(new EditCommand(KeyInputUtil.CharToKeyInput('i'), editCommandKind, Guid.Empty, 42));
}
private void VerifyConvert(VSConstants.VSStd2KCmdID cmd, KeyInput ki, EditCommandKind kind)
{
VerifyConvert(cmd, VimKeyModifiers.None, ki, kind);
}
internal static bool TryConvert(VSConstants.VSStd2KCmdID cmdId, IntPtr variantIn, out KeyInput ki, out EditCommandKind kind)
{
kind = EditCommandKind.Unknown;
ki = null;
switch (cmdId)
{
case VSConstants.VSStd2KCmdID.TYPECHAR:
if (variantIn == IntPtr.Zero)
{
ki = KeyInputUtil.CharToKeyInput(Char.MinValue);
}
else
{
var obj = Marshal.GetObjectForNativeVariant(variantIn);
var c = (char)(ushort)obj;
ki = KeyInputUtil.CharToKeyInput(c);
}
kind = EditCommandKind.TypeChar;
break;
case VSConstants.VSStd2KCmdID.RETURN:
ki = KeyInputUtil.EnterKey;
kind = EditCommandKind.Return;
break;
case VSConstants.VSStd2KCmdID.CANCEL:
ki = KeyInputUtil.EscapeKey;
kind = EditCommandKind.Cancel;
break;
case VSConstants.VSStd2KCmdID.DELETE:
ki = KeyInputUtil.VimKeyToKeyInput(VimKey.Delete);
kind = EditCommandKind.Delete;
break;
case VSConstants.VSStd2KCmdID.BACKSPACE:
ki = KeyInputUtil.VimKeyToKeyInput(VimKey.Back);
kind = EditCommandKind.Backspace;
break;
case VSConstants.VSStd2KCmdID.LEFT:
case VSConstants.VSStd2KCmdID.LEFT_EXT:
case VSConstants.VSStd2KCmdID.LEFT_EXT_COL:
ki = KeyInputUtil.VimKeyToKeyInput(VimKey.Left);
kind = EditCommandKind.CursorMovement;
break;
case VSConstants.VSStd2KCmdID.RIGHT:
case VSConstants.VSStd2KCmdID.RIGHT_EXT:
case VSConstants.VSStd2KCmdID.RIGHT_EXT_COL:
ki = KeyInputUtil.VimKeyToKeyInput(VimKey.Right);
kind = EditCommandKind.CursorMovement;
break;
case VSConstants.VSStd2KCmdID.UP:
case VSConstants.VSStd2KCmdID.UP_EXT:
case VSConstants.VSStd2KCmdID.UP_EXT_COL:
ki = KeyInputUtil.VimKeyToKeyInput(VimKey.Up);
kind = EditCommandKind.CursorMovement;
break;
case VSConstants.VSStd2KCmdID.DOWN:
case VSConstants.VSStd2KCmdID.DOWN_EXT:
case VSConstants.VSStd2KCmdID.DOWN_EXT_COL:
ki = KeyInputUtil.VimKeyToKeyInput(VimKey.Down);
kind = EditCommandKind.CursorMovement;
break;
case VSConstants.VSStd2KCmdID.TAB:
ki = KeyInputUtil.TabKey;
kind = EditCommandKind.TypeChar;
break;
case VSConstants.VSStd2KCmdID.PAGEDN:
case VSConstants.VSStd2KCmdID.PAGEDN_EXT:
ki = KeyInputUtil.VimKeyToKeyInput(VimKey.PageDown);
kind = EditCommandKind.CursorMovement;
break;
case VSConstants.VSStd2KCmdID.PAGEUP:
case VSConstants.VSStd2KCmdID.PAGEUP_EXT:
ki = KeyInputUtil.VimKeyToKeyInput(VimKey.PageUp);
kind = EditCommandKind.CursorMovement;
break;
case VSConstants.VSStd2KCmdID.UNDO:
case VSConstants.VSStd2KCmdID.UNDONOMOVE:
ki = KeyInput.DefaultValue;
kind = EditCommandKind.Undo;
break;
case VSConstants.VSStd2KCmdID.REDO:
case VSConstants.VSStd2KCmdID.REDONOMOVE:
ki = KeyInput.DefaultValue;
kind = EditCommandKind.Redo;
break;
default:
break;
}
return ki != null;
}
internal static bool TryConvert(VSConstants.VSStd2KCmdID cmdId, IntPtr pVariantIn, out KeyInput ki, out EditCommandKind kind)
{
kind = EditCommandKind.Unknown;
ki = null;
switch (cmdId)
{
case VSConstants.VSStd2KCmdID.TYPECHAR:
if (pVariantIn == IntPtr.Zero)
{
return false;
}
var obj = Marshal.GetObjectForNativeVariant(pVariantIn);
var c = (char)(ushort)obj;
ki = InputUtil.CharToKeyInput(c);
kind = EditCommandKind.TypeChar;
break;
case VSConstants.VSStd2KCmdID.RETURN:
ki = InputUtil.VimKeyToKeyInput(VimKey.EnterKey);
kind = EditCommandKind.Return;
break;
case VSConstants.VSStd2KCmdID.CANCEL:
ki = InputUtil.VimKeyToKeyInput(VimKey.EscapeKey);
kind = EditCommandKind.Cancel;
break;
case VSConstants.VSStd2KCmdID.DELETE:
ki = InputUtil.VimKeyToKeyInput(VimKey.DeleteKey);
kind = EditCommandKind.Delete;
break;
case VSConstants.VSStd2KCmdID.BACKSPACE:
ki = InputUtil.VimKeyToKeyInput(VimKey.BackKey);
kind = EditCommandKind.Backspace;
break;
case VSConstants.VSStd2KCmdID.LEFT:
ki = InputUtil.VimKeyToKeyInput(VimKey.LeftKey);
break;
case VSConstants.VSStd2KCmdID.RIGHT:
ki = InputUtil.VimKeyToKeyInput(VimKey.RightKey);
break;
case VSConstants.VSStd2KCmdID.UP:
ki = InputUtil.VimKeyToKeyInput(VimKey.UpKey);
break;
case VSConstants.VSStd2KCmdID.DOWN:
ki = InputUtil.VimKeyToKeyInput(VimKey.DownKey);
break;
case VSConstants.VSStd2KCmdID.TAB:
ki = InputUtil.VimKeyToKeyInput(VimKey.TabKey);
break;
default:
break;
}
return ki != null;
}
internal static bool TryConvert(VSConstants.VSStd97CmdID cmdId, IntPtr pVariantIn, out KeyInput ki, out EditCommandKind kind)
{
ki = null;
kind = EditCommandKind.Unknown;
switch (cmdId)
{
case VSConstants.VSStd97CmdID.SingleChar:
var obj = Marshal.GetObjectForNativeVariant(pVariantIn);
var c = (char)(ushort)obj;
ki = InputUtil.CharToKeyInput(c);
kind = EditCommandKind.TypeChar;
break;
case VSConstants.VSStd97CmdID.Escape:
ki = InputUtil.VimKeyToKeyInput(VimKey.EscapeKey);
kind = EditCommandKind.Cancel;
break;
case VSConstants.VSStd97CmdID.Delete:
ki = InputUtil.VimKeyToKeyInput(VimKey.DeleteKey);
kind = EditCommandKind.Delete;
break;
}
return ki != null;
}
/// <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;
}
return(ki != null);
}
internal static bool TryConvert(Guid commandGroup, uint commandId, IntPtr variantIn, out KeyInput keyInput, out EditCommandKind kind)
{
bool unused;
return TryConvert(commandGroup, commandId, variantIn, out keyInput, out kind, out unused);
}
internal static bool TryConvert(Guid commandGroup, uint commandId, IntPtr variantIn, out KeyInput keyInput, out EditCommandKind kind)
{
bool unused;
return(TryConvert(commandGroup, commandId, variantIn, out keyInput, out kind, out unused));
}
/// <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;
}
internal static bool TryConvert(Guid commandGroup, uint commandId, IntPtr variantIn, out KeyInput keyInput, out EditCommandKind kind, out bool isRawText)
{
if (VSConstants.GUID_VSStandardCommandSet97 == commandGroup)
{
return(TryConvert((VSConstants.VSStd97CmdID)commandId, variantIn, out keyInput, out kind, out isRawText));
}
if (VSConstants.VSStd2K == commandGroup)
{
return(TryConvert((VSConstants.VSStd2KCmdID)commandId, variantIn, out keyInput, out kind, out isRawText));
}
if (commandGroup == HiddenCommand.Group && commandId == HiddenCommand.Id)
{
keyInput = KeyInputUtil.CharWithControlToKeyInput(';');
kind = EditCommandKind.UserInput;
isRawText = true;
return(true);
}
keyInput = null;
kind = EditCommandKind.UserInput;
isRawText = false;
return(false);
}
internal EditCommand Create(KeyInput ki, EditCommandKind kind)
{
return new EditCommand(ki, kind, Guid.Empty, 0);
}
internal static bool TryConvert(VSConstants.VSStd2KCmdID cmdId, IntPtr variantIn, out KeyInput ki, out EditCommandKind kind)
{
kind = EditCommandKind.Unknown;
ki = null;
switch (cmdId)
{
case VSConstants.VSStd2KCmdID.TYPECHAR:
if (variantIn == IntPtr.Zero)
{
ki = KeyInputUtil.CharToKeyInput(Char.MinValue);
}
else
{
var obj = Marshal.GetObjectForNativeVariant(variantIn);
var c = (char)(ushort)obj;
ki = KeyInputUtil.CharToKeyInput(c);
}
kind = EditCommandKind.TypeChar;
break;
case VSConstants.VSStd2KCmdID.RETURN:
ki = KeyInputUtil.EnterKey;
kind = EditCommandKind.Return;
break;
case VSConstants.VSStd2KCmdID.CANCEL:
ki = KeyInputUtil.EscapeKey;
kind = EditCommandKind.Cancel;
break;
case VSConstants.VSStd2KCmdID.DELETE:
ki = KeyInputUtil.VimKeyToKeyInput(VimKey.Delete);
kind = EditCommandKind.Delete;
break;
case VSConstants.VSStd2KCmdID.BACKSPACE:
ki = KeyInputUtil.VimKeyToKeyInput(VimKey.Back);
kind = EditCommandKind.Backspace;
break;
case VSConstants.VSStd2KCmdID.LEFT:
case VSConstants.VSStd2KCmdID.LEFT_EXT:
case VSConstants.VSStd2KCmdID.LEFT_EXT_COL:
ki = KeyInputUtil.VimKeyToKeyInput(VimKey.Left);
kind = EditCommandKind.CursorMovement;
break;
case VSConstants.VSStd2KCmdID.RIGHT:
case VSConstants.VSStd2KCmdID.RIGHT_EXT:
case VSConstants.VSStd2KCmdID.RIGHT_EXT_COL:
ki = KeyInputUtil.VimKeyToKeyInput(VimKey.Right);
kind = EditCommandKind.CursorMovement;
break;
case VSConstants.VSStd2KCmdID.UP:
case VSConstants.VSStd2KCmdID.UP_EXT:
case VSConstants.VSStd2KCmdID.UP_EXT_COL:
ki = KeyInputUtil.VimKeyToKeyInput(VimKey.Up);
kind = EditCommandKind.CursorMovement;
break;
case VSConstants.VSStd2KCmdID.DOWN:
case VSConstants.VSStd2KCmdID.DOWN_EXT:
case VSConstants.VSStd2KCmdID.DOWN_EXT_COL:
ki = KeyInputUtil.VimKeyToKeyInput(VimKey.Down);
kind = EditCommandKind.CursorMovement;
break;
case VSConstants.VSStd2KCmdID.TAB:
ki = KeyInputUtil.TabKey;
kind = EditCommandKind.TypeChar;
break;
case VSConstants.VSStd2KCmdID.PAGEDN:
case VSConstants.VSStd2KCmdID.PAGEDN_EXT:
ki = KeyInputUtil.VimKeyToKeyInput(VimKey.PageDown);
kind = EditCommandKind.CursorMovement;
break;
case VSConstants.VSStd2KCmdID.PAGEUP:
case VSConstants.VSStd2KCmdID.PAGEUP_EXT:
ki = KeyInputUtil.VimKeyToKeyInput(VimKey.PageUp);
kind = EditCommandKind.CursorMovement;
break;
case VSConstants.VSStd2KCmdID.UNDO:
case VSConstants.VSStd2KCmdID.UNDONOMOVE:
ki = KeyInput.DefaultValue;
kind = EditCommandKind.Undo;
break;
case VSConstants.VSStd2KCmdID.REDO:
case VSConstants.VSStd2KCmdID.REDONOMOVE:
ki = KeyInput.DefaultValue;
kind = EditCommandKind.Redo;
break;
default:
break;
}
return(ki != null);
}
