internal static bool TryConvert(Guid commandGroup, uint commandId, IntPtr pVariableIn, out EditCommand command)
{
KeyInput ki;
EditCommandKind kind;
if (!TryConvert(commandGroup, commandId, pVariableIn, out ki, out kind))
{
command = null;
return false;
}
command = new EditCommand(ki, kind, commandGroup, commandId);
return true;
}
internal static bool TryConvert(Guid commandGroup, uint commandId, IntPtr pVariableIn, KeyModifiers modifiers, out EditCommand command)
{
KeyInput keyInput;
EditCommandKind kind;
if (!TryConvert(commandGroup, commandId, pVariableIn, out keyInput, out kind))
{
command = null;
return false;
}
keyInput = KeyInputUtil.ApplyModifiers(keyInput, modifiers);
command = new EditCommand(keyInput, kind, commandGroup, commandId);
return true;
}
internal static bool TryConvert(Guid commandGroup, uint commandId, IntPtr pVariableIn, KeyModifiers modifiers, out EditCommand command)
{
KeyInput keyInput;
EditCommandKind kind;
bool isRawText;
if (!TryConvert(commandGroup, commandId, pVariableIn, out keyInput, out kind, out isRawText))
{
command = null;
return false;
}
// When raw text is provided it already includes the active keyboard modifiers. Don't reapply them
// here else it can incorrectly modify the provided character.
if (!isRawText)
{
keyInput = KeyInputUtil.ApplyModifiers(keyInput, modifiers);
}
command = new EditCommand(keyInput, kind, commandGroup, commandId);
return true;
}
/// <summary>
/// Try and convert the Visual Studio command to it's equivalent KeyInput
/// </summary>
internal bool TryConvert(Guid commandGroup, uint commandId, IntPtr pvaIn, out EditCommand editCommand)
{
editCommand = null;
// Don't ever process a command when we are in an automation function. Doing so will cause VsVim to
// intercept items like running Macros and certain wizard functionality
if (_adapter.InAutomationFunction)
{
return false;
}
// Don't intercept commands while incremental search is active. Don't want to interfere with it
if (_adapter.IsIncrementalSearchActive(_buffer.TextView))
{
return false;
}
return OleCommandUtil.TryConvert(commandGroup, commandId, pvaIn, out editCommand);
}
internal static bool TryConvert(Guid commandGroup, uint commandId, out EditCommand command)
{
return TryConvert(commandGroup, commandId, IntPtr.Zero, out command);
}
private CommandStatus QueryStatusCore(EditCommand editCommand)
{
VimTrace.TraceInfo("VsCommandTarget::QueryStatus {0}", editCommand);
_bufferCoordinator.DiscardedKeyInput = FSharpOption<KeyInput>.None;
var action = CommandStatus.PassOn;
switch (editCommand.EditCommandKind)
{
case EditCommandKind.Undo:
case EditCommandKind.Redo:
action = CommandStatus.Enable;
break;
case EditCommandKind.Paste:
action = _vimBuffer.ModeKind == ModeKind.Command
? CommandStatus.Enable
: CommandStatus.PassOn;
break;
default:
if (editCommand.HasKeyInput && _vimBuffer.CanProcess(editCommand.KeyInput))
{
action = CommandStatus.Enable;
if (_resharperUtil.IsInstalled)
{
action = QueryStatusInResharper(editCommand.KeyInput) ?? CommandStatus.Enable;
}
}
break;
}
VimTrace.TraceInfo("VsCommandTarget::QueryStatus ", action);
return action;
}
/// <summary>
/// Try and convert the Visual Studio command to it's equivalent KeyInput
/// </summary>
internal bool TryConvert(Guid commandGroup, uint commandId, IntPtr variantIn, out EditCommand editCommand)
{
editCommand = null;
// Don't ever process a command when we are in an automation function. Doing so will cause VsVim to
// intercept items like running Macros and certain wizard functionality
if (_vsAdapter.InAutomationFunction)
{
return false;
}
// Don't intercept commands while incremental search is active. Don't want to interfere with it
if (_vsAdapter.IsIncrementalSearchActive(_vimBuffer.TextView))
{
return false;
}
var modifiers = _keyUtil.GetKeyModifiers(_vsAdapter.KeyboardDevice.Modifiers);
if (!OleCommandUtil.TryConvert(commandGroup, commandId, variantIn, modifiers, out editCommand))
{
return false;
}
// Don't process Visual Studio commands. If the key sequence is mapped to a Visual Studio command
// then that command wins.
if (editCommand.EditCommandKind == EditCommandKind.VisualStudioCommand)
{
return false;
}
return true;
}
internal bool ExecCore(EditCommand editCommand, out Action action)
{
VimTrace.TraceInfo("VsCommandTarget::Exec {0}", editCommand);
action = null;
switch (editCommand.EditCommandKind)
{
case EditCommandKind.Undo:
// The user hit the undo button. Don't attempt to map anything here and instead just
// run a single Vim undo operation
_vimBuffer.UndoRedoOperations.Undo(1);
return true;
case EditCommandKind.Redo:
// The user hit the redo button. Don't attempt to map anything here and instead just
// run a single Vim redo operation
_vimBuffer.UndoRedoOperations.Redo(1);
return true;
case EditCommandKind.Paste:
return Paste();
case EditCommandKind.GoToDefinition:
// The GoToDefinition command will often cause a selection to occur in the
// buffer. We don't want that to cause us to enter Visual Mode so clear it
// out. This command can cause the active document to switch if the target
// of the goto def is in another file. This file won't be registered as the
// active file yet so just clear out the active selections
action = () =>
{
_textManager.TextViews
.Where(x => !x.Selection.IsEmpty)
.ForEach(x => x.Selection.Clear());
};
return false;
case EditCommandKind.Comment:
case EditCommandKind.Uncomment:
// The comment / uncomment command will often induce a selection on the
// editor even if there was no selection before the command was run (single line
// case).
if (_textView.Selection.IsEmpty)
{
action = () => { _textView.Selection.Clear(); };
}
return false;
case EditCommandKind.UserInput:
case EditCommandKind.VisualStudioCommand:
if (editCommand.HasKeyInput)
{
var keyInput = editCommand.KeyInput;
// Discard the input if it's been flagged by a previous QueryStatus
if (_bufferCoordinator.DiscardedKeyInput.IsSome(keyInput))
{
return true;
}
// Try and process the command with the IVimBuffer
if (TryProcessWithBuffer(keyInput))
{
return true;
}
}
return false;
default:
Debug.Assert(false);
return false;
}
}
private bool Exec(EditCommand editCommand)
{
VimTrace.TraceInfo("VsCommandTarget::Exec {0}", editCommand);
if (editCommand.IsUndo)
{
// The user hit the undo button. Don't attempt to map anything here and instead just
// run a single Vim undo operation
_vimBuffer.UndoRedoOperations.Undo(1);
return true;
}
else if (editCommand.IsRedo)
{
// The user hit the redo button. Don't attempt to map anything here and instead just
// run a single Vim redo operation
_vimBuffer.UndoRedoOperations.Redo(1);
return true;
}
else if (editCommand.HasKeyInput)
{
var keyInput = editCommand.KeyInput;
// Discard the input if it's been flagged by a previous QueryStatus
if (_bufferCoordinator.DiscardedKeyInput.IsSome(keyInput))
{
return true;
}
// Try and process the command with the IVimBuffer
if (TryProcessWithBuffer(keyInput))
{
return true;
}
}
return false;
}
internal bool ExecCore(EditCommand editCommand)
{
VimTrace.TraceInfo("VsCommandTarget::Exec {0}", editCommand);
switch (editCommand.EditCommandKind)
{
case EditCommandKind.Undo:
// The user hit the undo button. Don't attempt to map anything here and instead just
// run a single Vim undo operation
_vimBuffer.UndoRedoOperations.Undo(1);
return true;
case EditCommandKind.Redo:
// The user hit the redo button. Don't attempt to map anything here and instead just
// run a single Vim redo operation
_vimBuffer.UndoRedoOperations.Redo(1);
return true;
case EditCommandKind.GoToDefinition:
// Let Visual Studio process this command
return false;
case EditCommandKind.UserInput:
case EditCommandKind.VisualStudioCommand:
if (editCommand.HasKeyInput)
{
var keyInput = editCommand.KeyInput;
// Discard the input if it's been flagged by a previous QueryStatus
if (_bufferCoordinator.DiscardedKeyInput.IsSome(keyInput))
{
return true;
}
// Try and process the command with the IVimBuffer
if (TryProcessWithBuffer(keyInput))
{
return true;
}
}
return false;
default:
Debug.Assert(false);
return false;
}
}
private CommandStatus QueryStatus(EditCommand editCommand)
{
VimTrace.TraceInfo("VsCommandTarget::QueryStatus {0}", editCommand);
var action = CommandStatus.PassOn;
foreach (var commandTarget in _commandTargets)
{
action = commandTarget.QueryStatus(editCommand);
if (action != CommandStatus.PassOn)
{
break;
}
}
VimTrace.TraceInfo("VsCommandTarget::QueryStatus ", action);
return action;
}
internal bool Exec(EditCommand editCommand, out Action action)
{
VimTrace.TraceInfo("VsCommandTarget::Exec {0}", editCommand);
action = null;
// If the KeyInput was already handled then pretend we handled it here
if (editCommand.HasKeyInput && _vimBufferCoordinator.IsDiscarded(editCommand.KeyInput))
{
return true;
}
var result = false;
foreach (var commandTarget in _commandTargets)
{
if (commandTarget.Exec(editCommand, out action))
{
result = true;
break;
}
}
return result;
}
internal static bool TryConvert(EditCommand editCommand, out OleCommandData oleCommandData)
{
switch (editCommand.EditCommandKind)
{
case EditCommandKind.GoToDefinition:
oleCommandData = new OleCommandData(VSConstants.VSStd97CmdID.GotoDecl);
return true;
case EditCommandKind.Paste:
oleCommandData = new OleCommandData(VSConstants.VSStd2KCmdID.PASTE);
return true;
case EditCommandKind.Undo:
oleCommandData = new OleCommandData(VSConstants.VSStd2KCmdID.UNDO);
return true;
case EditCommandKind.Redo:
oleCommandData = new OleCommandData(VSConstants.VSStd2KCmdID.REDO);
return true;
case EditCommandKind.Comment:
oleCommandData = new OleCommandData(VSConstants.VSStd2KCmdID.COMMENTBLOCK);
return true;
case EditCommandKind.Uncomment:
oleCommandData = new OleCommandData(VSConstants.VSStd2KCmdID.UNCOMMENTBLOCK);
return true;
case EditCommandKind.UserInput:
return TryConvert(editCommand.KeyInput, out oleCommandData);
case EditCommandKind.VisualStudioCommand:
default:
oleCommandData = OleCommandData.Empty;
return false;
}
}
internal bool ExecCore(EditCommand editCommand, out Action action)
{
VimTrace.TraceInfo("VsCommandTarget::Exec {0}", editCommand);
action = null;
switch (editCommand.EditCommandKind)
{
case EditCommandKind.Undo:
// The user hit the undo button. Don't attempt to map anything here and instead just
// run a single Vim undo operation
_vimBuffer.UndoRedoOperations.Undo(1);
return(true);
case EditCommandKind.Redo:
// The user hit the redo button. Don't attempt to map anything here and instead just
// run a single Vim redo operation
_vimBuffer.UndoRedoOperations.Redo(1);
return(true);
case EditCommandKind.Paste:
return(Paste());
case EditCommandKind.GoToDefinition:
// The GoToDefinition command will often cause a selection to occur in the
// buffer. We don't want that to cause us to enter Visual Mode so clear it
// out. This command can cause the active document to switch if the target
// of the goto def is in another file. This file won't be registered as the
// active file yet so just clear out the active selections
action = () =>
{
_textManager.TextViews
.Where(x => !x.Selection.IsEmpty)
.ForEach(x => x.Selection.Clear());
};
return(false);
case EditCommandKind.Comment:
case EditCommandKind.Uncomment:
// The comment / uncomment command will often induce a selection on the
// editor even if there was no selection before the command was run (single line
// case).
if (_textView.Selection.IsEmpty)
{
action = () => { _textView.Selection.Clear(); };
}
return(false);
case EditCommandKind.UserInput:
case EditCommandKind.VisualStudioCommand:
if (editCommand.HasKeyInput)
{
var keyInput = editCommand.KeyInput;
// Discard the input if it's been flagged by a previous QueryStatus
if (_bufferCoordinator.DiscardedKeyInput.IsSome(keyInput))
{
return(true);
}
// Try and process the command with the IVimBuffer
if (TryProcessWithBuffer(keyInput))
{
return(true);
}
}
return(false);
default:
Debug.Assert(false);
return(false);
}
}
/// <summary>
/// Try and convert the Visual Studio command to it's equivalent KeyInput
/// </summary>
internal bool TryConvert(Guid commandGroup, uint commandId, IntPtr variantIn, out EditCommand editCommand)
{
editCommand = null;
// Don't ever process a command when we are in an automation function. Doing so will cause VsVim to
// intercept items like running Macros and certain wizard functionality
if (_vsAdapter.InAutomationFunction)
{
return(false);
}
// Don't intercept commands while incremental search is active. Don't want to interfere with it
if (_vsAdapter.IsIncrementalSearchActive(_vimBuffer.TextView))
{
return(false);
}
var modifiers = _keyUtil.GetKeyModifiers(_vsAdapter.KeyboardDevice.Modifiers);
if (!OleCommandUtil.TryConvert(commandGroup, commandId, variantIn, modifiers, out editCommand))
{
return(false);
}
// Don't process Visual Studio commands. If the key sequence is mapped to a Visual Studio command
// then that command wins.
if (editCommand.EditCommandKind == EditCommandKind.VisualStudioCommand)
{
return(false);
}
return(true);
}
