protected internal override void PostDispatch(IPanel panel) { if (PointerType.IsDirectManipulationDevice(pointerType)) { panel.ReleasePointer(pointerId); BaseVisualElementPanel basePanel = panel as BaseVisualElementPanel; basePanel?.ClearCachedElementUnderPointer(this); } if (panel.ShouldSendCompatibilityMouseEvents(this)) { using (var evt = MouseUpEvent.GetPooled(this)) { evt.target = target; target.SendEvent(evt); } } base.PostDispatch(panel); }
static bool SendEventToIMGUIContainer(EventBase evt, BaseVisualElementPanel panel) { if (evt.imguiEvent == null) return false; // Root IMGUI is the container that handles all the GUIView/DockArea logic for EditorWindows. var rootIMGUI = panel.rootIMGUIContainer; if (rootIMGUI == null) return false; // If root IMGUI doesn't use event, send it to other IMGUIs down the line. if (evt.propagateToIMGUI || evt.eventTypeId == MouseEnterWindowEvent.TypeId() || evt.eventTypeId == MouseLeaveWindowEvent.TypeId()) { evt.skipElements.Add(evt.target); EventDispatchUtilities.PropagateToIMGUIContainer(panel.visualTree, evt); } return IsDone(evt); }
static void SetBestTargetForEvent(EventBase evt, BaseVisualElementPanel panel) { UpdateElementUnderMouse(evt, panel, out VisualElement elementUnderMouse); if (evt.target != null) { evt.propagateToIMGUI = false; } else if (elementUnderMouse != null) { evt.propagateToIMGUI = false; evt.target = elementUnderMouse; } else { // Event occured outside the window. // Send event to visual tree root and // don't modify evt.propagateToIMGUI. evt.target = panel?.visualTree; } }
static bool SendEventToIMGUIContainer(EventBase evt, BaseVisualElementPanel panel) { if (evt.imguiEvent == null) { return(false); } // Root IMGUI is the container that handles all the GUIView/DockArea logic for EditorWindows. var rootIMGUI = panel.rootIMGUIContainer; if (rootIMGUI == null) { return(false); } // If root IMGUI doesn't use event, send it to other IMGUIs down the line. if (evt.propagateToIMGUI || evt.eventTypeId == MouseEnterWindowEvent.TypeId() || evt.eventTypeId == MouseLeaveWindowEvent.TypeId() || evt.target == rootIMGUI ) { evt.skipElements.Add(evt.target); EventDispatchUtilities.PropagateToIMGUIContainer(panel.visualTree, evt); } // If non-root element doesn't use event, send it to root IMGUI. // This is necessary for some behaviors like dropdown menus in IMGUI. // See case : https://fogbugz.unity3d.com/f/cases/1223087/ else { evt.skipElements.Add(evt.target); if (!evt.Skip(rootIMGUI)) { bool canAffectFocus = evt.target is Focusable f && !f.focusable && f.isIMGUIContainer; rootIMGUI.SendEventToIMGUI(evt, canAffectFocus); } } return(IsDone(evt)); }
void OnPanelChanged(BaseVisualElementPanel obj) { DisposeRenderChain(); if (panel != null) { renderChain = CreateRenderChain(); if (panel.visualTree != null) { renderChain.UIEOnChildAdded(panel.visualTree.hierarchy.parent, panel.visualTree, panel.visualTree.hierarchy.parent == null ? 0 : panel.visualTree.hierarchy.parent.IndexOf(panel.visualTree)); renderChain.UIEOnVisualsChanged(panel.visualTree, true); } panel.standardShaderChanged += OnPanelStandardShaderChanged; panel.standardWorldSpaceShaderChanged += OnPanelStandardWorldSpaceShaderChanged; panel.hierarchyChanged += OnPanelHierarchyChanged; OnPanelStandardShaderChanged(); if (panel.contextType == ContextType.Player) { OnPanelStandardWorldSpaceShaderChanged(); } } }
private static bool DoDispatch(BaseVisualElementPanel panel) { bool result = false; bool flag = UIElementsUtility.s_EventInstance.type == EventType.Repaint; if (flag) { using (UIElementsUtility.s_RepaintProfilerMarker.Auto()) { panel.Repaint(UIElementsUtility.s_EventInstance); } IPanelDebug expr_46 = panel.panelDebug; Panel expr_57 = ((expr_46 != null) ? expr_46.debuggerOverlayPanel : null) as Panel; if (expr_57 != null) { expr_57.Repaint(UIElementsUtility.s_EventInstance); } result = (panel.IMGUIContainersCount > 0); } else { panel.ValidateLayout(); using (EventBase eventBase = UIElementsUtility.CreateEvent(UIElementsUtility.s_EventInstance)) { bool flag2 = UIElementsUtility.s_EventInstance.type == EventType.Used || UIElementsUtility.s_EventInstance.type == EventType.Layout || UIElementsUtility.s_EventInstance.type == EventType.ExecuteCommand || UIElementsUtility.s_EventInstance.type == EventType.ValidateCommand; using (UIElementsUtility.s_EventProfilerMarker.Auto()) { panel.SendEvent(eventBase, flag2 ? DispatchMode.Immediate : DispatchMode.Default); } bool isPropagationStopped = eventBase.isPropagationStopped; if (isPropagationStopped) { panel.visualTree.IncrementVersion(VersionChangeType.Repaint); result = true; } } } return(result); }
static bool DoDispatch(BaseVisualElementPanel panel) { bool usesEvent = false; if (s_EventInstance.type == EventType.Repaint) { panel.Repaint(s_EventInstance); // TODO get rid of this when we wrap every GUIView inside IMGUIContainers // here we pretend to use the repaint event // in order to suspend to suspend OnGUI() processing on the native side // since we've already run it if we have an IMGUIContainer usesEvent = panel.IMGUIContainersCount > 0; } else { panel.ValidateLayout(); using (EventBase evt = CreateEvent(s_EventInstance)) { bool immediate = s_EventInstance.type == EventType.Used || s_EventInstance.type == EventType.Layout || s_EventInstance.type == EventType.ExecuteCommand || s_EventInstance.type == EventType.ValidateCommand; panel.SendEvent(evt, immediate ? DispatchMode.Immediate : DispatchMode.Queued); // The dispatcher should have finished processing the event, // otherwise we cannot return a value for usesEvent. // FIXME: this makes GUIPointWindowConversionOnMultipleWindow fails because the event sent in the OnGUI is put in the queue. // Debug.Assert(evt.processed); // FIXME: we dont always have to repaint if evt.isPropagationStopped. if (evt.isPropagationStopped) { panel.visualTree.IncrementVersion(VersionChangeType.Repaint); usesEvent = true; } } } return(usesEvent); }
static bool SendEventToIMGUIContainer(EventBase evt, BaseVisualElementPanel panel) { if (evt.propagateToIMGUI || evt.eventTypeId == MouseEnterWindowEvent.TypeId() || evt.eventTypeId == MouseLeaveWindowEvent.TypeId() ) { EventDispatchUtilities.PropagateToIMGUIContainer(panel.visualTree, evt); } else { // Send the events to the GUIView container so that it can process them. // This is necessary for some behaviors like dropdown menus in IMGUI. // See case : https://fogbugz.unity3d.com/f/cases/1223087/ var topLevelIMGUI = panel.rootIMGUIContainer; if (topLevelIMGUI != null && !evt.Skip(topLevelIMGUI) && evt.imguiEvent != null) { topLevelIMGUI.SendEventToIMGUI(evt, false); } } return(IsDone(evt)); }
static void UpdateElementUnderMouse(EventBase evt, BaseVisualElementPanel panel, out VisualElement elementUnderMouse) { bool shouldRecomputeTopElementUnderMouse = (evt as IMouseEventInternal)?.recomputeTopElementUnderMouse ?? true; elementUnderMouse = shouldRecomputeTopElementUnderMouse ? panel.Pick(((IMouseEvent)evt).mousePosition) : panel.GetTopElementUnderPointer(PointerId.mousePointerId); // If mouse leaves the window, make sure element under mouse is null. // However, if pressed button != 0, we are getting a MouseLeaveWindowEvent as part of // of a drag and drop operation, at the very beginning of the drag. Since // we are not really exiting the window, we do not want to set the element // under mouse to null in this case. if (evt.eventTypeId == MouseLeaveWindowEvent.TypeId() && (evt as MouseLeaveWindowEvent).pressedButtons == 0) { panel.SetElementUnderPointer(null, evt); } else if (shouldRecomputeTopElementUnderMouse) { panel.SetElementUnderPointer(elementUnderMouse, evt); } }
public void DispatchEvent(EventBase evt, IPanel panel) { EventBehavior captureBehavior = EventBehavior.None; IEventHandler capturingElement = panel?.GetCapturingElement(PointerId.mousePointerId); if (capturingElement == null) { return; } // Release mouse capture if capture element is not in a panel. VisualElement captureVE = capturingElement as VisualElement; if (evt.eventTypeId != MouseCaptureOutEvent.TypeId() && captureVE != null && captureVE.panel == null) { captureVE.ReleaseMouse(); return; } if (panel != null && captureVE != null && captureVE.panel.contextType != panel.contextType) { return; } IMouseEvent mouseEvent = evt as IMouseEvent; if (mouseEvent != null && (evt.target == null || evt.target == capturingElement)) { // Exclusive processing by capturing element. captureBehavior = EventBehavior.IsCapturable; captureBehavior |= EventBehavior.IsSentExclusivelyToCapturingElement; } else if (evt.imguiEvent != null && evt.target == null) { // Non exclusive processing by capturing element. captureBehavior = EventBehavior.IsCapturable; } if (evt.eventTypeId == MouseEnterWindowEvent.TypeId() || evt.eventTypeId == MouseLeaveWindowEvent.TypeId() || evt.eventTypeId == WheelEvent.TypeId()) { captureBehavior = EventBehavior.None; } if ((captureBehavior & EventBehavior.IsCapturable) == EventBehavior.IsCapturable) { BaseVisualElementPanel basePanel = panel as BaseVisualElementPanel; if (mouseEvent != null && basePanel != null) { bool shouldRecomputeTopElementUnderMouse = (mouseEvent as IMouseEventInternal)?.recomputeTopElementUnderMouse ?? true; if (shouldRecomputeTopElementUnderMouse) { basePanel.RecomputeTopElementUnderPointer(mouseEvent.mousePosition, evt); } } evt.dispatch = true; evt.target = capturingElement; evt.currentTarget = capturingElement; (capturingElement as CallbackEventHandler)?.HandleEventAtTargetPhase(evt); // Do further processing with a target computed the usual way. // However, if IsSentExclusivelyToCapturingElement, the only thing remaining to do is ExecuteDefaultAction, // which should be done with mouseCapture as the target. if ((captureBehavior & EventBehavior.IsSentExclusivelyToCapturingElement) != EventBehavior.IsSentExclusivelyToCapturingElement) { evt.target = null; } evt.currentTarget = null; evt.propagationPhase = PropagationPhase.None; evt.dispatch = false; // Do not call HandleEvent again for this element. evt.skipElements.Add(capturingElement); evt.stopDispatch = (captureBehavior & EventBehavior.IsSentExclusivelyToCapturingElement) == EventBehavior.IsSentExclusivelyToCapturingElement; if (evt.target is IMGUIContainer) { evt.propagateToIMGUI = true; evt.skipElements.Add(evt.target); } else { evt.propagateToIMGUI = false; } } }
public VisualTreeUpdater(BaseVisualElementPanel panel) { this.m_Panel = panel; this.m_UpdaterArray = new VisualTreeUpdater.UpdaterArray(); this.SetDefaultUpdaters(); }
public void DispatchEvent(EventBase evt, IPanel panel) { MouseCaptureDispatchingStrategy.EventBehavior eventBehavior = MouseCaptureDispatchingStrategy.EventBehavior.None; IEventHandler eventHandler = (panel != null) ? panel.GetCapturingElement(PointerId.mousePointerId) : null; bool flag = eventHandler == null; if (!flag) { VisualElement visualElement = eventHandler as VisualElement; bool flag2 = evt.eventTypeId != EventBase <MouseCaptureOutEvent> .TypeId() && visualElement != null && visualElement.panel == null; if (flag2) { visualElement.ReleaseMouse(); } else { bool flag3 = panel != null && visualElement != null && visualElement.panel.contextType != panel.contextType; if (!flag3) { IMouseEvent mouseEvent = evt as IMouseEvent; bool flag4 = mouseEvent != null && (evt.target == null || evt.target == eventHandler); if (flag4) { eventBehavior = MouseCaptureDispatchingStrategy.EventBehavior.IsCapturable; eventBehavior |= MouseCaptureDispatchingStrategy.EventBehavior.IsSentExclusivelyToCapturingElement; } else { bool flag5 = evt.imguiEvent != null && evt.target == null; if (flag5) { eventBehavior = MouseCaptureDispatchingStrategy.EventBehavior.IsCapturable; } } bool flag6 = evt.eventTypeId == EventBase <MouseEnterWindowEvent> .TypeId() || evt.eventTypeId == EventBase <MouseLeaveWindowEvent> .TypeId() || evt.eventTypeId == EventBase <WheelEvent> .TypeId(); if (flag6) { eventBehavior = MouseCaptureDispatchingStrategy.EventBehavior.None; } bool flag7 = (eventBehavior & MouseCaptureDispatchingStrategy.EventBehavior.IsCapturable) == MouseCaptureDispatchingStrategy.EventBehavior.IsCapturable; if (flag7) { BaseVisualElementPanel baseVisualElementPanel = panel as BaseVisualElementPanel; bool flag8 = mouseEvent != null && baseVisualElementPanel != null; if (flag8) { IMouseEventInternal expr_139 = mouseEvent as IMouseEventInternal; bool flag9 = expr_139 == null || expr_139.recomputeTopElementUnderMouse; bool flag10 = flag9; if (flag10) { baseVisualElementPanel.RecomputeTopElementUnderPointer(mouseEvent.mousePosition, evt); } } evt.dispatch = true; evt.target = eventHandler; CallbackEventHandler expr_175 = eventHandler as CallbackEventHandler; if (expr_175 != null) { expr_175.HandleEventAtTargetPhase(evt); } bool flag11 = (eventBehavior & MouseCaptureDispatchingStrategy.EventBehavior.IsSentExclusivelyToCapturingElement) != MouseCaptureDispatchingStrategy.EventBehavior.IsSentExclusivelyToCapturingElement; if (flag11) { evt.target = null; } evt.currentTarget = null; evt.propagationPhase = PropagationPhase.None; evt.dispatch = false; evt.skipElements.Add(eventHandler); evt.stopDispatch = ((eventBehavior & MouseCaptureDispatchingStrategy.EventBehavior.IsSentExclusivelyToCapturingElement) == MouseCaptureDispatchingStrategy.EventBehavior.IsSentExclusivelyToCapturingElement); bool flag12 = evt.target is IMGUIContainer; if (flag12) { evt.propagateToIMGUI = true; evt.skipElements.Add(evt.target); } else { evt.propagateToIMGUI = false; } } } } } }
static bool SendEventToTarget(EventBase evt, BaseVisualElementPanel panel) { return SendEventToRegularTarget(evt, panel) || SendEventToIMGUIContainer(evt, panel); }
public void DispatchEvent(EventBase evt, IPanel panel) { EventBehavior captureBehavior = EventBehavior.None; if (MouseCaptureController.mouseCapture == null) { return; } // Release mouse capture if capture element is not in a panel. VisualElement captureVE = MouseCaptureController.mouseCapture as VisualElement; if (evt.eventTypeId != MouseCaptureOutEvent.TypeId() && captureVE != null && captureVE.panel == null) { MouseCaptureController.ReleaseMouse(); return; } if (panel != null && captureVE != null && captureVE.panel.contextType != panel.contextType) { return; } IMouseEvent mouseEvent = evt as IMouseEvent; if (mouseEvent != null && (evt.target == null || evt.target == MouseCaptureController.mouseCapture)) { // Exclusive processing by capturing element. captureBehavior = EventBehavior.IsCapturable; captureBehavior |= EventBehavior.IsSentExclusivelyToCapturingElement; } else if (evt.imguiEvent != null && evt.target == null) { // Non exclusive processing by capturing element. captureBehavior = EventBehavior.IsCapturable; } if (evt.eventTypeId == MouseEnterWindowEvent.TypeId() || evt.eventTypeId == MouseLeaveWindowEvent.TypeId() || evt.eventTypeId == WheelEvent.TypeId()) { captureBehavior = EventBehavior.None; } if ((captureBehavior & EventBehavior.IsCapturable) == EventBehavior.IsCapturable) { BaseVisualElementPanel basePanel = panel as BaseVisualElementPanel; if (mouseEvent != null && basePanel != null) { bool shouldRecomputeTopElementUnderMouse = true; if ((IMouseEventInternal)mouseEvent != null) { shouldRecomputeTopElementUnderMouse = ((IMouseEventInternal)mouseEvent).recomputeTopElementUnderMouse; } VisualElement elementUnderMouse = shouldRecomputeTopElementUnderMouse ? basePanel.Pick(mouseEvent.mousePosition) : basePanel.topElementUnderMouse; basePanel.SetElementUnderMouse(elementUnderMouse, evt); } IEventHandler originalCaptureElement = MouseCaptureController.mouseCapture; 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 should be done with mouseCapture as the target. if ((captureBehavior & EventBehavior.IsSentExclusivelyToCapturingElement) != EventBehavior.IsSentExclusivelyToCapturingElement) { evt.target = null; } evt.currentTarget = null; evt.propagationPhase = PropagationPhase.None; evt.dispatch = false; // Do not call HandleEvent again for this element. evt.skipElements.Add(originalCaptureElement); evt.stopDispatch = (captureBehavior & EventBehavior.IsSentExclusivelyToCapturingElement) == EventBehavior.IsSentExclusivelyToCapturingElement; evt.propagateToIMGUI = false; } }
void OnPanelChanged(BaseVisualElementPanel obj) { DetachFromPanel(); AttachToPanel(); }
private static bool SendEventToTarget(EventBase evt, BaseVisualElementPanel panel) { return(MouseEventDispatchingStrategy.SendEventToRegularTarget(evt, panel) || MouseEventDispatchingStrategy.SendEventToIMGUIContainer(evt, panel)); }
public void DispatchEvent(EventBase evt, IPanel panel) { EventBehavior captureBehavior = EventBehavior.None; IEventHandler capturingElement = panel?.GetCapturingElement(PointerId.mousePointerId); if (capturingElement == null) { return; } // Release mouse capture if capture element is not in a panel. VisualElement captureVE = capturingElement as VisualElement; if (evt.eventTypeId != MouseCaptureOutEvent.TypeId() && captureVE != null && captureVE.panel == null) { captureVE.ReleaseMouse(); return; } // Case 1342115: mouse position is in local panel coordinates; sending event to a target from a different // panel will lead to a wrong position, so we don't allow it. Note that in general the mouse-down-move-up // sequence still works properly because the OS captures the mouse on the starting EditorWindow. if (panel != null && captureVE != null && captureVE.panel != panel) { return; } IMouseEvent mouseEvent = evt as IMouseEvent; if (mouseEvent != null && (evt.target == null || evt.target == capturingElement)) { // Exclusive processing by capturing element. captureBehavior = EventBehavior.IsCapturable; captureBehavior |= EventBehavior.IsSentExclusivelyToCapturingElement; } else if (evt.imguiEvent != null && evt.target == null) { // Non exclusive processing by capturing element. captureBehavior = EventBehavior.IsCapturable; } if (evt.eventTypeId == MouseEnterWindowEvent.TypeId() || evt.eventTypeId == MouseLeaveWindowEvent.TypeId() || evt.eventTypeId == WheelEvent.TypeId()) { captureBehavior = EventBehavior.None; } if ((captureBehavior & EventBehavior.IsCapturable) == EventBehavior.IsCapturable) { BaseVisualElementPanel basePanel = panel as BaseVisualElementPanel; if (mouseEvent != null && basePanel != null) { bool shouldRecomputeTopElementUnderMouse = (mouseEvent as IMouseEventInternal)?.recomputeTopElementUnderMouse ?? true; if (shouldRecomputeTopElementUnderMouse) { basePanel.RecomputeTopElementUnderPointer(PointerId.mousePointerId, mouseEvent.mousePosition, evt); } } evt.dispatch = true; evt.target = capturingElement; var skipDisabledElements = evt.skipDisabledElements; evt.skipDisabledElements = false; (capturingElement as CallbackEventHandler)?.HandleEventAtTargetPhase(evt); // Do further processing with a target computed the usual way. // However, if IsSentExclusivelyToCapturingElement, the only thing remaining to do is ExecuteDefaultAction, // which should be done with mouseCapture as the target. if ((captureBehavior & EventBehavior.IsSentExclusivelyToCapturingElement) != EventBehavior.IsSentExclusivelyToCapturingElement) { evt.target = null; evt.skipDisabledElements = skipDisabledElements; } evt.currentTarget = null; evt.propagationPhase = PropagationPhase.None; evt.dispatch = false; // Do not call HandleEvent again for this element. evt.skipElements.Add(capturingElement); evt.stopDispatch = (captureBehavior & EventBehavior.IsSentExclusivelyToCapturingElement) == EventBehavior.IsSentExclusivelyToCapturingElement; if (evt.target is IMGUIContainer) { evt.propagateToIMGUI = true; evt.skipElements.Add(evt.target); } else { evt.propagateToIMGUI = false; } } }
public virtual void DispatchEvent(EventBase evt, IPanel panel) { IMouseEvent mouseEvent = evt as IMouseEvent; // 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" BaseVisualElementPanel basePanel = panel as BaseVisualElementPanel; if (basePanel != null && (evt.eventTypeId == MouseLeaveWindowEvent.TypeId() || evt.eventTypeId == DragExitedEvent.TypeId())) { basePanel.SetElementUnderMouse(null, evt); } else { // update element under mouse and fire necessary events if (basePanel != null) { bool shouldRecomputeTopElementUnderMouse = true; if ((IMouseEventInternal)mouseEvent != null) { shouldRecomputeTopElementUnderMouse = ((IMouseEventInternal)mouseEvent).recomputeTopElementUnderMouse; } VisualElement elementUnderMouse = shouldRecomputeTopElementUnderMouse ? basePanel.Pick(mouseEvent.mousePosition) : basePanel.topElementUnderMouse; if (evt.target == null) { evt.target = elementUnderMouse; } // Because events are queued, we can set the element under mouse // right now, instead of waiting after the PropagateEvent() as we // did before. basePanel.SetElementUnderMouse(elementUnderMouse, evt); } if (evt.target != null) { evt.propagateToIMGUI = false; EventDispatchUtilities.PropagateEvent(evt); } } if (!evt.isPropagationStopped && panel != null) { if (evt.propagateToIMGUI || evt.eventTypeId == MouseEnterWindowEvent.TypeId() || evt.eventTypeId == MouseLeaveWindowEvent.TypeId() ) { EventDispatchUtilities.PropagateToIMGUIContainer(panel.visualTree, evt); } } evt.stopDispatch = true; }
static void OnPanelDestroyed(BaseVisualElementPanel panel) { s_GroupManagers.Remove(panel); panel.panelDisposed -= OnPanelDestroyed; }