public void OnTextInput(TextInputEventArgs e, int caretIndex, int line, int column)
        {
            if (e.Source == editor)
            {
                intellisenseJobRunner.InvokeAsync(() =>
                {
                    if (e.Text.Length == 1)
                    {
                        char currentChar = e.Text[0];

                        if (completionAssistant.IsVisible)
                        {
                            if (caretIndex < completionAssistant.CurrentSignatureHelp.Offset)
                            {
                                Dispatcher.UIThread.InvokeTaskAsync(() =>
                                {
                                    completionAssistant.PopMethod();
                                }).Wait();
                            }

                            if (completionAssistant.CurrentSignatureHelp != null)
                            {
                                int index = 0;
                                int level = 0;
                                int offset = completionAssistant.CurrentSignatureHelp.Offset;

                                while (offset < caretIndex)
                                {
                                    var curChar = '\0';

                                    Dispatcher.UIThread.InvokeTaskAsync(() =>
                                    {
                                        curChar = editor.TextDocument.GetCharAt(offset++);
                                    }).Wait();

                                    switch (curChar)
                                    {
                                        case ',':
                                            if (level == 0)
                                            {
                                                index++;
                                            }
                                            break;

                                        case '(':
                                            level++;
                                            break;

                                        case ')':
                                            level--;
                                            break;
                                    }
                                }

                                completionAssistant.SetParameterIndex(index);
                            }
                        }

                        if (currentChar == '(' && (completionAssistant.CurrentSignatureHelp == null || completionAssistant.CurrentSignatureHelp.Offset != editor.CaretIndex))
                        {
                            string currentWord = string.Empty;

                            char behindBehindCaretChar = '\0';

                            Dispatcher.UIThread.InvokeTaskAsync(() =>
                            {
                                behindBehindCaretChar = editor.TextDocument.GetCharAt(caretIndex - 2);
                            }).Wait();

                            if (behindBehindCaretChar.IsWhiteSpace() && behindBehindCaretChar != '\0')
                            {
                                Dispatcher.UIThread.InvokeTaskAsync(() =>
                                {
                                    currentWord = editor.GetPreviousWordAtIndex(editor.CaretIndex - 1);
                                }).Wait();
                            }
                            else
                            {
                                Dispatcher.UIThread.InvokeTaskAsync(() =>
                                {
                                    currentWord = editor.GetWordAtIndex(editor.CaretIndex - 1);
                                }).Wait();
                            }

                            var signatureHelpTask = languageService.SignatureHelp(file, EditorModel.UnsavedFiles.FirstOrDefault(), EditorModel.UnsavedFiles.ToList(), line, column, editor.CaretIndex, currentWord);
                            signatureHelpTask.Wait();

                            var signatureHelp = signatureHelpTask.Result;

                            if (signatureHelp != null)
                            {
                                Dispatcher.UIThread.InvokeTaskAsync(() =>
                                {
                                    completionAssistant.PushMethod(signatureHelp);
                                }).Wait();
                            }
                        }
                        else if (currentChar == ')')
                        {
                            Dispatcher.UIThread.InvokeTaskAsync(() =>
                            {
                                completionAssistant.PopMethod();
                            }).Wait();
                        }

                        if (IsCompletionChar(currentChar))
                        {
                            DoComplete(true);
                        }

                        if (currentChar.IsWhiteSpace() || IsSearchChar(currentChar))
                        {
                            SetCursor(caretIndex, line, column, EditorModel.UnsavedFiles.ToList(), false);
                        }

                        if (IsTriggerChar(currentChar, intellisenseControl.IsVisible) || IsLanguageSpecificTriggerChar(currentChar))
                        {
                            if (!intellisenseControl.IsVisible)
                            {
                                OpenIntellisense(currentChar, caretIndex);
                            }
                            else if (caretIndex > intellisenseStartedAt)
                            {
                                UpdateFilter(caretIndex);
                            }
                            else
                            {
                                CloseIntellisense();
                                SetCursor(caretIndex, line, column, EditorModel.UnsavedFiles.ToList(), false);
                            }

                            isProcessingKey = intellisenseControl.IsVisible;
                        }
                    }
                });
            }
        }
예제 #2
0
 /// <summary>
 /// Called before the <see cref="TextInput"/> event occurs.
 /// </summary>
 /// <param name="e">The event args.</param>
 protected virtual void OnTextInput(TextInputEventArgs e)
 {
 }
예제 #3
0
        /// <summary>
        /// Processes an input event.
        /// </summary>
        /// <param name="e">The input event arguments.</param>
        private void ProcessRawEvent(RawInputEventArgs e)
        {
            IInputElement element = FocusedElement;

            if (element != null)
            {
                var keyInput = e as RawKeyEventArgs;

                if (keyInput != null)
                {
                    switch (keyInput.Type)
                    {
                    case RawKeyEventType.KeyDown:
                    case RawKeyEventType.KeyUp:
                        var routedEvent = keyInput.Type == RawKeyEventType.KeyDown
                                ? InputElement.KeyDownEvent
                                : InputElement.KeyUpEvent;

                        KeyEventArgs ev = new KeyEventArgs
                        {
                            RoutedEvent = routedEvent,
                            Device      = this,
                            Key         = keyInput.Key,
                            Modifiers   = keyInput.Modifiers,
                            Source      = element,
                        };

                        IVisual currentHandler = element;
                        while (currentHandler != null && !ev.Handled && keyInput.Type == RawKeyEventType.KeyDown)
                        {
                            var bindings = (currentHandler as IInputElement)?.KeyBindings;
                            if (bindings != null)
                            {
                                foreach (var binding in bindings)
                                {
                                    if (ev.Handled)
                                    {
                                        break;
                                    }
                                    binding.TryHandle(ev);
                                }
                            }
                            currentHandler = currentHandler.VisualParent;
                        }

                        element.RaiseEvent(ev);
                        e.Handled = ev.Handled;
                        break;
                    }
                }

                var text = e as RawTextInputEventArgs;

                if (text != null)
                {
                    var ev = new TextInputEventArgs()
                    {
                        Device      = this,
                        Text        = text.Text,
                        Source      = element,
                        RoutedEvent = InputElement.TextInputEvent
                    };

                    element.RaiseEvent(ev);
                    e.Handled = ev.Handled;
                }
            }
        }
예제 #4
0
        public void ProcessRawEvent(RawInputEventArgs e)
        {
            if (e.Handled)
            {
                return;
            }

            var element = FocusedElement ?? e.Root;

            if (e is RawKeyEventArgs keyInput)
            {
                switch (keyInput.Type)
                {
                case RawKeyEventType.KeyDown:
                case RawKeyEventType.KeyUp:
                    var routedEvent = keyInput.Type == RawKeyEventType.KeyDown
                            ? InputElement.KeyDownEvent
                            : InputElement.KeyUpEvent;

                    KeyEventArgs ev = new KeyEventArgs
                    {
                        RoutedEvent  = routedEvent,
                        Device       = this,
                        Key          = keyInput.Key,
                        KeyModifiers = KeyModifiersUtils.ConvertToKey(keyInput.Modifiers),
                        Source       = element,
                    };

                    IVisual?currentHandler = element;
                    while (currentHandler != null && !ev.Handled && keyInput.Type == RawKeyEventType.KeyDown)
                    {
                        var bindings = (currentHandler as IInputElement)?.KeyBindings;
                        if (bindings != null)
                        {
                            KeyBinding[]? bindingsCopy = null;

                            // Create a copy of the KeyBindings list if there's a binding which matches the event.
                            // If we don't do this the foreach loop will throw an InvalidOperationException when the KeyBindings list is changed.
                            // This can happen when a new view is loaded which adds its own KeyBindings to the handler.
                            foreach (var binding in bindings)
                            {
                                if (binding.Gesture?.Matches(ev) == true)
                                {
                                    bindingsCopy = bindings.ToArray();
                                    break;
                                }
                            }

                            if (bindingsCopy is object)
                            {
                                foreach (var binding in bindingsCopy)
                                {
                                    if (ev.Handled)
                                    {
                                        break;
                                    }
                                    binding.TryHandle(ev);
                                }
                            }
                        }
                        currentHandler = currentHandler.VisualParent;
                    }

                    element.RaiseEvent(ev);
                    e.Handled = ev.Handled;
                    break;
                }
            }

            if (e is RawTextInputEventArgs text)
            {
                var ev = new TextInputEventArgs()
                {
                    Device      = this,
                    Text        = text.Text,
                    Source      = element,
                    RoutedEvent = InputElement.TextInputEvent
                };

                element.RaiseEvent(ev);
                e.Handled = ev.Handled;
            }
        }
예제 #5
0
 protected override void OnTextInput(TextInputEventArgs e)
 {
     HandleTextInput(e.Text);
 }
예제 #6
0
        private void ProcessRawEvent(RawInputEventArgs e)
        {
            IInputElement element = FocusedElement;

            if (element != null)
            {
                var keyInput = e as RawKeyEventArgs;

                if (keyInput != null)
                {
                    switch (keyInput.Type)
                    {
                        case RawKeyEventType.KeyDown:
                        case RawKeyEventType.KeyUp:
                            var routedEvent = keyInput.Type == RawKeyEventType.KeyDown
                                ? InputElement.KeyDownEvent
                                : InputElement.KeyUpEvent;

                            KeyEventArgs ev = new KeyEventArgs
                            {
                                RoutedEvent = routedEvent,
                                Device = this,
                                Key = keyInput.Key,
                                Modifiers = keyInput.Modifiers,
                                Source = element,
                            };

                            IVisual currentHandler = element;
                            while (currentHandler != null && !ev.Handled && keyInput.Type == RawKeyEventType.KeyDown)
                            {
                                var bindings = (currentHandler as IInputElement)?.KeyBindings;
                                if(bindings!=null)
                                    foreach (var binding in bindings)
                                    {
                                        if(ev.Handled)
                                            break;
                                        binding.TryHandle(ev);
                                    }
                                currentHandler = currentHandler.VisualParent;
                            }

                            element.RaiseEvent(ev);
                            e.Handled = ev.Handled;
                            break;
                    }
                }

                var text = e as RawTextInputEventArgs;

                if (text != null)
                {
                    var ev = new TextInputEventArgs()
                    {
                        Device = this,
                        Text = text.Text,
                        Source = element,
                        RoutedEvent = InputElement.TextInputEvent
                    };

                    element.RaiseEvent(ev);
                    e.Handled = ev.Handled;
                }
            }
        }
예제 #7
0
        public void ProcessRawEvent(RawInputEventArgs e)
        {
            if (e.Handled)
            {
                return;
            }

            var element = FocusedElement ?? e.Root;

            if (e is RawKeyEventArgs keyInput)
            {
                switch (keyInput.Type)
                {
                case RawKeyEventType.KeyDown:
                case RawKeyEventType.KeyUp:
                    var routedEvent = keyInput.Type == RawKeyEventType.KeyDown
                            ? InputElement.KeyDownEvent
                            : InputElement.KeyUpEvent;

                    KeyEventArgs ev = new KeyEventArgs
                    {
                        RoutedEvent  = routedEvent,
                        Device       = this,
                        Key          = keyInput.Key,
                        KeyModifiers = KeyModifiersUtils.ConvertToKey(keyInput.Modifiers),
                        Source       = element,
                    };

                    IVisual currentHandler = element;
                    while (currentHandler != null && !ev.Handled && keyInput.Type == RawKeyEventType.KeyDown)
                    {
                        var bindings = (currentHandler as IInputElement)?.KeyBindings;
                        if (bindings != null)
                        {
                            foreach (var binding in bindings)
                            {
                                if (ev.Handled)
                                {
                                    break;
                                }
                                binding.TryHandle(ev);
                            }
                        }
                        currentHandler = currentHandler.VisualParent;
                    }

                    element.RaiseEvent(ev);
                    e.Handled = ev.Handled;
                    break;
                }
            }

            if (e is RawTextInputEventArgs text)
            {
                var ev = new TextInputEventArgs()
                {
                    Device      = this,
                    Text        = text.Text,
                    Source      = element,
                    RoutedEvent = InputElement.TextInputEvent
                };

                element.RaiseEvent(ev);
                e.Handled = ev.Handled;
            }
        }
예제 #8
0
 /// <summary>
 /// Called before the <see cref="TextInput"/> event occurs.
 /// </summary>
 /// <param name="e">The event args.</param>
 protected virtual void OnTextInput(TextInputEventArgs e)
 {
 }
        /// <summary>
        /// Handles a key being pressed in the menu.
        /// </summary>
        /// <param name="sender">The event sender.</param>
        /// <param name="e">The event args.</param>
        protected virtual void OnTextInput(object sender, TextInputEventArgs e)
        {
            if (!string.IsNullOrWhiteSpace(e.Text))
            {
                var text = e.Text.ToUpper();
                var focus = _registered
                    .FirstOrDefault(x => x.Item1 == text && x.Item2.IsEffectivelyVisible)?.Item2;

                focus?.RaiseEvent(new RoutedEventArgs(AccessKeyHandler.AccessKeyPressedEvent));

                e.Handled = true;
            }
        }