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);
}
