public abstract void Invoke(EventBase evt);
        void DispatchEnterLeaveEvents(VisualElement previousTopElementUnderMouse, VisualElement currentTopElementUnderMouse, EventBase triggerEvent)
        {
            IMouseEvent mouseEvent = triggerEvent as IMouseEvent;

            if (mouseEvent == null)
            {
                return;
            }

            if (triggerEvent.GetEventTypeId() == MouseMoveEvent.TypeId() ||
                triggerEvent.GetEventTypeId() == MouseDownEvent.TypeId() ||
                triggerEvent.GetEventTypeId() == MouseUpEvent.TypeId() ||
                triggerEvent.GetEventTypeId() == MouseEnterWindowEvent.TypeId() ||
                triggerEvent.GetEventTypeId() == WheelEvent.TypeId())
            {
                DispatchMouseEnterMouseLeave(previousTopElementUnderMouse, currentTopElementUnderMouse, mouseEvent);
                DispatchMouseOverMouseOut(previousTopElementUnderMouse, currentTopElementUnderMouse, mouseEvent);
            }
            else if (triggerEvent.GetEventTypeId() == DragUpdatedEvent.TypeId())
            {
                DispatchDragEnterDragLeave(previousTopElementUnderMouse, currentTopElementUnderMouse, mouseEvent);
            }
        }
Ejemplo n.º 3
0
        protected internal override void ExecuteDefaultAction(EventBase evt)
        {
            base.ExecuteDefaultAction(evt);

            editorEventHandler.ExecuteDefaultAction(evt);
        }
Ejemplo n.º 4
0
        public bool UnregisterCallback <TEventType, TCallbackArgs>(EventCallback <TEventType, TCallbackArgs> callback, Capture useCapture = Capture.NoCapture) where TEventType : EventBase <TEventType>, new()
        {
            long eventTypeId = EventBase <TEventType> .TypeId();

            return(this.UnregisterCallback(eventTypeId, callback, useCapture));
        }
Ejemplo n.º 5
0
        public void DispatchEvent(EventBase evt, IPanel panel)
        {
            if (evt.GetEventTypeId() == IMGUIEvent.TypeId())
            {
                Event e = evt.imguiEvent;
                if (e.type == EventType.Repaint)
                {
                    return;
                }
            }
            if (panel != null && panel.panelDebug != null && panel.panelDebug.enabled && panel.panelDebug.interceptEvents != null)
            {
                if (panel.panelDebug.interceptEvents(evt.imguiEvent))
                {
                    evt.StopPropagation();
                    return;
                }
            }

            IMouseEvent         mouseEvent         = evt as IMouseEvent;
            IMouseEventInternal mouseEventInternal = evt as IMouseEventInternal;

            if (mouseEvent != null && mouseEventInternal != null && mouseEventInternal.hasUnderlyingPhysicalEvent)
            {
                m_LastMousePosition = mouseEvent.mousePosition;
            }

            bool eventHandled = false;

            // Release mouse capture if capture element is not in a panel.
            VisualElement captureVE = MouseCaptureController.mouseCapture as VisualElement;

            if (evt.GetEventTypeId() != MouseCaptureOutEvent.TypeId() && captureVE != null && captureVE.panel == null)
            {
                Event e = evt.imguiEvent;
                Debug.Log(String.Format("Capture has no panel, forcing removal (capture={0} eventType={1})", MouseCaptureController.mouseCapture, e != null ? e.type.ToString() : "null"));
                MouseCaptureController.ReleaseMouseCapture();
            }

            // Send all IMGUI events (for backward compatibility) and MouseEvents with null target (because thats what we want to do in the new system)
            // to the capture, if there is one. Note that events coming from IMGUI have their target set to null.
            bool sendEventToMouseCapture = false;
            bool mouseEventWasCaptured   = false;

            if (MouseCaptureController.mouseCapture != null)
            {
                if (evt.imguiEvent != null && evt.target == null)
                {
                    // Non exclusive processing by capturing element.
                    sendEventToMouseCapture = true;
                    mouseEventWasCaptured   = false;
                }
                if (mouseEvent != null && (evt.target == null || evt.target == MouseCaptureController.mouseCapture))
                {
                    // Exclusive processing by capturing element.
                    sendEventToMouseCapture = true;
                    mouseEventWasCaptured   = true;
                }

                if (panel != null)
                {
                    if (captureVE != null && captureVE.panel.contextType != panel.contextType)
                    {
                        // Capturing element is not in the right context. Ignore it.
                        sendEventToMouseCapture = false;
                        mouseEventWasCaptured   = false;
                    }
                }
            }

            evt.skipElement = null;

            if (sendEventToMouseCapture)
            {
                IEventHandler originalCaptureElement = MouseCaptureController.mouseCapture;

                eventHandled = true;

                evt.dispatch         = true;
                evt.target           = MouseCaptureController.mouseCapture;
                evt.currentTarget    = MouseCaptureController.mouseCapture;
                evt.propagationPhase = PropagationPhase.AtTarget;
                MouseCaptureController.mouseCapture.HandleEvent(evt);

                // Do further processing with a target computed the usual way.
                // However, if mouseEventWasCaptured, the only thing remaining to do is ExecuteDefaultAction,
                // which whould be done with mouseCapture as the target.
                if (!mouseEventWasCaptured)
                {
                    evt.target = null;
                }

                evt.currentTarget    = null;
                evt.propagationPhase = PropagationPhase.None;
                evt.dispatch         = false;

                // Do not call HandleEvent again for this element.
                evt.skipElement = originalCaptureElement;
            }

            if (!mouseEventWasCaptured && !evt.isPropagationStopped)
            {
                if (evt is IKeyboardEvent && panel != null)
                {
                    eventHandled = true;
                    if (panel.focusController.focusedElement != null)
                    {
                        IMGUIContainer imguiContainer = panel.focusController.focusedElement as IMGUIContainer;

                        if (imguiContainer != null)
                        {
                            // THINK ABOUT THIS PF: shoudln't we allow for the capture dispatch phase?
                            if (imguiContainer != evt.skipElement && imguiContainer.HandleIMGUIEvent(evt.imguiEvent))
                            {
                                evt.StopPropagation();
                                evt.PreventDefault();
                            }
                        }
                        else
                        {
                            evt.target = panel.focusController.focusedElement;
                            PropagateEvent(evt);
                        }
                    }
                    else
                    {
                        evt.target = panel.visualTree;
                        PropagateEvent(evt);

                        if (!evt.isPropagationStopped)
                        {
                            PropagateToIMGUIContainer(panel.visualTree, evt);
                        }
                    }
                }
                else if (mouseEvent != null)
                {
                    // FIXME: we should not change hover state when capture is true.
                    // However, when doing drag and drop, drop target should be highlighted.

                    // TODO when EditorWindow is docked MouseLeaveWindow is not always sent
                    // this is a problem in itself but it could leave some elements as "hover"

                    if (evt.GetEventTypeId() == MouseLeaveWindowEvent.TypeId())
                    {
                        VisualElement currentTopElementUnderMouse = m_TopElementUnderMouse;
                        m_TopElementUnderMouse = null;
                        DispatchMouseEnterMouseLeave(currentTopElementUnderMouse, m_TopElementUnderMouse, mouseEvent);
                        DispatchMouseOverMouseOut(currentTopElementUnderMouse, m_TopElementUnderMouse, mouseEvent);
                    }
                    else if (evt.GetEventTypeId() == DragExitedEvent.TypeId())
                    {
                        VisualElement currentTopElementUnderMouse = m_TopElementUnderMouse;
                        m_TopElementUnderMouse = null;
                        DispatchDragEnterDragLeave(currentTopElementUnderMouse, m_TopElementUnderMouse, mouseEvent);
                    }
                    // update element under mouse and fire necessary events
                    else
                    {
                        VisualElement currentTopElementUnderMouse = m_TopElementUnderMouse;
                        if (evt.target == null && panel != null)
                        {
                            m_TopElementUnderMouse = panel.Pick(mouseEvent.mousePosition);
                            evt.target             = m_TopElementUnderMouse;
                        }

                        if (evt.target != null)
                        {
                            eventHandled = true;
                            PropagateEvent(evt);
                        }

                        if (evt.GetEventTypeId() == MouseMoveEvent.TypeId() ||
                            evt.GetEventTypeId() == MouseDownEvent.TypeId() ||
                            evt.GetEventTypeId() == MouseUpEvent.TypeId() ||
                            evt.GetEventTypeId() == MouseEnterWindowEvent.TypeId() ||
                            evt.GetEventTypeId() == WheelEvent.TypeId())
                        {
                            DispatchMouseEnterMouseLeave(currentTopElementUnderMouse, m_TopElementUnderMouse, mouseEvent);
                            DispatchMouseOverMouseOut(currentTopElementUnderMouse, m_TopElementUnderMouse, mouseEvent);
                        }
                        else if (evt.GetEventTypeId() == DragUpdatedEvent.TypeId())
                        {
                            DispatchDragEnterDragLeave(currentTopElementUnderMouse, m_TopElementUnderMouse, mouseEvent);
                        }
                    }
                }
                else if (panel != null && evt is ICommandEvent)
                {
                    IMGUIContainer imguiContainer = panel.focusController.focusedElement as IMGUIContainer;

                    eventHandled = true;
                    if (imguiContainer != null)
                    {
                        if (imguiContainer != evt.skipElement && imguiContainer.HandleIMGUIEvent(evt.imguiEvent))
                        {
                            evt.StopPropagation();
                            evt.PreventDefault();
                        }
                    }
                    else if (panel.focusController.focusedElement != null)
                    {
                        evt.target = panel.focusController.focusedElement;
                        PropagateEvent(evt);
                    }
                    else
                    {
                        PropagateToIMGUIContainer(panel.visualTree, evt);
                    }
                }
                else if (evt is IPropagatableEvent ||
                         evt is IFocusEvent ||
                         evt is IChangeEvent ||
                         evt.GetEventTypeId() == InputEvent.TypeId() ||
                         evt.GetEventTypeId() == GeometryChangedEvent.TypeId())
                {
                    Debug.Assert(evt.target != null);
                    eventHandled = true;
                    PropagateEvent(evt);
                }
            }

            if (!mouseEventWasCaptured && !evt.isPropagationStopped && panel != null)
            {
                Event e = evt.imguiEvent;
                if (!eventHandled || (e != null && e.type == EventType.Used) ||
                    evt.GetEventTypeId() == MouseEnterWindowEvent.TypeId() ||
                    evt.GetEventTypeId() == MouseLeaveWindowEvent.TypeId())
                {
                    PropagateToIMGUIContainer(panel.visualTree, evt);
                }
            }

            if (evt.target == null && panel != null)
            {
                evt.target = panel.visualTree;
            }
            ExecuteDefaultAction(evt);
        }
Ejemplo n.º 6
0
 // ActionStatusCallback for action that are always disabled.
 public static StatusFlags AlwaysDisabled(EventBase e)
 {
     return(StatusFlags.Disabled);
 }
Ejemplo n.º 7
0
        public void DispatchEvent(EventBase evt, IPanel panel)
        {
            Event e = evt.imguiEvent;

            if (e != null && e.type == EventType.Repaint)
            {
                return;
            }

            if (panel != null && panel.panelDebug != null && panel.panelDebug.enabled && panel.panelDebug.interceptEvents != null)
            {
                if (panel.panelDebug.interceptEvents(e))
                {
                    evt.StopPropagation();
                    return;
                }
            }

            bool          invokedHandleEvent = false;
            VisualElement captureVE          = null;

            // Send all IMGUI events (for backward compatibility) and MouseEvents (because thats what we want to do in the new system)
            // to the capture, if there is one.
            if ((evt is IMouseEvent || e != null) && MouseCaptureController.mouseCapture != null)
            {
                captureVE = MouseCaptureController.mouseCapture as VisualElement;
                if (captureVE != null && captureVE.panel == null)
                {
                    Debug.Log(String.Format("Capture has no panel, forcing removal (capture={0} eventType={1})", MouseCaptureController.mouseCapture, e != null ? e.type.ToString() : "null"));
                    MouseCaptureController.ReleaseMouseCapture();
                    captureVE = null;
                }

                if (panel != null)
                {
                    if (captureVE != null && captureVE.panel.contextType != panel.contextType)
                    {
                        return;
                    }
                }

                invokedHandleEvent = true;
                evt.dispatch       = true;

                if (MouseCaptureController.mouseCapture != null)
                {
                    evt.target           = MouseCaptureController.mouseCapture;
                    evt.currentTarget    = MouseCaptureController.mouseCapture;
                    evt.propagationPhase = PropagationPhase.AtTarget;
                    MouseCaptureController.mouseCapture.HandleEvent(evt);
                }
                evt.propagationPhase = PropagationPhase.None;
                evt.currentTarget    = null;
                evt.dispatch         = false;
            }

            if (evt.isPropagationStopped)
            {
                // Make sure to call default actions at target, but dont call it twice on mouse capture
                if (evt.target == null && panel != null)
                {
                    evt.target = panel.visualTree;
                }
                if (evt.target != null && evt.target != MouseCaptureController.mouseCapture)
                {
                    evt.dispatch         = true;
                    evt.currentTarget    = evt.target;
                    evt.propagationPhase = PropagationPhase.AtTarget;
                    evt.target.HandleEvent(evt);
                    evt.propagationPhase = PropagationPhase.None;
                    evt.currentTarget    = null;
                    evt.dispatch         = false;
                }
            }

            if (!evt.isPropagationStopped)
            {
                if (evt is IKeyboardEvent && panel != null)
                {
                    if (panel.focusController.focusedElement != null)
                    {
                        IMGUIContainer imguiContainer = panel.focusController.focusedElement as IMGUIContainer;

                        invokedHandleEvent = true;
                        if (imguiContainer != null)
                        {
                            if (imguiContainer.HandleIMGUIEvent(evt.imguiEvent))
                            {
                                evt.StopPropagation();
                                evt.PreventDefault();
                            }
                        }
                        else
                        {
                            evt.target = panel.focusController.focusedElement;
                            PropagateEvent(evt);
                        }
                    }
                    else
                    {
                        evt.target = panel.visualTree;
                        PropagateEvent(evt);

                        // Force call to PropagateToIMGUIContainer(), even if capture != null.
                        invokedHandleEvent = false;
                    }
                }
                else if (evt.GetEventTypeId() == MouseEnterEvent.TypeId() ||
                         evt.GetEventTypeId() == MouseLeaveEvent.TypeId())
                {
                    Debug.Assert(evt.target != null);
                    invokedHandleEvent = true;
                    PropagateEvent(evt);
                }
                else if (evt is IMouseEvent || (
                             e != null && (
                                 e.type == EventType.ContextClick ||
                                 e.type == EventType.DragUpdated ||
                                 e.type == EventType.DragPerform ||
                                 e.type == EventType.DragExited
                                 )
                             ))
                {
                    // FIXME: we should not change hover state when capture is true.
                    // However, when doing drag and drop, drop target should be highlighted.

                    // TODO when EditorWindow is docked MouseLeaveWindow is not always sent
                    // this is a problem in itself but it could leave some elements as "hover"
                    VisualElement currentTopElementUnderMouse = m_TopElementUnderMouse;

                    if (evt.GetEventTypeId() == MouseLeaveWindowEvent.TypeId())
                    {
                        m_TopElementUnderMouse = null;
                        DispatchMouseEnterMouseLeave(currentTopElementUnderMouse, m_TopElementUnderMouse, e);
                        DispatchMouseOverMouseOut(currentTopElementUnderMouse, m_TopElementUnderMouse, e);
                    }
                    // update element under mouse and fire necessary events
                    else if (evt is IMouseEvent || e != null)
                    {
                        if (evt.target == null && panel != null)
                        {
                            if (evt is IMouseEvent)
                            {
                                m_TopElementUnderMouse = panel.Pick((evt as IMouseEvent).localMousePosition);
                            }
                            else if (e != null)
                            {
                                m_TopElementUnderMouse = panel.Pick(e.mousePosition);
                            }

                            evt.target = m_TopElementUnderMouse;
                        }

                        if (evt.target != null)
                        {
                            invokedHandleEvent = true;
                            PropagateEvent(evt);
                        }

                        if (evt.GetEventTypeId() == MouseMoveEvent.TypeId() ||
                            evt.GetEventTypeId() == MouseEnterWindowEvent.TypeId() ||
                            evt.GetEventTypeId() == WheelEvent.TypeId() ||
                            (e != null && e.type == EventType.DragUpdated))
                        {
                            DispatchMouseEnterMouseLeave(currentTopElementUnderMouse, m_TopElementUnderMouse, e);
                            DispatchMouseOverMouseOut(currentTopElementUnderMouse, m_TopElementUnderMouse, e);
                        }
                    }
                }
                else if (panel != null && e != null && (e.type == EventType.ExecuteCommand || e.type == EventType.ValidateCommand))
                {
                    IMGUIContainer imguiContainer = panel.focusController.focusedElement as IMGUIContainer;

                    if (imguiContainer != null)
                    {
                        invokedHandleEvent = true;
                        if (imguiContainer.HandleIMGUIEvent(evt.imguiEvent))
                        {
                            evt.StopPropagation();
                            evt.PreventDefault();
                        }
                    }
                    else if (panel.focusController.focusedElement != null)
                    {
                        invokedHandleEvent = true;
                        evt.target         = panel.focusController.focusedElement;
                        PropagateEvent(evt);
                    }
                    else
                    {
                        invokedHandleEvent = true;
                        PropagateToIMGUIContainer(panel.visualTree, evt, captureVE);
                    }
                }
                else if (evt is IPropagatableEvent ||
                         evt is IFocusEvent ||
                         evt is IChangeEvent ||
                         evt.GetEventTypeId() == InputEvent.TypeId() ||
                         evt.GetEventTypeId() == PostLayoutEvent.TypeId())
                {
                    Debug.Assert(evt.target != null);
                    invokedHandleEvent = true;
                    PropagateEvent(evt);
                }
            }

            if (!evt.isPropagationStopped && e != null && panel != null)
            {
                if (!invokedHandleEvent || e != null && (
                        e.type == EventType.MouseEnterWindow ||
                        e.type == EventType.MouseLeaveWindow ||
                        e.type == EventType.Used
                        ))
                {
                    PropagateToIMGUIContainer(panel.visualTree, evt, captureVE);
                }
            }

            if (evt.target == null && panel != null)
            {
                evt.target = panel.visualTree;
            }
            ExecuteDefaultAction(evt);
        }
Ejemplo n.º 8
0
 public abstract void DisplayMenuIfEventMatches(EventBase evt, IEventHandler eventHandler);
 public EventCallbackFunctor(EventCallback <TEventType, TCallbackArgs> callback, TCallbackArgs userArgs, CallbackPhase phase) : base(phase)
 {
     this.m_Callback    = callback;
     this.m_UserArgs    = userArgs;
     this.m_EventTypeId = EventBase <TEventType> .TypeId();
 }
Ejemplo n.º 10
0
 public abstract void SendEvent(EventBase e);
Ejemplo n.º 11
0
 protected abstract void DoDisplayMenu(ContextualMenu menu, EventBase triggerEvent);
Ejemplo n.º 12
0
 public sealed override void SendEvent(EventBase e)
 {
     elementPanel?.SendEvent(e);
 }
Ejemplo n.º 13
0
        private void DoOnGUI(Event evt)
        {
            if (this.m_OnGUIHandler != null && base.panel != null)
            {
                int num = GUIClip.Internal_GetCount();
                this.SaveGlobals();
                UIElementsUtility.BeginContainerGUI(this.cache, evt, this);
                if (this.lostFocus)
                {
                    GUIUtility.keyboardControl = 0;
                    if (this.focusController != null)
                    {
                        this.focusController.imguiKeyboardControl = 0;
                    }
                    this.lostFocus = false;
                }
                if (this.receivedFocus)
                {
                    if (this.focusChangeDirection != FocusChangeDirection.unspecified && this.focusChangeDirection != FocusChangeDirection.none)
                    {
                        if (this.focusChangeDirection == VisualElementFocusChangeDirection.left)
                        {
                            GUIUtility.SetKeyboardControlToLastControlId();
                        }
                        else if (this.focusChangeDirection == VisualElementFocusChangeDirection.right)
                        {
                            GUIUtility.SetKeyboardControlToFirstControlId();
                        }
                    }
                    this.receivedFocus        = false;
                    this.focusChangeDirection = FocusChangeDirection.unspecified;
                    if (this.focusController != null)
                    {
                        this.focusController.imguiKeyboardControl = GUIUtility.keyboardControl;
                    }
                }
                this.GUIDepth = GUIUtility.Internal_GetGUIDepth();
                EventType type = Event.current.type;
                bool      flag = false;
                try
                {
                    this.m_OnGUIHandler();
                }
                catch (Exception exception)
                {
                    if (type != EventType.Layout)
                    {
                        throw;
                    }
                    flag = GUIUtility.IsExitGUIException(exception);
                    if (!flag)
                    {
                        Debug.LogException(exception);
                    }
                }
                finally
                {
                    int num2 = GUIUtility.CheckForTabEvent(evt);
                    if (this.focusController != null)
                    {
                        if (num2 < 0)
                        {
                            KeyDownEvent keyDownEvent = null;
                            if (num2 == -1)
                            {
                                keyDownEvent = KeyboardEventBase <KeyDownEvent> .GetPooled('\t', KeyCode.Tab, EventModifiers.None);
                            }
                            else if (num2 == -2)
                            {
                                keyDownEvent = KeyboardEventBase <KeyDownEvent> .GetPooled('\t', KeyCode.Tab, EventModifiers.Shift);
                            }
                            Focusable focusedElement = this.focusController.focusedElement;
                            this.focusController.SwitchFocusOnEvent(keyDownEvent);
                            EventBase <KeyDownEvent> .ReleasePooled(keyDownEvent);

                            if (focusedElement == this)
                            {
                                if (this.focusController.focusedElement == this)
                                {
                                    if (num2 == -2)
                                    {
                                        GUIUtility.SetKeyboardControlToLastControlId();
                                    }
                                    else if (num2 == -1)
                                    {
                                        GUIUtility.SetKeyboardControlToFirstControlId();
                                    }
                                    this.newKeyboardFocusControlID            = GUIUtility.keyboardControl;
                                    this.focusController.imguiKeyboardControl = GUIUtility.keyboardControl;
                                }
                                else
                                {
                                    GUIUtility.keyboardControl = 0;
                                    this.focusController.imguiKeyboardControl = 0;
                                }
                            }
                        }
                        else if (num2 > 0)
                        {
                            this.focusController.imguiKeyboardControl = GUIUtility.keyboardControl;
                            this.newKeyboardFocusControlID            = GUIUtility.keyboardControl;
                        }
                        else if (num2 == 0 && type == EventType.MouseDown)
                        {
                            this.focusController.SyncIMGUIFocus(this);
                        }
                    }
                    this.hasFocusableControls = GUIUtility.HasFocusableControls();
                }
                EventType type2 = Event.current.type;
                UIElementsUtility.EndContainerGUI();
                this.RestoreGlobals();
                if (!flag)
                {
                    if (type2 != EventType.Ignore && type2 != EventType.Used)
                    {
                        int num3 = GUIClip.Internal_GetCount();
                        if (num3 > num)
                        {
                            Debug.LogError("GUI Error: You are pushing more GUIClips than you are popping. Make sure they are balanced)");
                        }
                        else if (num3 < num)
                        {
                            Debug.LogError("GUI Error: You are popping more GUIClips than you are pushing. Make sure they are balanced)");
                        }
                    }
                }
                while (GUIClip.Internal_GetCount() > num)
                {
                    GUIClip.Internal_Pop();
                }
                if (type2 == EventType.Used)
                {
                    base.Dirty(ChangeType.Repaint);
                }
            }
        }
Ejemplo n.º 14
0
        public FocusChangeDirection GetFocusChangeDirection(Focusable currentFocusable, EventBase e)
        {
            // FUTURE:
            // We could implement an extendable adapter system to convert event to a focus change direction.
            // This would enable new event sources to change the focus.

            if (currentFocusable as IMGUIContainer != null && e.imguiEvent != null)
            {
                // Let IMGUIContainer manage the focus change.
                return(FocusChangeDirection.none);
            }

            if (e.GetEventTypeId() == KeyDownEvent.TypeId())
            {
                KeyDownEvent   kde       = e as KeyDownEvent;
                EventModifiers modifiers = kde.modifiers;

                if (kde.character == '\t')
                {
                    if (currentFocusable == null)
                    {
                        // Dont start going around a focus ring if there is no current focused element.
                        return(FocusChangeDirection.none);
                    }
                    else if ((modifiers & EventModifiers.Shift) == 0)
                    {
                        return(VisualElementFocusChangeDirection.right);
                    }
                    else
                    {
                        return(VisualElementFocusChangeDirection.left);
                    }
                }
            }

            return(FocusChangeDirection.none);
        }
Ejemplo n.º 15
0
 public EventCallbackFunctor(EventCallback <TEventType> callback, CallbackPhase phase) : base(phase)
 {
     m_Callback    = callback;
     m_EventTypeId = EventBase <TEventType> .TypeId();
 }
Ejemplo n.º 16
0
        public bool UnregisterCallback <TEventType, TCallbackArgs>(EventCallback <TEventType, TCallbackArgs> callback, TrickleDown useTrickleDown = TrickleDown.NoTrickleDown) where TEventType : EventBase <TEventType>, new()
        {
            long eventTypeId = EventBase <TEventType> .TypeId();

            return(UnregisterCallback(eventTypeId, callback, useTrickleDown));
        }
Ejemplo n.º 17
0
 // ActionStatusCallback for action that are always enabled.
 public static StatusFlags AlwaysEnabled(EventBase e)
 {
     return(StatusFlags.Normal);
 }
Ejemplo n.º 18
0
 ContextualMenu.MenuAction.StatusFlags CutCopyActionStatus(EventBase e)
 {
     return((editorEngine.hasSelection && !isPasswordField) ? ContextualMenu.MenuAction.StatusFlags.Normal : ContextualMenu.MenuAction.StatusFlags.Disabled);
 }
Ejemplo n.º 19
0
 public void UpdateActionStatus(EventBase e)
 {
     status = (actionStatusCallback != null ? actionStatusCallback(e) : StatusFlags.Hidden);
 }
Ejemplo n.º 20
0
 ContextualMenu.MenuAction.StatusFlags PasteActionStatus(EventBase e)
 {
     return(editorEngine.CanPaste() ? ContextualMenu.MenuAction.StatusFlags.Normal : ContextualMenu.MenuAction.StatusFlags.Disabled);
 }
Ejemplo n.º 21
0
        public FocusChangeDirection GetFocusChangeDirection(Focusable currentFocusable, EventBase e)
        {
            FocusChangeDirection result;

            if (currentFocusable is IMGUIContainer && e.imguiEvent != null)
            {
                result = FocusChangeDirection.none;
            }
            else
            {
                if (e.GetEventTypeId() == EventBase <KeyDownEvent> .TypeId())
                {
                    KeyDownEvent   keyDownEvent = e as KeyDownEvent;
                    EventModifiers modifiers    = keyDownEvent.modifiers;
                    if (keyDownEvent.character == '\t')
                    {
                        if (currentFocusable == null)
                        {
                            result = FocusChangeDirection.none;
                            return(result);
                        }
                        if ((modifiers & EventModifiers.Shift) == EventModifiers.None)
                        {
                            result = VisualElementFocusChangeDirection.right;
                            return(result);
                        }
                        result = VisualElementFocusChangeDirection.left;
                        return(result);
                    }
                }
                result = FocusChangeDirection.none;
            }
            return(result);
        }
Ejemplo n.º 22
0
 void Copy(EventBase e)
 {
     editorEngine.Copy();
 }
Ejemplo n.º 23
0
        public void DispatchEvent(EventBase evt, IPanel panel)
        {
            Event imguiEvent = evt.imguiEvent;

            if (imguiEvent == null || imguiEvent.type != EventType.Repaint)
            {
                if (panel != null && panel.panelDebug != null && panel.panelDebug.enabled && panel.panelDebug.interceptEvents != null && panel.panelDebug.interceptEvents(imguiEvent))
                {
                    evt.StopPropagation();
                }
                else
                {
                    bool          flag          = false;
                    VisualElement visualElement = null;
                    if ((evt is IMouseEvent || imguiEvent != null) && MouseCaptureController.mouseCapture != null)
                    {
                        visualElement = (MouseCaptureController.mouseCapture as VisualElement);
                        if (visualElement != null && visualElement.panel == null)
                        {
                            Debug.Log(string.Format("Capture has no panel, forcing removal (capture={0} eventType={1})", MouseCaptureController.mouseCapture, (imguiEvent == null) ? "null" : imguiEvent.type.ToString()));
                            MouseCaptureController.ReleaseMouseCapture();
                            visualElement = null;
                        }
                        if (panel != null)
                        {
                            if (visualElement != null && visualElement.panel.contextType != panel.contextType)
                            {
                                return;
                            }
                        }
                        flag         = true;
                        evt.dispatch = true;
                        if (MouseCaptureController.mouseCapture != null)
                        {
                            evt.target           = MouseCaptureController.mouseCapture;
                            evt.currentTarget    = MouseCaptureController.mouseCapture;
                            evt.propagationPhase = PropagationPhase.AtTarget;
                            MouseCaptureController.mouseCapture.HandleEvent(evt);
                        }
                        evt.propagationPhase = PropagationPhase.None;
                        evt.currentTarget    = null;
                        evt.dispatch         = false;
                    }
                    if (evt.isPropagationStopped)
                    {
                        if (evt.target == null && panel != null)
                        {
                            evt.target = panel.visualTree;
                        }
                        if (evt.target != null && evt.target != MouseCaptureController.mouseCapture)
                        {
                            evt.dispatch         = true;
                            evt.currentTarget    = evt.target;
                            evt.propagationPhase = PropagationPhase.AtTarget;
                            evt.target.HandleEvent(evt);
                            evt.propagationPhase = PropagationPhase.None;
                            evt.currentTarget    = null;
                            evt.dispatch         = false;
                        }
                    }
                    if (!evt.isPropagationStopped)
                    {
                        if (evt is IKeyboardEvent && panel != null)
                        {
                            if (panel.focusController.focusedElement != null)
                            {
                                IMGUIContainer iMGUIContainer = panel.focusController.focusedElement as IMGUIContainer;
                                flag = true;
                                if (iMGUIContainer != null)
                                {
                                    if (iMGUIContainer.HandleIMGUIEvent(evt.imguiEvent))
                                    {
                                        evt.StopPropagation();
                                        evt.PreventDefault();
                                    }
                                }
                                else
                                {
                                    evt.target = panel.focusController.focusedElement;
                                    EventDispatcher.PropagateEvent(evt);
                                }
                            }
                            else
                            {
                                evt.target = panel.visualTree;
                                EventDispatcher.PropagateEvent(evt);
                                flag = false;
                            }
                        }
                        else if (evt.GetEventTypeId() == EventBase <MouseEnterEvent> .TypeId() || evt.GetEventTypeId() == EventBase <MouseLeaveEvent> .TypeId())
                        {
                            Debug.Assert(evt.target != null);
                            flag = true;
                            EventDispatcher.PropagateEvent(evt);
                        }
                        else if (evt is IMouseEvent || (imguiEvent != null && (imguiEvent.type == EventType.ContextClick || imguiEvent.type == EventType.DragUpdated || imguiEvent.type == EventType.DragPerform || imguiEvent.type == EventType.DragExited)))
                        {
                            VisualElement topElementUnderMouse = this.m_TopElementUnderMouse;
                            if (evt.GetEventTypeId() == EventBase <MouseLeaveWindowEvent> .TypeId())
                            {
                                this.m_TopElementUnderMouse = null;
                                this.DispatchMouseEnterMouseLeave(topElementUnderMouse, this.m_TopElementUnderMouse, imguiEvent);
                                this.DispatchMouseOverMouseOut(topElementUnderMouse, this.m_TopElementUnderMouse, imguiEvent);
                            }
                            else if (evt is IMouseEvent || imguiEvent != null)
                            {
                                if (evt.target == null && panel != null)
                                {
                                    if (evt is IMouseEvent)
                                    {
                                        this.m_TopElementUnderMouse = panel.Pick((evt as IMouseEvent).localMousePosition);
                                    }
                                    else if (imguiEvent != null)
                                    {
                                        this.m_TopElementUnderMouse = panel.Pick(imguiEvent.mousePosition);
                                    }
                                    evt.target = this.m_TopElementUnderMouse;
                                }
                                if (evt.target != null)
                                {
                                    flag = true;
                                    EventDispatcher.PropagateEvent(evt);
                                }
                                if (evt.GetEventTypeId() == EventBase <MouseMoveEvent> .TypeId() || evt.GetEventTypeId() == EventBase <MouseEnterWindowEvent> .TypeId() || evt.GetEventTypeId() == EventBase <WheelEvent> .TypeId() || (imguiEvent != null && imguiEvent.type == EventType.DragUpdated))
                                {
                                    this.DispatchMouseEnterMouseLeave(topElementUnderMouse, this.m_TopElementUnderMouse, imguiEvent);
                                    this.DispatchMouseOverMouseOut(topElementUnderMouse, this.m_TopElementUnderMouse, imguiEvent);
                                }
                            }
                        }
                        else if (panel != null && imguiEvent != null && (imguiEvent.type == EventType.ExecuteCommand || imguiEvent.type == EventType.ValidateCommand))
                        {
                            IMGUIContainer iMGUIContainer2 = panel.focusController.focusedElement as IMGUIContainer;
                            if (iMGUIContainer2 != null)
                            {
                                flag = true;
                                if (iMGUIContainer2.HandleIMGUIEvent(evt.imguiEvent))
                                {
                                    evt.StopPropagation();
                                    evt.PreventDefault();
                                }
                            }
                            else if (panel.focusController.focusedElement != null)
                            {
                                flag       = true;
                                evt.target = panel.focusController.focusedElement;
                                EventDispatcher.PropagateEvent(evt);
                            }
                            else
                            {
                                flag = true;
                                EventDispatcher.PropagateToIMGUIContainer(panel.visualTree, evt, visualElement);
                            }
                        }
                        else if (evt is IPropagatableEvent || evt is IFocusEvent || evt is IChangeEvent || evt.GetEventTypeId() == EventBase <PostLayoutEvent> .TypeId() || evt.GetEventTypeId() == EventBase <InputEvent> .TypeId())
                        {
                            Debug.Assert(evt.target != null);
                            flag = true;
                            EventDispatcher.PropagateEvent(evt);
                        }
                    }
                    if (!evt.isPropagationStopped && imguiEvent != null && panel != null)
                    {
                        if (!flag || (imguiEvent != null && (imguiEvent.type == EventType.MouseEnterWindow || imguiEvent.type == EventType.MouseLeaveWindow || imguiEvent.type == EventType.Used)))
                        {
                            EventDispatcher.PropagateToIMGUIContainer(panel.visualTree, evt, visualElement);
                        }
                    }
                    if (evt.target == null && panel != null)
                    {
                        evt.target = panel.visualTree;
                    }
                    EventDispatcher.ExecuteDefaultAction(evt);
                }
            }
        }
 protected internal virtual void ExecuteDefaultAction(EventBase evt)
 {
 }
Ejemplo n.º 25
0
        private static void PropagateEvent(EventBase evt)
        {
            if (evt.dispatch)
            {
                // FIXME: signal this as an error
                return;
            }

            PropagationPaths.Type pathTypesRequested = (evt.capturable ? PropagationPaths.Type.Capture : PropagationPaths.Type.None);
            pathTypesRequested |= (evt.bubbles ? PropagationPaths.Type.BubbleUp : PropagationPaths.Type.None);

            using (var paths = BuildPropagationPath(evt.target as VisualElement, pathTypesRequested))
            {
                evt.dispatch = true;

                if (evt.capturable && paths != null && paths.capturePath.Count > 0)
                {
                    // Phase 1: Capture phase
                    // Propagate event from root to target.parent
                    evt.propagationPhase = PropagationPhase.Capture;

                    for (int i = paths.capturePath.Count - 1; i >= 0; i--)
                    {
                        if (evt.isPropagationStopped)
                        {
                            break;
                        }

                        if (paths.capturePath[i] == evt.skipElement)
                        {
                            continue;
                        }

                        evt.currentTarget = paths.capturePath[i];
                        evt.currentTarget.HandleEvent(evt);
                    }
                }

                // Phase 2: Target
                // Call HandleEvent() even if propagation is stopped, for the default actions at target.
                if (evt.target != evt.skipElement)
                {
                    evt.propagationPhase = PropagationPhase.AtTarget;
                    evt.currentTarget    = evt.target;
                    evt.currentTarget.HandleEvent(evt);
                }

                // Phase 3: bubble Up phase
                // Propagate event from target parent up to root
                if (evt.bubbles && paths != null && paths.bubblePath.Count > 0)
                {
                    evt.propagationPhase = PropagationPhase.BubbleUp;

                    foreach (VisualElement ve in paths.bubblePath)
                    {
                        if (evt.isPropagationStopped)
                        {
                            break;
                        }

                        if (ve == evt.skipElement)
                        {
                            continue;
                        }

                        evt.currentTarget = ve;
                        evt.currentTarget.HandleEvent(evt);
                    }
                }

                evt.dispatch         = false;
                evt.propagationPhase = PropagationPhase.None;
                evt.currentTarget    = null;
            }
        }
Ejemplo n.º 26
0
 internal void SendEvent(EventBase e, DispatchMode dispatchMode = DispatchMode.Queued)
 {
     Debug.Assert(dispatcher != null);
     dispatcher?.Dispatch(e, this, dispatchMode);
 }