Exemple #1
0
            protected override void ExecuteDefaultActionAtTarget(EventBase evt)
            {
                base.ExecuteDefaultActionAtTarget(evt);

                if (evt == null)
                {
                    return;
                }

                if (evt.eventTypeId == KeyDownEvent.TypeId())
                {
                    KeyDownEvent kde = evt as KeyDownEvent;

                    if (!parentTextField.isDelayed || (!multiline && ((kde?.keyCode == KeyCode.KeypadEnter) || (kde?.keyCode == KeyCode.Return))))
                    {
                        parentTextField.value = text;
                    }

                    if (multiline)
                    {
                        if (kde?.character == '\t' && kde.modifiers == EventModifiers.None)
                        {
                            kde?.StopPropagation();
                            kde?.PreventDefault();
                        }
                        else if (((kde?.character == 3) && (kde?.shiftKey == true)) ||  // KeyCode.KeypadEnter
                                 ((kde?.character == '\n') && (kde?.shiftKey == true))) // KeyCode.Return
                        {
                            parent.Focus();
                            evt.StopPropagation();
                            evt.PreventDefault();
                        }
                    }
                    else if ((kde?.character == 3) ||    // KeyCode.KeypadEnter
                             (kde?.character == '\n'))   // KeyCode.Return
                    {
                        parent.Focus();
                        evt.StopPropagation();
                        evt.PreventDefault();
                    }
                }
                else if (evt.eventTypeId == ExecuteCommandEvent.TypeId())
                {
                    ExecuteCommandEvent commandEvt = evt as ExecuteCommandEvent;
                    string cmdName = commandEvt.commandName;
                    if (!parentTextField.isDelayed && (cmdName == EventCommandNames.Paste || cmdName == EventCommandNames.Cut))
                    {
                        parentTextField.value = text;
                    }
                }
                // Prevent duplicated navigation events, since we're observing KeyDownEvents instead
                else if (evt.eventTypeId == NavigationSubmitEvent.TypeId() ||
                         evt.eventTypeId == NavigationCancelEvent.TypeId() ||
                         evt.eventTypeId == NavigationMoveEvent.TypeId())
                {
                    evt.StopPropagation();
                    evt.PreventDefault();
                }
            }
            protected internal override void ExecuteDefaultActionAtTarget(EventBase evt)
            {
                base.ExecuteDefaultActionAtTarget(evt);
                if (evt == null)
                {
                    return;
                }

                if (evt.eventTypeId == KeyDownEvent.TypeId())
                {
                    KeyDownEvent kde = evt as KeyDownEvent;

                    if (!parentTextField.isDelayed || (!multiline && ((kde?.keyCode == KeyCode.KeypadEnter) || (kde?.keyCode == KeyCode.Return))))
                    {
                        parentTextField.value = text;
                    }

                    if (multiline)
                    {
                        if (kde?.character == '\t')
                        {
                            kde?.StopPropagation();
                            kde?.PreventDefault();
                        }
                        else if (((kde?.character == 3) && (kde?.shiftKey == true)) ||  // KeyCode.KeypadEnter
                                 ((kde?.character == '\n') && (kde?.shiftKey == true))) // KeyCode.Return
                        {
                            parent.Focus();
                        }
                    }
                    else if ((kde?.character == 3) ||    // KeyCode.KeypadEnter
                             (kde?.character == '\n'))   // KeyCode.Return
                    {
                        parent.Focus();
                    }
                }
                else if (evt.eventTypeId == ExecuteCommandEvent.TypeId())
                {
                    ExecuteCommandEvent commandEvt = evt as ExecuteCommandEvent;
                    string cmdName = commandEvt.commandName;
                    if (!parentTextField.isDelayed && (cmdName == EventCommandNames.Paste || cmdName == EventCommandNames.Cut))
                    {
                        parentTextField.value = text;
                    }
                }
            }
        void OnKeyDown(KeyDownEvent evt)
        {
            SliderKey sliderKey    = SliderKey.None;
            bool      isHorizontal = direction == SliderDirection.Horizontal;

            if (isHorizontal && evt.keyCode == KeyCode.Home || !isHorizontal && evt.keyCode == KeyCode.End)
            {
                sliderKey = inverted ? SliderKey.Highest : SliderKey.Lowest;
            }
            else if (isHorizontal && evt.keyCode == KeyCode.End || !isHorizontal && evt.keyCode == KeyCode.Home)
            {
                sliderKey = inverted ? SliderKey.Lowest : SliderKey.Highest;
            }
            else if (isHorizontal && evt.keyCode == KeyCode.PageUp || !isHorizontal && evt.keyCode == KeyCode.PageDown)
            {
                sliderKey = inverted ? SliderKey.HigherPage : SliderKey.LowerPage;
            }
            else if (isHorizontal && evt.keyCode == KeyCode.PageDown || !isHorizontal && evt.keyCode == KeyCode.PageUp)
            {
                sliderKey = inverted ? SliderKey.LowerPage : SliderKey.HigherPage;
            }
            else if (isHorizontal && evt.keyCode == KeyCode.LeftArrow || !isHorizontal && evt.keyCode == KeyCode.DownArrow)
            {
                sliderKey = inverted ? SliderKey.Higher : SliderKey.Lower;
            }
            else if (isHorizontal && evt.keyCode == KeyCode.RightArrow || !isHorizontal && evt.keyCode == KeyCode.UpArrow)
            {
                sliderKey = inverted ? SliderKey.Lower : SliderKey.Higher;
            }

            if (sliderKey == SliderKey.None)
            {
                return;
            }

            ComputeValueFromKey(sliderKey, evt.shiftKey);
            evt.StopPropagation();
        }
Exemple #4
0
        public void OnKeyDown(KeyDownEvent evt)
        {
            int     selectedIndex = this.m_ListView.selectedIndex;
            bool    flag          = true;
            KeyCode keyCode       = evt.keyCode;
            KeyCode keyCode2      = keyCode;

            if (keyCode2 != KeyCode.RightArrow)
            {
                if (keyCode2 != KeyCode.LeftArrow)
                {
                    flag = false;
                }
                else
                {
                    bool flag2 = this.IsExpandedByIndex(selectedIndex);
                    if (flag2)
                    {
                        this.CollapseItemByIndex(selectedIndex);
                    }
                }
            }
            else
            {
                bool flag3 = !this.IsExpandedByIndex(selectedIndex);
                if (flag3)
                {
                    this.ExpandItemByIndex(selectedIndex);
                }
            }
            bool flag4 = flag;

            if (flag4)
            {
                evt.StopPropagation();
            }
        }
Exemple #5
0
        void OnKeyDown(KeyDownEvent evt)
        {
            if (!textInputField.hasFocus)
            {
                return;
            }

            textInputField.SyncTextEngine();
            m_Changed = false;

            // Check for action keys.
            if (editorEngine.HandleKeyEvent(evt.imguiEvent, textInputField.isReadOnly))
            {
                if (textInputField.text != editorEngine.text)
                {
                    m_Changed = true;
                }
                evt.StopPropagation();
            }
            else
            {
                char c = evt.character;

                // Ignore tab & shift-tab in single-line text fields
                if (!editorEngine.multiline && (evt.keyCode == KeyCode.Tab || c == '\t'))
                {
                    return;
                }

                // Ignore modifier+tab in multiline text fields
                if (editorEngine.multiline && (evt.keyCode == KeyCode.Tab || c == '\t') && evt.modifiers != EventModifiers.None)
                {
                    return;
                }

                evt.StopPropagation();

                if (c == '\n' && !editorEngine.multiline && !evt.altKey)
                {
                    return;
                }

                // When the newline character is sent, we have to check if the shift key is down also...
                // In the multiline case, this is like a return on a single line
                if (c == '\n' && editorEngine.multiline && evt.shiftKey)
                {
                    return;
                }

                if (!textInputField.AcceptCharacter(c))
                {
                    return;
                }

                // Simplest test: only allow the character if the display font supports it.
                Font font = editorEngine.style.font;
                if (font != null && font.HasCharacter(c) || c == '\n' || c == '\t')
                {
                    // Input event
                    editorEngine.Insert(c);
                    m_Changed = true;
                }
                // On windows, key presses also send events with keycode but no character. Eat them up here.
                else if (c == 0)
                {
                    // if we have a composition string, make sure we clear the previous selection.
                    if (!string.IsNullOrEmpty(GUIUtility.compositionString))
                    {
                        editorEngine.ReplaceSelection("");
                        m_Changed = true;
                    }
                }
            }

            if (m_Changed)
            {
                editorEngine.text = textInputField.CullString(editorEngine.text);
                textInputField.UpdateText(editorEngine.text);
            }

            // Scroll offset might need to be updated
            editorEngine.UpdateScrollOffset();
        }
        void OnKeyDown(KeyDownEvent evt)
        {
            if (!textElement.edition.hasFocus)
            {
                return;
            }

            m_Changed = false;

            if (evt.keyCode == KeyCode.Escape)
            {
                textElement.edition.RestoreValueAndText();
                textElement.parent.Focus();
            }

            evt.GetEquivalentImguiEvent(m_ImguiEvent);
            if (editingUtilities.HandleKeyEvent(m_ImguiEvent, false))
            {
                if (textElement.text != editingUtilities.text)
                {
                    m_Changed = true;
                }
                evt.StopPropagation();
            }
            else
            {
                char c = evt.character;

                // Ignore command and control keys, but not AltGr characters
                if (evt.actionKey && !(evt.altKey && c != '\0'))
                {
                    return;
                }

                // Ignore tab & shift-tab in single-line text fields
                if (!textElement.edition.multiline && (evt.keyCode == KeyCode.Tab || c == '\t'))
                {
                    return;
                }

                // Ignore modifier+tab in multiline text fields
                if ((evt.keyCode == KeyCode.Tab || c == '\t') && evt.modifiers != EventModifiers.None)
                {
                    return;
                }

                evt.StopPropagation();

                if ((c == '\n' || c == '\r' || c == k_LineFeed) && !textElement.edition.multiline && !evt.altKey)
                {
                    return;
                }

                // When the newline character is sent, we have to check if the shift key is down also...
                // In the multiline case, this is like a return on a single line
                if (c == '\n' && textElement.edition.multiline && evt.shiftKey)
                {
                    return;
                }

                if (!textElement.edition.AcceptCharacter(c))
                {
                    return;
                }

                if (c >= k_Space || c == '\t' || c == '\n' || c == '\r' || c == k_LineFeed)
                {
                    editingUtilities.Insert(c);
                    m_Changed = true;
                }
                // On windows, key presses also send events with keycode but no character. Eat them up here.
                else
                {
                    // if we have a composition string, make sure we clear the previous selection.
                    if (editingUtilities.UpdateImeState())
                    {
                        m_Changed = true;
                    }
                }
            }

            if (m_Changed)
            {
                UpdateLabel();
                // UpdateScrollOffset needs the new geometry of the text to compute the new scrollOffset.
                textElement.uitkTextHandle.Update();
            }

            // Scroll offset might need to be updated
            textElement.edition.UpdateScrollOffset?.Invoke();
        }
        public void OnKeyDown(KeyDownEvent evt)
        {
            if (evt == null || !HasValidDataAndBindings())
            {
                return;
            }

            bool shouldStopPropagation = true;
            bool shouldScroll          = true;

            switch (evt.keyCode)
            {
            case KeyCode.UpArrow:
                if (selectedIndex > 0)
                {
                    selectedIndex = selectedIndex - 1;
                }
                break;

            case KeyCode.DownArrow:
                if (selectedIndex + 1 < itemsSource.Count)
                {
                    selectedIndex = selectedIndex + 1;
                }
                break;

            case KeyCode.Home:
                selectedIndex = 0;
                break;

            case KeyCode.End:
                selectedIndex = itemsSource.Count - 1;
                break;

            case KeyCode.Return:
                if (onItemChosen != null)
                {
                    onItemChosen.Invoke(m_ItemsSource[selectedIndex]);
                }
                break;

            case KeyCode.PageDown:
                selectedIndex = Math.Min(itemsSource.Count - 1, selectedIndex + (int)(m_LastHeight / itemHeight));
                break;

            case KeyCode.PageUp:
                selectedIndex = Math.Max(0, selectedIndex - (int)(m_LastHeight / itemHeight));
                break;

            case KeyCode.A:
                if (evt.actionKey)
                {
                    SelectAll();
                    shouldScroll = false;
                }
                break;

            case KeyCode.Escape:
                ClearSelection();
                shouldScroll = false;
                break;

            default:
                shouldStopPropagation = false;
                shouldScroll          = false;
                break;
            }

            if (shouldStopPropagation)
            {
                evt.StopPropagation();
            }

            if (shouldScroll)
            {
                ScrollToItem(selectedIndex);
            }
        }
Exemple #8
0
        private void OnKeyDown(KeyDownEvent evt)
        {
            bool flag = !base.textInputField.hasFocus;

            if (!flag)
            {
                base.textInputField.SyncTextEngine();
                this.m_Changed = false;
                evt.GetEquivalentImguiEvent(this.m_ImguiEvent);
                bool flag2 = base.editorEngine.HandleKeyEvent(this.m_ImguiEvent, base.textInputField.isReadOnly);
                if (flag2)
                {
                    bool flag3 = base.textInputField.text != base.editorEngine.text;
                    if (flag3)
                    {
                        this.m_Changed = true;
                    }
                    evt.StopPropagation();
                }
                else
                {
                    char character = evt.character;
                    bool flag4     = !base.editorEngine.multiline && (evt.keyCode == KeyCode.Tab || character == '\t');
                    if (flag4)
                    {
                        return;
                    }
                    bool flag5 = base.editorEngine.multiline && (evt.keyCode == KeyCode.Tab || character == '\t') && evt.modifiers > EventModifiers.None;
                    if (flag5)
                    {
                        return;
                    }
                    bool flag6 = evt.actionKey && (!evt.altKey || character == '\0');
                    if (flag6)
                    {
                        return;
                    }
                    evt.StopPropagation();
                    bool flag7 = character == '\n' && !base.editorEngine.multiline && !evt.altKey;
                    if (flag7)
                    {
                        return;
                    }
                    bool flag8 = character == '\n' && base.editorEngine.multiline && evt.shiftKey;
                    if (flag8)
                    {
                        return;
                    }
                    bool flag9 = !base.textInputField.AcceptCharacter(character);
                    if (flag9)
                    {
                        return;
                    }
                    Font font   = base.editorEngine.style.font;
                    bool flag10 = (font != null && font.HasCharacter(character)) || character == '\n' || character == '\t';
                    if (flag10)
                    {
                        base.editorEngine.Insert(character);
                        this.m_Changed = true;
                    }
                    else
                    {
                        bool flag11 = character == '\0';
                        if (flag11)
                        {
                            bool flag12 = !string.IsNullOrEmpty(GUIUtility.compositionString);
                            if (flag12)
                            {
                                base.editorEngine.ReplaceSelection("");
                                this.m_Changed = true;
                            }
                        }
                    }
                }
                bool changed = this.m_Changed;
                if (changed)
                {
                    base.editorEngine.text = base.textInputField.CullString(base.editorEngine.text);
                    base.textInputField.UpdateText(base.editorEngine.text);
                }
                base.editorEngine.UpdateScrollOffset();
            }
        }
Exemple #9
0
            protected override void ExecuteDefaultActionAtTarget(EventBase evt)
            {
                base.ExecuteDefaultActionAtTarget(evt);
                bool flag = evt == null;

                if (!flag)
                {
                    bool flag2 = evt.eventTypeId == EventBase <KeyDownEvent> .TypeId();

                    if (flag2)
                    {
                        KeyDownEvent keyDownEvent = evt as KeyDownEvent;
                        bool         flag3        = !this.parentTextField.isDelayed || (!this.multiline && ((keyDownEvent != null && keyDownEvent.keyCode == KeyCode.KeypadEnter) || (keyDownEvent != null && keyDownEvent.keyCode == KeyCode.Return)));
                        if (flag3)
                        {
                            this.parentTextField.value = base.text;
                        }
                        bool multiline = this.multiline;
                        if (multiline)
                        {
                            char?c     = (keyDownEvent != null) ? new char?(keyDownEvent.character) : null;
                            int? num   = c.HasValue ? new int?((int)c.GetValueOrDefault()) : null;
                            int  num2  = 9;
                            bool flag4 = (num.GetValueOrDefault() == num2 & num.HasValue) && keyDownEvent.modifiers == EventModifiers.None;
                            if (flag4)
                            {
                                if (keyDownEvent != null)
                                {
                                    keyDownEvent.StopPropagation();
                                }
                                if (keyDownEvent != null)
                                {
                                    keyDownEvent.PreventDefault();
                                }
                            }
                            else
                            {
                                c    = ((keyDownEvent != null) ? new char?(keyDownEvent.character) : null);
                                num  = (c.HasValue ? new int?((int)c.GetValueOrDefault()) : null);
                                num2 = 3;
                                bool arg_1EE_0;
                                if (!(num.GetValueOrDefault() == num2 & num.HasValue) || keyDownEvent == null || !keyDownEvent.shiftKey)
                                {
                                    c         = ((keyDownEvent != null) ? new char?(keyDownEvent.character) : null);
                                    num       = (c.HasValue ? new int?((int)c.GetValueOrDefault()) : null);
                                    num2      = 10;
                                    arg_1EE_0 = ((num.GetValueOrDefault() == num2 & num.HasValue) && keyDownEvent != null && keyDownEvent.shiftKey);
                                }
                                else
                                {
                                    arg_1EE_0 = true;
                                }
                                bool flag5 = arg_1EE_0;
                                if (flag5)
                                {
                                    base.parent.Focus();
                                }
                            }
                        }
                        else
                        {
                            char?c    = (keyDownEvent != null) ? new char?(keyDownEvent.character) : null;
                            int? num  = c.HasValue ? new int?((int)c.GetValueOrDefault()) : null;
                            int  num2 = 3;
                            bool arg_2B8_0;
                            if (!(num.GetValueOrDefault() == num2 & num.HasValue))
                            {
                                c         = ((keyDownEvent != null) ? new char?(keyDownEvent.character) : null);
                                num       = (c.HasValue ? new int?((int)c.GetValueOrDefault()) : null);
                                num2      = 10;
                                arg_2B8_0 = (num.GetValueOrDefault() == num2 & num.HasValue);
                            }
                            else
                            {
                                arg_2B8_0 = true;
                            }
                            bool flag6 = arg_2B8_0;
                            if (flag6)
                            {
                                base.parent.Focus();
                            }
                        }
                    }
                    else
                    {
                        bool flag7 = evt.eventTypeId == EventBase <ExecuteCommandEvent> .TypeId();

                        if (flag7)
                        {
                            ExecuteCommandEvent executeCommandEvent = evt as ExecuteCommandEvent;
                            string commandName = executeCommandEvent.commandName;
                            bool   flag8       = !this.parentTextField.isDelayed && (commandName == "Paste" || commandName == "Cut");
                            if (flag8)
                            {
                                this.parentTextField.value = base.text;
                            }
                        }
                        else
                        {
                            NavigationDirection navigationDirection;
                            bool flag9 = base.eventInterpreter.IsActivationEvent(evt) || base.eventInterpreter.IsCancellationEvent(evt) || (base.eventInterpreter.IsNavigationEvent(evt, out navigationDirection) && navigationDirection != NavigationDirection.Previous && navigationDirection != NavigationDirection.Next);
                            if (flag9)
                            {
                                evt.StopPropagation();
                                evt.PreventDefault();
                            }
                        }
                    }
                }
            }