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); } }
protected internal override void ExecuteDefaultAction(EventBase evt) { base.ExecuteDefaultAction(evt); editorEventHandler.ExecuteDefaultAction(evt); }
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)); }
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); }
// ActionStatusCallback for action that are always disabled. public static StatusFlags AlwaysDisabled(EventBase e) { return(StatusFlags.Disabled); }
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); }
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(); }
public abstract void SendEvent(EventBase e);
protected abstract void DoDisplayMenu(ContextualMenu menu, EventBase triggerEvent);
public sealed override void SendEvent(EventBase e) { elementPanel?.SendEvent(e); }
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); } } }
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); }
public EventCallbackFunctor(EventCallback <TEventType> callback, CallbackPhase phase) : base(phase) { m_Callback = callback; m_EventTypeId = EventBase <TEventType> .TypeId(); }
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)); }
// ActionStatusCallback for action that are always enabled. public static StatusFlags AlwaysEnabled(EventBase e) { return(StatusFlags.Normal); }
ContextualMenu.MenuAction.StatusFlags CutCopyActionStatus(EventBase e) { return((editorEngine.hasSelection && !isPasswordField) ? ContextualMenu.MenuAction.StatusFlags.Normal : ContextualMenu.MenuAction.StatusFlags.Disabled); }
public void UpdateActionStatus(EventBase e) { status = (actionStatusCallback != null ? actionStatusCallback(e) : StatusFlags.Hidden); }
ContextualMenu.MenuAction.StatusFlags PasteActionStatus(EventBase e) { return(editorEngine.CanPaste() ? ContextualMenu.MenuAction.StatusFlags.Normal : ContextualMenu.MenuAction.StatusFlags.Disabled); }
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); }
void Copy(EventBase e) { editorEngine.Copy(); }
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) { }
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; } }
internal void SendEvent(EventBase e, DispatchMode dispatchMode = DispatchMode.Queued) { Debug.Assert(dispatcher != null); dispatcher?.Dispatch(e, this, dispatchMode); }