Beispiel #1
0
            /// <summary>
            /// Try and exec the given KeyInput
            /// </summary>
            private bool TryExec(KeyInput keyInput)
            {
                if (keyInput.Key == VimKey.Back)
                {
                    _editorOperatins.Backspace();
                    return(true);
                }

                _editorOperatins.InsertText(keyInput.Char.ToString());
                return(true);
            }
Beispiel #2
0
            /// <summary>
            /// Try and exec the given KeyInput
            /// </summary>
            private bool TryExec(KeyInput keyInput)
            {
                switch (keyInput.Key)
                {
                case VimKey.Left:
                    _editorOperatins.MoveToPreviousCharacter(extendSelection: keyInput.KeyModifiers == VimKeyModifiers.Shift);
                    return(true);

                case VimKey.Right:
                    _editorOperatins.MoveToNextCharacter(extendSelection: keyInput.KeyModifiers == VimKeyModifiers.Shift);
                    return(true);

                case VimKey.Up:
                    _editorOperatins.MoveLineUp(extendSelection: keyInput.KeyModifiers == VimKeyModifiers.Shift);
                    return(true);

                case VimKey.Down:
                    _editorOperatins.MoveLineDown(extendSelection: keyInput.KeyModifiers == VimKeyModifiers.Shift);
                    return(true);

                case VimKey.Back:
                    _editorOperatins.Backspace();
                    return(true);

                case VimKey.Tab:
                    if (keyInput.KeyModifiers == VimKeyModifiers.Shift)
                    {
                        _editorOperatins.Unindent();
                    }
                    else
                    {
                        _editorOperatins.Indent();
                    }
                    return(true);
                }

                if (char.IsLetterOrDigit(keyInput.Char))
                {
                    _editorOperatins.InsertText(keyInput.Char.ToString());
                    return(true);
                }

                return(false);
            }
Beispiel #3
0
 public void SendBackspace()
 {
     EditorOperations.Backspace();
 }
Beispiel #4
0
        public CommandResult Invoke(Guid group, int id, object args, ref object outargs)
        {
            CommandResult result = _braceCompletionTarget.Invoke(group, id, args, ref outargs);

            if (result.WasExecuted)
            {
                return(result);
            }

            if (group == VSConstants.VSStd2K)
            {
                switch (id)
                {
                case (int)VSConstants.VSStd2KCmdID.TYPECHAR:
                    string text;
                    if (args is char)
                    {
                        text = args.ToString();
                    }
                    else
                    {
                        text = Char.ConvertFromUtf32((System.UInt16)args);
                    }

                    result = this.PerformEditAction(() => _editorOperations.InsertText(text));
                    break;

                case (int)VSConstants.VSStd2KCmdID.BACKSPACE:
                    result = this.PerformEditAction(() => _editorOperations.Backspace());
                    break;

                case (int)VSConstants.VSStd2KCmdID.DELETE:
                    result = this.PerformEditAction(() => _editorOperations.Delete());
                    break;

                case (int)VSConstants.VSStd2KCmdID.CANCEL:
                    _editorOperations.ResetSelection();
                    break;

                case (int)VSConstants.VSStd2KCmdID.DOWN_EXT:
                    _editorOperations.MoveLineDown(true);
                    break;

                case (int)VSConstants.VSStd2KCmdID.DOWN:
                    _editorOperations.MoveLineDown(false);
                    break;

                case (int)VSConstants.VSStd2KCmdID.RIGHT_EXT:
                    _editorOperations.MoveToNextCharacter(true);
                    break;

                case (int)VSConstants.VSStd2KCmdID.RIGHT:
                    _editorOperations.MoveToNextCharacter(false);
                    break;

                case (int)VSConstants.VSStd2KCmdID.LEFT_EXT:
                    _editorOperations.MoveToPreviousCharacter(true);
                    break;

                case (int)VSConstants.VSStd2KCmdID.LEFT:
                    _editorOperations.MoveToPreviousCharacter(false);
                    break;

                case (int)VSConstants.VSStd2KCmdID.UP_EXT:
                    _editorOperations.MoveLineUp(true);
                    break;

                case (int)VSConstants.VSStd2KCmdID.UP:
                    _editorOperations.MoveLineUp(false);
                    break;

                case (int)VSConstants.VSStd2KCmdID.HOME_EXT:
                    _editorOperations.MoveToHome(true);
                    break;

                case (int)VSConstants.VSStd2KCmdID.HOME:
                    _editorOperations.MoveToHome(false);
                    break;

                case (int)VSConstants.VSStd2KCmdID.PAGEUP_EXT:
                    _editorOperations.PageUp(true);
                    break;

                case (int)VSConstants.VSStd2KCmdID.PAGEUP:
                    _editorOperations.PageUp(false);
                    break;

                case (int)VSConstants.VSStd2KCmdID.PAGEDN_EXT:
                    _editorOperations.PageDown(true);
                    break;

                case (int)VSConstants.VSStd2KCmdID.PAGEDN:
                    _editorOperations.PageDown(false);
                    break;

                case (int)VSConstants.VSStd2KCmdID.END_EXT:
                    _editorOperations.MoveToEndOfLine(true);
                    break;

                case (int)VSConstants.VSStd2KCmdID.END:
                    _editorOperations.MoveToEndOfLine(false);
                    break;

                case (int)VSConstants.VSStd2KCmdID.BACKTAB:
                    result = this.PerformEditAction(() => _editorOperations.Unindent());
                    break;

                case (int)VSConstants.VSStd2KCmdID.TAB:
                    result = this.PerformEditAction(() => _editorOperations.Indent());
                    break;

                case (int)VSConstants.VSStd2KCmdID.RETURN:
                    result = this.PerformEditAction(() => _editorOperations.InsertNewLine());
                    break;

                case (int)VSConstants.VSStd2KCmdID.CTLMOVERIGHT:
                    _editorOperations.MoveToNextWord(true);
                    break;

                case (int)VSConstants.VSStd2KCmdID.CTLMOVELEFT:
                    _editorOperations.MoveToPreviousWord(true);
                    break;

                case (int)VSConstants.VSStd2KCmdID.TOPLINE_EXT:
                    _editorOperations.MoveToStartOfDocument(true);
                    break;

                case (int)VSConstants.VSStd2KCmdID.BOTTOMLINE_EXT:
                    _editorOperations.MoveToEndOfDocument(true);
                    break;

                case (int)VSConstants.VSStd2KCmdID.INSERT:
                    bool isEnabled = _editorOperations.Options.IsOverwriteModeEnabled();
                    _editorOperations.Options.SetOptionValue(DefaultTextViewOptions.OverwriteModeId, !isEnabled);
                    break;

                case (int)VSConstants.VSStd2KCmdID.DELETEWORDLEFT:
                    result = this.PerformEditAction(() => _editorOperations.DeleteWordToLeft());
                    break;

                case (int)VSConstants.VSStd2KCmdID.DELETEWORDRIGHT:
                    result = this.PerformEditAction(() => _editorOperations.DeleteWordToRight());
                    break;

                case (int)VSConstants.VSStd2KCmdID.SELECTALL:
                    _editorOperations.SelectAll();
                    break;

                case (int)VSConstants.VSStd2KCmdID.SELECTCURRENTWORD:
                    _editorOperations.SelectCurrentWord();
                    break;

                case (int)VSConstants.VSStd2KCmdID.WORDNEXT:
                    _editorOperations.MoveToNextWord(false);
                    break;

                case (int)VSConstants.VSStd2KCmdID.WORDPREV:
                    _editorOperations.MoveToPreviousWord(false);
                    break;

                case (int)VSConstants.VSStd2KCmdID.TOPLINE:
                    _editorOperations.MoveToStartOfDocument(false);
                    break;

                case (int)VSConstants.VSStd2KCmdID.BOTTOMLINE:
                    _editorOperations.MoveToEndOfDocument(false);
                    break;

                case (int)VSConstants.VSStd2KCmdID.SCROLLUP:
                    _editorOperations.ScrollUpAndMoveCaretIfNecessary();
                    break;

                case (int)VSConstants.VSStd2KCmdID.SCROLLDN:
                    _editorOperations.ScrollDownAndMoveCaretIfNecessary();
                    break;

                case (int)VSConstants.VSStd2KCmdID.COPY:
                    _editorOperations.CopySelection();
                    break;

                case (int)VSConstants.VSStd2KCmdID.CUT:
                    return(this.PerformEditAction(() => _editorOperations.CutSelection()));

                case (int)VSConstants.VSStd2KCmdID.PASTE:
                    string pastedText = args as string;

                    if (pastedText != null)
                    {
                        return(this.PerformEditAction(() => _editorOperations.InsertText(pastedText)));
                    }
                    else
                    {
                        return(this.PerformEditAction(() => _editorOperations.Paste()));
                    }

                case (int)VSConstants.VSStd2KCmdID.UNDO:

                    if (UndoManager != null &&
                        UndoManager.TextBufferUndoHistory.CanUndo)
                    {
                        UndoManager.TextBufferUndoHistory.Undo(1);
                        break;
                    }

                    return(CommandResult.Disabled);

                case (int)VSConstants.VSStd2KCmdID.REDO:

                    if (UndoManager != null &&
                        UndoManager.TextBufferUndoHistory.CanRedo)
                    {
                        UndoManager.TextBufferUndoHistory.Redo(1);
                        break;
                    }

                    return(CommandResult.Disabled);

                default:
                    return(CommandResult.NotSupported);
                }

                _braceCompletionTarget.PostProcessInvoke(CommandResult.Executed, group, id, args, ref outargs);
                return(result);
            }

            return(CommandResult.NotSupported);
        }
Beispiel #5
0
        public void SendBackspace()
        {
            var backspaceHandler = (ICommandHandler <BackspaceKeyCommandArgs>)CompletionCommandHandler;

            backspaceHandler.ExecuteCommand(new BackspaceKeyCommandArgs(_view, _view.TextBuffer), () => _editorOperations.Backspace());
        }
 public virtual void SendBackspace()
 => EditorOperations.Backspace();