/// <summary> /// This method is called to process KeyInput in any fashion by the IVimBuffer. There are /// several cases where we want to defer to Visual Studio and IOleCommandTarget for processing /// of a command. In particular we don't want to process any text input here /// </summary> protected override bool TryProcess(KeyInput keyInput) { if (IsDiscardedKeyInput(keyInput)) { return(true); } // Don't handle input when incremental search is active. Let Visual Studio handle it if (_adapter.IsIncrementalSearchActive(TextView)) { return(false); } // In insert mode we don't want text input going directly to VsVim. Text input must // be routed through Visual Studio and IOleCommandTarget in order to get intellisense // properly hooked up. Not handling it in this KeyProcessor will eventually cause // it to be routed through IOleCommandTarget if it's input // // The Visual Studio KeyProcessor won't pass along control characters that are less than // or equal to 0x1f so we have to handle them here if (VimBuffer.ModeKind.IsAnyInsert() && !VimBuffer.CanProcessAsCommand(keyInput) && (int)keyInput.Char > 0x1f) { return(false); } return(base.TryProcess(keyInput)); }
public VimBufferTest() { _textView = CreateTextView("here we go"); _textView.MoveCaretTo(0); _vimBuffer = Vim.CreateVimBuffer(_textView); _vimBuffer.SwitchMode(ModeKind.Command, ModeArgument.None); _keyMap = _vimBuffer.Vim.KeyMap; _vimBufferRaw = (VimBuffer)_vimBuffer; _factory = new MockRepository(MockBehavior.Strict); }
public void Setup() { _textView = CreateTextView("here we go"); _textView.MoveCaretTo(0); _vimBuffer = Vim.CreateVimBuffer(_textView); _vimBuffer.SwitchMode(ModeKind.Command, ModeArgument.None); _keyMap = _vimBuffer.Vim.KeyMap; _vimBufferRaw = (VimBuffer)_vimBuffer; _factory = new MockRepository(MockBehavior.Strict); }
/// <summary> /// This method is called to process KeyInput in any fashion by the IVimBuffer. There are /// several cases where we want to defer to Visual Studio and IOleCommandTarget for processing /// of a command. In particular we don't want to process any text input here /// </summary> protected override bool TryProcess(KeyInput keyInput) { // If the ITextView doesn't have aggregate focus then this event needs to be discarded. This will // happen when a peek definition window is active. The peek window is a child and if it fails to // process a key event it will bubble up to the parent window. If the peek window has focus the // parent window shouldn't be handling the key if (!_vimHost.IsFocused(TextView)) { return(false); } // Check to see if we should be discarding this KeyInput value. If it is discarded and // made it back to us then we need to pretend that it was handled here if (_bufferCoordinator.IsDiscarded(keyInput)) { return(true); } // Don't handle input when incremental search is active. Let Visual Studio handle it if (_adapter.IsIncrementalSearchActive(TextView)) { VimTrace.TraceInfo("VsKeyProcessor::TryProcess Incremental search active"); return(false); } // In insert mode we don't want text input going directly to VsVim. Text input must // be routed through Visual Studio and IOleCommandTarget in order to get intellisense // properly hooked up. Not handling it in this KeyProcessor will eventually cause // it to be routed through IOleCommandTarget if it's input // // The Visual Studio KeyProcessor won't pass along control characters that are less than // or equal to 0x1f so we have to handle them here if (VimBuffer.ModeKind.IsAnyInsert() && !VimBuffer.CanProcessAsCommand(keyInput) && (int)keyInput.Char > 0x1f) { return(false); } // The report designer will process certain key strokes both through IOleCommandTarget and // then back through the KeyProcessor interface. This happens because they call into IOleCommandTarget // from Control.PreProcessMessage and if the execution succeeds they return false. This // causes it to continue to be processed as a normal message and hence leads to this // interface. Don't process any of these keys twice if (_reportDesignerUtil.IsExpressionView(TextView) && _reportDesignerUtil.IsSpecialHandled(keyInput)) { return(false); } return(base.TryProcess(keyInput)); }
/// <summary> /// This method is called to process KeyInput in any fashion by the IVimBuffer. There are /// several cases where we want to defer to Visual Studio and IOleCommandTarget for processing /// of a command. In particular we don't want to process any text input here /// </summary> protected override bool TryProcess(KeyInput keyInput) { if (IsDiscardedKeyInput(keyInput)) { return(true); } // Don't handle input when incremental search is active. Let Visual Studio handle it if (_adapter.IsIncrementalSearchActive(TextView)) { VimTrace.TraceInfo("VsKeyProcessor::TryProcess Incremental search active"); return(false); } // In insert mode we don't want text input going directly to VsVim. Text input must // be routed through Visual Studio and IOleCommandTarget in order to get intellisense // properly hooked up. Not handling it in this KeyProcessor will eventually cause // it to be routed through IOleCommandTarget if it's input // // The Visual Studio KeyProcessor won't pass along control characters that are less than // or equal to 0x1f so we have to handle them here if (VimBuffer.ModeKind.IsAnyInsert() && !VimBuffer.CanProcessAsCommand(keyInput) && (int)keyInput.Char > 0x1f) { return(false); } // The report designer will process certain key strokes both through IOleCommandTarget and // then back through the KeyProcessor interface. This happens because they call into IOleCommandTarget // from Control.PreProcessMessage and if the execution succeeds they return false. This // causes it to continue to be processed as a normal message and hence leads to this // interface. Don't process any of these keys twice if (_reportDesignerUtil.IsExpressionView(TextView) && _reportDesignerUtil.IsSpecialHandled(keyInput)) { return(false); } return(base.TryProcess(keyInput)); }
/// <summary> /// Handle the case where we need to process a KeyDown but it will be swallowed by the /// TranslateAccelorator chain of input /// /// Must be **very** careful here because of international key board issues. The base /// KeyProcessor in VimWPF has ample documentation on why this is dangerous. In short /// though we must be as specific as possible when choosing keys to filter out because /// mapping a Key at this level to a Vim KeyInput with 100% accuracey is not possible /// </summary> public override void KeyDown(KeyEventArgs args) { base.KeyDown(args); if (args.Handled) { return; } // Don't attempt to handle this if we're in an incremental search if (_adapter.IsIncrementalSearchActive(TextView)) { return; } // Don't process anything unless we're in a case where TranslateAccelorator would // win. Also get rid of the problem cases from the start if (!_adapter.IsReadOnly(TextBuffer) || !KeyUtil.IsInputKey(args.Key) || KeyUtil.IsAltGr(args.KeyboardDevice.Modifiers)) { return; } var handled = false; KeyInput keyInput; if (KeyUtil.TryConvertToKeyInput(args.Key, args.KeyboardDevice.Modifiers, out keyInput)) { // We only want to process input characters here. All other input will eventually // be routed along a more reliable route for us to convert back to Vim KeyInput if (keyInput.KeyModifiers == KeyModifiers.None && KeyUtil.IsMappedByChar(keyInput.Key) && CoreCharacterSet.Contains(keyInput.Char)) { // We intentionally avoid using the TryProcess version here. This is one case // we don't want to defer to Visual Studio. It thinks the buffer is readonly and // will react as such while we want to do actual commands here handled = VimBuffer.CanProcess(keyInput) && VimBuffer.Process(keyInput).IsAnyHandled; } } args.Handled = handled; }
/// <summary> /// Handle the case where we need to process a KeyDown but it will be swallowed by the /// TranslateAccelorator chain of input /// /// Must be **very** careful here because of international key board issues. The base /// KeyProcessor in VimWPF has ample documentation on why this is dangerous. In short /// though we must be as specific as possible when choosing keys to filter out because /// mapping a Key at this level to a Vim KeyInput with 100% accuracey is not possible /// </summary> public override void KeyDown(KeyEventArgs args) { // Don't intercept keystrokse if Visual Studio IncrementalSearch is active if (_adapter.IsIncrementalSearchActive(TextView)) { return; } base.KeyDown(args); if (args.Handled) { return; } // Don't process anything unless we're in a case where TranslateAccelorator would // win. Also get rid of the problem cases from the start if (!_adapter.IsReadOnly(TextBuffer) || !KeyUtil.IsInputKey(args.Key) || KeyUtil.IsAltGr(args.KeyboardDevice.Modifiers)) { return; } var handled = false; KeyInput ki; if (KeyUtil.TryConvertToKeyInput(args.Key, args.KeyboardDevice.Modifiers, out ki)) { // We only want to process input characters here. All other input will eventually // be routed along a more reliable route for us to convert back to Vim KeyInput if (ki.KeyModifiers == KeyModifiers.None && KeyUtil.IsMappedByChar(ki.Key) && CoreCharacterSet.Contains(ki.Char)) { handled = VimBuffer.CanProcess(ki) && VimBuffer.Process(ki); } } args.Handled = handled; }
public void Initialize() { _view = EditorUtil.CreateView("here we go"); _markMap = new MarkMap(new TrackingLineColumnService()); _globalSettings = MockObjectFactory.CreateGlobalSettings(); _settings = MockObjectFactory.CreateLocalSettings(_globalSettings.Object); _keyMap = new Mock<IKeyMap>(MockBehavior.Strict); _host = new Mock<IVimHost>(MockBehavior.Strict); _vim = MockObjectFactory.CreateVim(map:_markMap, settings:_globalSettings.Object, keyMap:_keyMap.Object, host:_host.Object); _disabledMode = new Mock<IMode>(MockBehavior.Strict); _disabledMode.SetupGet(x => x.ModeKind).Returns(ModeKind.Disabled); _normalMode = new Mock<INormalMode>(MockBehavior.Strict); _normalMode.Setup(x => x.OnEnter()); _normalMode.SetupGet(x => x.ModeKind).Returns(ModeKind.Normal); _normalMode.SetupGet(x => x.IsOperatorPending).Returns(false); _normalMode.SetupGet(x => x.IsWaitingForInput).Returns(false); _insertMode = new Mock<IMode>(MockBehavior.Strict); _insertMode.SetupGet(x => x.ModeKind).Returns(ModeKind.Insert); _jumpList = new Mock<IJumpList>(MockBehavior.Strict); _rawBuffer = new VimBuffer( _vim.Object, _view, _jumpList.Object, _settings.Object); _rawBuffer.AddMode(_normalMode.Object); _rawBuffer.AddMode(_insertMode.Object); _rawBuffer.AddMode(_disabledMode.Object); _rawBuffer.SwitchMode(ModeKind.Normal); _buffer = _rawBuffer; }
public void Setup() { _textView = EditorUtil.CreateView("here we go"); _textView.MoveCaretTo(0); _buffer = EditorUtil.FactoryService.Vim.CreateBuffer(_textView); _buffer.SwitchMode(ModeKind.Command, ModeArgument.None); _keyMap = _buffer.Vim.KeyMap; _bufferRaw = (VimBuffer)_buffer; _factory = new MockRepository(MockBehavior.Strict); }
/// <summary> /// Try and process the given KeyInput with the IVimBuffer. This is overridable by /// derived classes in order for them to prevent any KeyInput from reaching the /// IVimBuffer /// </summary> private bool TryProcess(KeyInput keyInput) { return(VimBuffer.CanProcess(keyInput) && VimBuffer.Process(keyInput).IsAnyHandled); }
public void Initialize() { _view = EditorUtil.CreateView("here we go"); _markMap = new MarkMap(new TrackingLineColumnService()); _factory = new MockRepository(MockBehavior.Strict); _globalSettings = MockObjectFactory.CreateGlobalSettings(factory:_factory); _settings = MockObjectFactory.CreateLocalSettings(_globalSettings.Object, factory:_factory); _keyMap = _factory.Create<IKeyMap>(); _host = _factory.Create<IVimHost>(MockBehavior.Strict); _vim = MockObjectFactory.CreateVim(map: _markMap, settings: _globalSettings.Object, keyMap: _keyMap.Object, host: _host.Object, factory:_factory); _disabledMode = _factory.Create<IMode>(MockBehavior.Loose); _disabledMode.SetupGet(x => x.ModeKind).Returns(ModeKind.Disabled); _normalMode = _factory.Create<INormalMode>(MockBehavior.Loose); _normalMode.SetupGet(x => x.KeyRemapMode).Returns(KeyRemapMode.Normal); _normalMode.Setup(x => x.OnEnter(ModeArgument.None)); _normalMode.SetupGet(x => x.ModeKind).Returns(ModeKind.Normal); _insertMode = _factory.Create<IMode>(MockBehavior.Loose); _insertMode.SetupGet(x => x.ModeKind).Returns(ModeKind.Insert); _jumpList = _factory.Create<IJumpList>(MockBehavior.Strict); _incrementalSearch = _factory.Create<IIncrementalSearch>(); _rawBuffer = new VimBuffer( _vim.Object, _view, _jumpList.Object, _settings.Object, _incrementalSearch.Object); _rawBuffer.AddMode(_normalMode.Object); _rawBuffer.AddMode(_insertMode.Object); _rawBuffer.AddMode(_disabledMode.Object); _rawBuffer.SwitchMode(ModeKind.Normal, ModeArgument.None); _buffer = _rawBuffer; }