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