コード例 #1
0
        internal static EventBase CreateEvent(Event systemEvent)
        {
            switch (systemEvent.type)
            {
            case EventType.MouseMove:
                return(MouseMoveEvent.GetPooled(systemEvent));

            case EventType.MouseDrag:
                return(MouseMoveEvent.GetPooled(systemEvent));

            case EventType.MouseDown:
                return(MouseDownEvent.GetPooled(systemEvent));

            case EventType.MouseUp:
                return(MouseUpEvent.GetPooled(systemEvent));

            case EventType.ScrollWheel:
                return(WheelEvent.GetPooled(systemEvent));

            case EventType.KeyDown:
                return(KeyDownEvent.GetPooled(systemEvent));

            case EventType.KeyUp:
                return(KeyUpEvent.GetPooled(systemEvent));

            case EventType.MouseEnterWindow:
                return(MouseEnterWindowEvent.GetPooled(systemEvent));

            case EventType.MouseLeaveWindow:
                return(MouseLeaveWindowEvent.GetPooled(systemEvent));

            default:
                return(IMGUIEvent.GetPooled(systemEvent));
            }
        }
コード例 #2
0
        // In order for tests to run without an EditorWindow but still be able to send
        // events, we sometimes need to force the event type. IMGUI::GetEventType() (native) will
        // return the event type as Ignore if the proper views haven't yet been
        // initialized. This (falsely) breaks tests that rely on the event type. So for tests, we
        // just ensure the event type is what we originally set it to when we sent it.
        internal static EventBase CreateEvent(Event systemEvent, EventType eventType)
        {
            switch (eventType)
            {
            case EventType.MouseMove:
                return(MouseMoveEvent.GetPooled(systemEvent));

            case EventType.MouseDrag:
                return(MouseMoveEvent.GetPooled(systemEvent));

            case EventType.MouseDown:
                return(MouseDownEvent.GetPooled(systemEvent));

            case EventType.MouseUp:
                return(MouseUpEvent.GetPooled(systemEvent));

            case EventType.ContextClick:
                return(ContextClickEvent.GetPooled(systemEvent));

            case EventType.MouseEnterWindow:
                return(MouseEnterWindowEvent.GetPooled(systemEvent));

            case EventType.MouseLeaveWindow:
                return(MouseLeaveWindowEvent.GetPooled(systemEvent));

            case EventType.ScrollWheel:
                return(WheelEvent.GetPooled(systemEvent));

            case EventType.KeyDown:
                return(KeyDownEvent.GetPooled(systemEvent));

            case EventType.KeyUp:
                return(KeyUpEvent.GetPooled(systemEvent));

            case EventType.DragUpdated:
                return(DragUpdatedEvent.GetPooled(systemEvent));

            case EventType.DragPerform:
                return(DragPerformEvent.GetPooled(systemEvent));

            case EventType.DragExited:
                return(DragExitedEvent.GetPooled(systemEvent));

            case EventType.ValidateCommand:
                return(ValidateCommandEvent.GetPooled(systemEvent));

            case EventType.ExecuteCommand:
                return(ExecuteCommandEvent.GetPooled(systemEvent));

            default:    // Layout, Ignore, Used
                return(IMGUIEvent.GetPooled(systemEvent));
            }
        }
コード例 #3
0
 private void OnScrollWheel(WheelEvent evt)
 {
     if (this.contentContainer.layout.height - base.layout.height > 0f)
     {
         if (evt.delta.y < 0f)
         {
             this.verticalScroller.ScrollPageUp();
         }
         else if (evt.delta.y > 0f)
         {
             this.verticalScroller.ScrollPageDown();
         }
     }
     evt.StopPropagation();
 }
コード例 #4
0
        // TODO: Same behaviour as IMGUI Scroll view; it would probably be nice to show same behaviour
        // as Web browsers, which give back event to parent if not consumed
        void OnScrollWheel(WheelEvent evt)
        {
            if (contentContainer.layout.height - layout.height > 0)
            {
                if (evt.delta.y < 0)
                {
                    verticalScroller.ScrollPageUp(Mathf.Abs(evt.delta.y));
                }
                else if (evt.delta.y > 0)
                {
                    verticalScroller.ScrollPageDown(Mathf.Abs(evt.delta.y));
                }
            }

            evt.StopPropagation();
        }
コード例 #5
0
        internal static EventBase CreateEvent(Event systemEvent)
        {
            EventBase pooled;

            switch (systemEvent.type)
            {
            case EventType.MouseDown:
                pooled = MouseEventBase <MouseDownEvent> .GetPooled(systemEvent);

                break;

            case EventType.MouseUp:
                pooled = MouseEventBase <MouseUpEvent> .GetPooled(systemEvent);

                break;

            case EventType.MouseMove:
                pooled = MouseEventBase <MouseMoveEvent> .GetPooled(systemEvent);

                break;

            case EventType.MouseDrag:
                pooled = MouseEventBase <MouseMoveEvent> .GetPooled(systemEvent);

                break;

            case EventType.KeyDown:
                pooled = KeyboardEventBase <KeyDownEvent> .GetPooled(systemEvent);

                break;

            case EventType.KeyUp:
                pooled = KeyboardEventBase <KeyUpEvent> .GetPooled(systemEvent);

                break;

            case EventType.ScrollWheel:
                pooled = WheelEvent.GetPooled(systemEvent);
                break;

            default:
                pooled = IMGUIEvent.GetPooled(systemEvent);
                break;
            }
            return(pooled);
        }
コード例 #6
0
        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);
            }
        }
コード例 #7
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);
        }
コード例 #8
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);
        }
コード例 #9
0
        internal static EventBase CreateEvent(Event systemEvent)
        {
            EventType type = systemEvent.type;
            EventBase pooled;

            switch (type)
            {
            case EventType.MouseDown:
                pooled = MouseEventBase <MouseDownEvent> .GetPooled(systemEvent);

                break;

            case EventType.MouseUp:
                pooled = MouseEventBase <MouseUpEvent> .GetPooled(systemEvent);

                break;

            case EventType.MouseMove:
                pooled = MouseEventBase <MouseMoveEvent> .GetPooled(systemEvent);

                break;

            case EventType.MouseDrag:
                pooled = MouseEventBase <MouseMoveEvent> .GetPooled(systemEvent);

                break;

            case EventType.KeyDown:
                pooled = KeyboardEventBase <KeyDownEvent> .GetPooled(systemEvent);

                break;

            case EventType.KeyUp:
                pooled = KeyboardEventBase <KeyUpEvent> .GetPooled(systemEvent);

                break;

            case EventType.ScrollWheel:
                pooled = WheelEvent.GetPooled(systemEvent);
                break;

            default:
                if (type != EventType.MouseEnterWindow)
                {
                    if (type != EventType.MouseLeaveWindow)
                    {
                        pooled = IMGUIEvent.GetPooled(systemEvent);
                    }
                    else
                    {
                        pooled = MouseEventBase <MouseLeaveWindowEvent> .GetPooled(systemEvent);
                    }
                }
                else
                {
                    pooled = MouseEventBase <MouseEnterWindowEvent> .GetPooled(systemEvent);
                }
                break;
            }
            return(pooled);
        }