예제 #1
0
        internal static void EndContainerGUI(Event evt, Rect layoutSize)
        {
            bool flag = Event.current.type == EventType.Layout && UIElementsUtility.s_ContainerStack.Count > 0;

            if (flag)
            {
                GUILayoutUtility.LayoutFromContainer(layoutSize.width, layoutSize.height);
            }
            GUILayoutUtility.SelectIDList(GUIUtility.s_OriginalID, false);
            GUIContent.ClearStaticCache();
            bool flag2 = UIElementsUtility.s_ContainerStack.Count > 0;

            if (flag2)
            {
                IMGUIContainer obj   = UIElementsUtility.s_ContainerStack.Peek();
                bool           flag3 = UIElementsUtility.s_EndContainerCallback != null;
                if (flag3)
                {
                    UIElementsUtility.s_EndContainerCallback(obj);
                }
            }
            evt.CopyFrom(Event.current);
            bool flag4 = UIElementsUtility.s_ContainerStack.Count > 0;

            if (flag4)
            {
                GUIUtility.EndContainer();
                UIElementsUtility.s_ContainerStack.Pop();
            }
        }
        // End the 2D GUI.
        internal static void EndContainerGUI(Event evt, Rect layoutSize)
        {
            if (Event.current.type == EventType.Layout &&
                s_ContainerStack.Count > 0)
            {
                GUILayoutUtility.LayoutFromContainer(layoutSize.width, layoutSize.height);
            }
            // restore cache
            GUILayoutUtility.SelectIDList(GUIUtility.s_OriginalID, false);
            GUIContent.ClearStaticCache();

            if (s_ContainerStack.Count > 0)
            {
                IMGUIContainer container = s_ContainerStack.Peek();
                if (s_EndContainerCallback != null)
                {
                    s_EndContainerCallback(container);
                }
            }

            evt.CopyFrom(Event.current);

            if (s_ContainerStack.Count > 0)
            {
                GUIUtility.EndContainer();
                s_ContainerStack.Pop();
            }
        }
        private static bool SendEventToIMGUIContainer(EventBase evt, BaseVisualElementPanel panel)
        {
            bool flag = evt.imguiEvent == null;
            bool result;

            if (flag)
            {
                result = false;
            }
            else
            {
                IMGUIContainer rootIMGUIContainer = panel.rootIMGUIContainer;
                bool           flag2 = rootIMGUIContainer == null;
                if (flag2)
                {
                    result = false;
                }
                else
                {
                    bool flag3 = evt.propagateToIMGUI || evt.eventTypeId == EventBase <MouseEnterWindowEvent> .TypeId() || evt.eventTypeId == EventBase <MouseLeaveWindowEvent> .TypeId();

                    if (flag3)
                    {
                        evt.skipElements.Add(evt.target);
                        EventDispatchUtilities.PropagateToIMGUIContainer(panel.visualTree, evt);
                    }
                    result = MouseEventDispatchingStrategy.IsDone(evt);
                }
            }
            return(result);
        }
예제 #4
0
        private static void GetCurrentTransformAndClip(IMGUIContainer container, Event evt, out Matrix4x4 transform, out Rect clipRect)
        {
            clipRect  = container.GetCurrentClipRect();
            transform = container.worldTransform;
            bool flag = evt.rawType == EventType.Repaint && container.elementPanel != null;

            if (flag)
            {
                transform = container.elementPanel.repaintData.currentOffset * container.worldTransform;
            }
        }
예제 #5
0
        private static void GetCurrentTransformAndClip(IMGUIContainer container, Event evt, out Matrix4x4 transform, out Rect clipRect)
        {
            clipRect = container.GetCurrentClipRect();

            transform = container.worldTransform;
            if (evt?.rawType == EventType.Repaint &&
                container.elementPanel != null)
            {
                // during repaint, we must use in case the current transform is not relative to Panel
                // this is to account for the pixel caching feature
                transform = container.elementPanel.repaintData.currentOffset * container.worldTransform;
            }
        }
        public void DispatchEvent(EventBase evt, IPanel panel)
        {
            bool flag = panel != null;

            if (flag)
            {
                Focusable leafFocusedElement = panel.focusController.GetLeafFocusedElement();
                bool      flag2 = leafFocusedElement != null;
                if (flag2)
                {
                    bool isIMGUIContainer = leafFocusedElement.isIMGUIContainer;
                    if (isIMGUIContainer)
                    {
                        IMGUIContainer iMGUIContainer = (IMGUIContainer)leafFocusedElement;
                        bool           flag3          = !evt.Skip(iMGUIContainer) && iMGUIContainer.SendEventToIMGUI(evt, true, true);
                        if (flag3)
                        {
                            evt.StopPropagation();
                            evt.PreventDefault();
                        }
                        bool flag4 = !evt.isPropagationStopped && evt.propagateToIMGUI;
                        if (flag4)
                        {
                            evt.skipElements.Add(iMGUIContainer);
                            EventDispatchUtilities.PropagateToIMGUIContainer(panel.visualTree, evt);
                        }
                    }
                    else
                    {
                        evt.target = panel.focusController.GetLeafFocusedElement();
                        EventDispatchUtilities.PropagateEvent(evt);
                        bool flag5 = !evt.isPropagationStopped && evt.propagateToIMGUI;
                        if (flag5)
                        {
                            EventDispatchUtilities.PropagateToIMGUIContainer(panel.visualTree, evt);
                        }
                    }
                }
                else
                {
                    EventDispatchUtilities.PropagateToIMGUIContainer(panel.visualTree, evt);
                }
            }
            evt.propagateToIMGUI = false;
            evt.stopDispatch     = true;
        }
예제 #7
0
        internal static void PropagateToIMGUIContainer(VisualElement root, EventBase evt)
        {
            bool flag = evt.imguiEvent == null || root.elementPanel.contextType == ContextType.Player;

            if (!flag)
            {
                bool isIMGUIContainer = root.isIMGUIContainer;
                if (isIMGUIContainer)
                {
                    IMGUIContainer iMGUIContainer = root as IMGUIContainer;
                    bool           flag2          = evt.Skip(iMGUIContainer);
                    if (flag2)
                    {
                        return;
                    }
                    Focusable expr_54 = evt.target as Focusable;
                    bool      flag3   = expr_54 != null && expr_54.focusable;
                    bool      flag4   = iMGUIContainer.SendEventToIMGUI(evt, !flag3, true);
                    if (flag4)
                    {
                        evt.StopPropagation();
                        evt.PreventDefault();
                    }
                    bool flag5 = evt.imguiEvent.rawType == EventType.Used;
                    if (flag5)
                    {
                        Debug.Assert(evt.isPropagationStopped);
                    }
                }
                bool flag6 = root.imguiContainerDescendantCount > 0;
                if (flag6)
                {
                    int childCount = root.hierarchy.childCount;
                    for (int i = 0; i < childCount; i++)
                    {
                        EventDispatchUtilities.PropagateToIMGUIContainer(root.hierarchy[i], evt);
                        bool isPropagationStopped = evt.isPropagationStopped;
                        if (isPropagationStopped)
                        {
                            break;
                        }
                    }
                }
            }
        }
        private static void GetCurrentTransformAndClip(IMGUIContainer container, Event evt, out Matrix4x4 transform, out Rect clipRect)
        {
            clipRect = container.lastWorldClip;
            if (clipRect.width == 0.0f || clipRect.height == 0.0f)
            {
                // lastWorldClip will be empty until the first repaint occurred,
                // we fall back on the worldBound in this case.
                clipRect = container.worldBound;
            }

            transform = container.worldTransform;
            if (evt.type == EventType.Repaint &&
                container.elementPanel != null)
            {
                // during repaint, we must use in case the current transform is not relative to Panel
                // this is to account for the pixel caching feature
                transform = container.elementPanel.repaintData.currentOffset * container.worldTransform;
            }
        }
예제 #9
0
        bool IUIElementsUtility.TakeCapture()
        {
            bool flag = UIElementsUtility.s_ContainerStack.Count > 0;
            bool result;

            if (flag)
            {
                IMGUIContainer iMGUIContainer   = UIElementsUtility.s_ContainerStack.Peek();
                IEventHandler  capturingElement = iMGUIContainer.panel.GetCapturingElement(PointerId.mousePointerId);
                bool           flag2            = capturingElement != null && capturingElement != iMGUIContainer;
                if (flag2)
                {
                    Debug.Log("Should not grab hot control with an active capture");
                }
                iMGUIContainer.CaptureMouse();
                result = true;
            }
            else
            {
                result = false;
            }
            return(result);
        }
        internal static void BeginContainerGUI(GUILayoutUtility.LayoutCache cache, Event evt, IMGUIContainer container)
        {
            if (container.useOwnerObjectGUIState)
            {
                GUIUtility.BeginContainerFromOwner(container.elementPanel.ownerObject);
            }
            else
            {
                GUIUtility.BeginContainer(container.guiState);
            }

            s_ContainerStack.Push(container);
            GUIUtility.s_SkinMode   = (int)container.contextType;
            GUIUtility.s_OriginalID = container.elementPanel.ownerObject.GetInstanceID();

            if (Event.current == null)
            {
                Event.current = evt;
            }
            else
            {
                Event.current.CopyFrom(evt);
            }

            // call AFTER setting current event
            if (s_BeginContainerCallback != null)
            {
                s_BeginContainerCallback(container);
            }

            GUI.enabled = container.enabledInHierarchy;
            GUILayoutUtility.BeginContainer(cache);
            GUIUtility.ResetGlobalState();
        }
예제 #11
0
        internal static void BeginContainerGUI(GUILayoutUtility.LayoutCache cache, Event evt, IMGUIContainer container)
        {
            bool useOwnerObjectGUIState = container.useOwnerObjectGUIState;

            if (useOwnerObjectGUIState)
            {
                GUIUtility.BeginContainerFromOwner(container.elementPanel.ownerObject);
            }
            else
            {
                GUIUtility.BeginContainer(container.guiState);
            }
            UIElementsUtility.s_ContainerStack.Push(container);
            GUIUtility.s_SkinMode   = (int)container.contextType;
            GUIUtility.s_OriginalID = container.elementPanel.ownerObject.GetInstanceID();
            bool flag = Event.current == null;

            if (flag)
            {
                Event.current = evt;
            }
            else
            {
                Event.current.CopyFrom(evt);
            }
            bool flag2 = UIElementsUtility.s_BeginContainerCallback != null;

            if (flag2)
            {
                UIElementsUtility.s_BeginContainerCallback(container);
            }
            GUI.enabled = container.enabledInHierarchy;
            GUILayoutUtility.BeginContainer(cache);
            GUIUtility.ResetGlobalState();
        }
예제 #12
0
 internal bool HandleIMGUIEvent(Event e, Action onGUIHandler, bool canAffectFocus)
 {
     IMGUIContainer.GetCurrentTransformAndClip(this, e, out this.m_CachedTransform, out this.m_CachedClippingRect);
     return(this.HandleIMGUIEvent(e, this.m_CachedTransform, this.m_CachedClippingRect, onGUIHandler, canAffectFocus));
 }