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 == DragExitedEvent.TypeId() ||
evt.eventTypeId == MouseEnterWindowEvent.TypeId() ||
evt.eventTypeId == MouseLeaveWindowEvent.TypeId())
{
evt.skipElements.Add(evt.target);
EventDispatchUtilities.PropagateToIMGUIContainer(panel.visualTree, evt);
}
return(IsDone(evt));
}
// 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 PointerMoveEvent.GetPooled(systemEvent);
case EventType.MouseDrag:
return PointerMoveEvent.GetPooled(systemEvent);
case EventType.MouseDown:
// If some buttons are already down, we generate PointerMove/MouseDown events.
// Otherwise we generate PointerDown/MouseDown events.
// See W3C pointer events recommendation: https://www.w3.org/TR/pointerevents2
if (PointerDeviceState.GetPressedButtons(PointerId.mousePointerId) != 0)
{
return PointerMoveEvent.GetPooled(systemEvent);
}
else
{
return PointerDownEvent.GetPooled(systemEvent);
}
case EventType.MouseUp:
// If more buttons are still down, we generate PointerMove/MouseUp events.
// Otherwise we generate PointerUp/MouseUp events.
// See W3C pointer events recommendation: https://www.w3.org/TR/pointerevents2
if (PointerDeviceState.HasAdditionalPressedButtons(PointerId.mousePointerId, systemEvent.button))
{
return PointerMoveEvent.GetPooled(systemEvent);
}
else
{
return PointerUpEvent.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);
}
}
// 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));
}
}
internal void SetElementUnderMouse(VisualElement newElementUnderMouse, EventBase triggerEvent)
{
if (newElementUnderMouse == topElementUnderMouse)
{
return;
}
VisualElement previousTopElementUnderMouse = topElementUnderMouse;
topElementUnderMouse = newElementUnderMouse;
IMouseEvent mouseEvent = triggerEvent == null ? null : triggerEvent as IMouseEvent;
var mousePosition = mouseEvent == null
? MousePositionTracker.mousePosition
: mouseEvent?.mousePosition ?? Vector2.zero;
// mouse enter/leave must be dispatched *any* time the element under mouse changes
using (new EventDispatcherGate(dispatcher))
{
MouseEventsHelper.SendEnterLeave <MouseLeaveEvent, MouseEnterEvent>(previousTopElementUnderMouse, topElementUnderMouse, mouseEvent, mousePosition);
}
if (triggerEvent == null ||
triggerEvent.eventTypeId == MouseMoveEvent.TypeId() ||
triggerEvent.eventTypeId == MouseDownEvent.TypeId() ||
triggerEvent.eventTypeId == MouseUpEvent.TypeId() ||
triggerEvent.eventTypeId == MouseEnterWindowEvent.TypeId() ||
triggerEvent.eventTypeId == MouseLeaveWindowEvent.TypeId() ||
triggerEvent.eventTypeId == WheelEvent.TypeId())
{
using (new EventDispatcherGate(dispatcher))
{
MouseEventsHelper.SendMouseOverMouseOut(previousTopElementUnderMouse, topElementUnderMouse, mouseEvent, mousePosition);
}
}
else if (triggerEvent.eventTypeId == DragUpdatedEvent.TypeId() ||
triggerEvent.eventTypeId == DragExitedEvent.TypeId())
{
using (new EventDispatcherGate(dispatcher))
{
MouseEventsHelper.SendEnterLeave <DragLeaveEvent, DragEnterEvent>(previousTopElementUnderMouse, topElementUnderMouse, mouseEvent, mousePosition);
}
}
}
internal void SetElementUnderMouse(VisualElement newElementUnderMouse, EventBase triggerEvent)
{
if (newElementUnderMouse == topElementUnderMouse)
{
return;
}
VisualElement previousTopElementUnderMouse = topElementUnderMouse;
topElementUnderMouse = newElementUnderMouse;
if (triggerEvent == null)
{
using (new EventDispatcherGate(dispatcher))
{
MouseEventsHelper.SendEnterLeave <MouseLeaveEvent, MouseEnterEvent>(previousTopElementUnderMouse, topElementUnderMouse, null, MousePositionTracker.mousePosition);
MouseEventsHelper.SendMouseOverMouseOut(previousTopElementUnderMouse, topElementUnderMouse, null, MousePositionTracker.mousePosition);
}
}
else if (
triggerEvent.eventTypeId == MouseMoveEvent.TypeId() ||
triggerEvent.eventTypeId == MouseDownEvent.TypeId() ||
triggerEvent.eventTypeId == MouseUpEvent.TypeId() ||
triggerEvent.eventTypeId == MouseEnterWindowEvent.TypeId() ||
triggerEvent.eventTypeId == MouseLeaveWindowEvent.TypeId() ||
triggerEvent.eventTypeId == WheelEvent.TypeId())
{
IMouseEvent mouseEvent = triggerEvent as IMouseEvent;
using (new EventDispatcherGate(dispatcher))
{
MouseEventsHelper.SendEnterLeave <MouseLeaveEvent, MouseEnterEvent>(previousTopElementUnderMouse, topElementUnderMouse, mouseEvent, mouseEvent?.mousePosition ?? Vector2.zero);
MouseEventsHelper.SendMouseOverMouseOut(previousTopElementUnderMouse, topElementUnderMouse, mouseEvent, mouseEvent?.mousePosition ?? Vector2.zero);
}
}
else if (triggerEvent.eventTypeId == DragUpdatedEvent.TypeId() ||
triggerEvent.eventTypeId == DragExitedEvent.TypeId())
{
IMouseEvent mouseEvent = triggerEvent as IMouseEvent;
using (new EventDispatcherGate(dispatcher))
{
MouseEventsHelper.SendEnterLeave <DragLeaveEvent, DragEnterEvent>(previousTopElementUnderMouse, topElementUnderMouse, mouseEvent, mouseEvent?.mousePosition ?? Vector2.zero);
}
}
}
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))
{
// Only permit switching the focus to another IMGUIContainer if the event target was not focusable
// and was itself an IMGUIContainer
bool canAffectFocus = evt.target is Focusable f && !f.focusable && f.isIMGUIContainer;
rootIMGUI.SendEventToIMGUI(evt, canAffectFocus);
}
}
return(IsDone(evt));
}
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));
}
public void ReplayEvents(List <EventDebuggerEventRecord> eventBases)
{
if (eventBases == null)
{
return;
}
foreach (var eventBase in eventBases)
{
Event newEvent = new Event
{
button = eventBase.button,
clickCount = eventBase.clickCount,
modifiers = eventBase.modifiers,
mousePosition = eventBase.mousePosition,
};
if (eventBase.eventTypeId == MouseMoveEvent.TypeId() && eventBase.hasUnderlyingPhysicalEvent)
{
newEvent.type = EventType.MouseMove;
panel.dispatcher.Dispatch(UIElementsUtility.CreateEvent(newEvent, EventType.MouseMove), panel,
DispatchMode.Default);
}
else if (eventBase.eventTypeId == MouseDownEvent.TypeId() && eventBase.hasUnderlyingPhysicalEvent)
{
newEvent.type = EventType.MouseDown;
panel.dispatcher.Dispatch(UIElementsUtility.CreateEvent(newEvent, EventType.MouseDown), panel,
DispatchMode.Default);
}
else if (eventBase.eventTypeId == MouseUpEvent.TypeId() && eventBase.hasUnderlyingPhysicalEvent)
{
newEvent.type = EventType.MouseUp;
panel.dispatcher.Dispatch(UIElementsUtility.CreateEvent(newEvent, EventType.MouseUp), panel,
DispatchMode.Default);
}
else if (eventBase.eventTypeId == ContextClickEvent.TypeId() && eventBase.hasUnderlyingPhysicalEvent)
{
newEvent.type = EventType.ContextClick;
panel.dispatcher.Dispatch(UIElementsUtility.CreateEvent(newEvent, EventType.ContextClick), panel,
DispatchMode.Default);
}
else if (eventBase.eventTypeId == MouseEnterWindowEvent.TypeId() && eventBase.hasUnderlyingPhysicalEvent)
{
newEvent.type = EventType.MouseEnterWindow;
panel.dispatcher.Dispatch(UIElementsUtility.CreateEvent(newEvent, EventType.MouseEnterWindow), panel,
DispatchMode.Default);
}
else if (eventBase.eventTypeId == MouseLeaveWindowEvent.TypeId() && eventBase.hasUnderlyingPhysicalEvent)
{
newEvent.type = EventType.MouseLeaveWindow;
panel.dispatcher.Dispatch(UIElementsUtility.CreateEvent(newEvent, EventType.MouseLeaveWindow), panel,
DispatchMode.Default);
}
else if (eventBase.eventTypeId == WheelEvent.TypeId() && eventBase.hasUnderlyingPhysicalEvent)
{
newEvent.type = EventType.ScrollWheel;
newEvent.delta = eventBase.delta;
panel.dispatcher.Dispatch(UIElementsUtility.CreateEvent(newEvent, EventType.ScrollWheel), panel,
DispatchMode.Default);
}
else if (eventBase.eventTypeId == KeyDownEvent.TypeId())
{
newEvent.type = EventType.KeyDown;
newEvent.character = eventBase.character;
newEvent.keyCode = eventBase.keyCode;
panel.dispatcher.Dispatch(UIElementsUtility.CreateEvent(newEvent, EventType.KeyDown), panel,
DispatchMode.Default);
}
else if (eventBase.eventTypeId == KeyUpEvent.TypeId())
{
newEvent.type = EventType.KeyUp;
newEvent.character = eventBase.character;
newEvent.keyCode = eventBase.keyCode;
panel.dispatcher.Dispatch(UIElementsUtility.CreateEvent(newEvent, EventType.KeyUp), panel,
DispatchMode.Default);
}
else if (eventBase.eventTypeId == DragUpdatedEvent.TypeId())
{
newEvent.type = EventType.DragUpdated;
panel.dispatcher.Dispatch(UIElementsUtility.CreateEvent(newEvent, EventType.DragUpdated), panel,
DispatchMode.Default);
}
else if (eventBase.eventTypeId == DragPerformEvent.TypeId())
{
newEvent.type = EventType.DragPerform;
panel.dispatcher.Dispatch(UIElementsUtility.CreateEvent(newEvent, EventType.DragPerform), panel,
DispatchMode.Default);
}
else if (eventBase.eventTypeId == DragExitedEvent.TypeId())
{
newEvent.type = EventType.DragExited;
panel.dispatcher.Dispatch(UIElementsUtility.CreateEvent(newEvent, EventType.DragExited), panel,
DispatchMode.Default);
}
else if (eventBase.eventTypeId == ValidateCommandEvent.TypeId())
{
newEvent.type = EventType.ValidateCommand;
newEvent.commandName = eventBase.commandName;
panel.dispatcher.Dispatch(UIElementsUtility.CreateEvent(newEvent, EventType.ValidateCommand), panel,
DispatchMode.Default);
}
else if (eventBase.eventTypeId == ExecuteCommandEvent.TypeId())
{
newEvent.type = EventType.ExecuteCommand;
newEvent.commandName = eventBase.commandName;
panel.dispatcher.Dispatch(UIElementsUtility.CreateEvent(newEvent, EventType.ExecuteCommand), panel,
DispatchMode.Default);
}
else if (eventBase.eventTypeId == IMGUIEvent.TypeId())
{
Debug.Log("Skipped IMGUI event (" + eventBase.eventBaseName + "): " + eventBase);
continue;
}
else
{
Debug.Log("Skipped event (" + eventBase.eventBaseName + "): " + eventBase);
continue;
}
Debug.Log("Replayed event (" + eventBase.eventBaseName + "): " + newEvent);
}
}
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;
}
}
}
private IEnumerator DoReplayEvents(IEnumerable <EventDebuggerEventRecord> eventBases, Action <int, int> refreshList)
{
var sortedEvents = eventBases.OrderBy(e => e.timestamp).ToList();
var sortedEventsCount = sortedEvents.Count;
IEnumerator AwaitForNextEvent(int currentIndex)
{
if (currentIndex == sortedEvents.Count - 1)
{
yield break;
}
var deltaTimestampMs = sortedEvents[currentIndex + 1].timestamp - sortedEvents[currentIndex].timestamp;
var timeMs = 0.0f;
while (timeMs < deltaTimestampMs)
{
if (isPlaybackPaused)
{
yield return(null);
}
else
{
var time = Panel.TimeSinceStartupMs();
yield return(null);
var delta = Panel.TimeSinceStartupMs() - time;
timeMs += delta * playbackSpeed;
}
}
}
for (var i = 0; i < sortedEventsCount; i++)
{
if (!isReplaying)
{
break;
}
var eventBase = sortedEvents[i];
var newEvent = new Event
{
button = eventBase.button,
clickCount = eventBase.clickCount,
modifiers = eventBase.modifiers,
mousePosition = eventBase.mousePosition,
};
if (eventBase.eventTypeId == MouseMoveEvent.TypeId() && eventBase.hasUnderlyingPhysicalEvent)
{
newEvent.type = EventType.MouseMove;
panel.dispatcher.Dispatch(UIElementsUtility.CreateEvent(newEvent, EventType.MouseMove), panel,
DispatchMode.Default);
}
else if (eventBase.eventTypeId == MouseDownEvent.TypeId() && eventBase.hasUnderlyingPhysicalEvent)
{
newEvent.type = EventType.MouseDown;
panel.dispatcher.Dispatch(UIElementsUtility.CreateEvent(newEvent, EventType.MouseDown), panel,
DispatchMode.Default);
}
else if (eventBase.eventTypeId == MouseUpEvent.TypeId() && eventBase.hasUnderlyingPhysicalEvent)
{
newEvent.type = EventType.MouseUp;
panel.dispatcher.Dispatch(UIElementsUtility.CreateEvent(newEvent, EventType.MouseUp), panel,
DispatchMode.Default);
}
else if (eventBase.eventTypeId == ContextClickEvent.TypeId() && eventBase.hasUnderlyingPhysicalEvent)
{
newEvent.type = EventType.ContextClick;
panel.dispatcher.Dispatch(UIElementsUtility.CreateEvent(newEvent, EventType.ContextClick), panel,
DispatchMode.Default);
}
else if (eventBase.eventTypeId == MouseEnterWindowEvent.TypeId() && eventBase.hasUnderlyingPhysicalEvent)
{
newEvent.type = EventType.MouseEnterWindow;
panel.dispatcher.Dispatch(UIElementsUtility.CreateEvent(newEvent, EventType.MouseEnterWindow), panel,
DispatchMode.Default);
}
else if (eventBase.eventTypeId == MouseLeaveWindowEvent.TypeId() && eventBase.hasUnderlyingPhysicalEvent)
{
newEvent.type = EventType.MouseLeaveWindow;
panel.dispatcher.Dispatch(UIElementsUtility.CreateEvent(newEvent, EventType.MouseLeaveWindow), panel,
DispatchMode.Default);
}
else if (eventBase.eventTypeId == PointerMoveEvent.TypeId() && eventBase.hasUnderlyingPhysicalEvent)
{
newEvent.type = EventType.MouseMove;
panel.dispatcher.Dispatch(UIElementsUtility.CreateEvent(newEvent, EventType.MouseMove), panel,
DispatchMode.Default);
}
else if (eventBase.eventTypeId == PointerDownEvent.TypeId() && eventBase.hasUnderlyingPhysicalEvent)
{
newEvent.type = EventType.MouseDown;
panel.dispatcher.Dispatch(UIElementsUtility.CreateEvent(newEvent, EventType.MouseDown), panel,
DispatchMode.Default);
}
else if (eventBase.eventTypeId == PointerUpEvent.TypeId() && eventBase.hasUnderlyingPhysicalEvent)
{
newEvent.type = EventType.MouseUp;
panel.dispatcher.Dispatch(UIElementsUtility.CreateEvent(newEvent, EventType.MouseUp), panel,
DispatchMode.Default);
}
else if (eventBase.eventTypeId == WheelEvent.TypeId() && eventBase.hasUnderlyingPhysicalEvent)
{
newEvent.type = EventType.ScrollWheel;
newEvent.delta = eventBase.delta;
panel.dispatcher.Dispatch(UIElementsUtility.CreateEvent(newEvent, EventType.ScrollWheel), panel,
DispatchMode.Default);
}
else if (eventBase.eventTypeId == KeyDownEvent.TypeId())
{
newEvent.type = EventType.KeyDown;
newEvent.character = eventBase.character;
newEvent.keyCode = eventBase.keyCode;
panel.dispatcher.Dispatch(UIElementsUtility.CreateEvent(newEvent, EventType.KeyDown), panel,
DispatchMode.Default);
}
else if (eventBase.eventTypeId == KeyUpEvent.TypeId())
{
newEvent.type = EventType.KeyUp;
newEvent.character = eventBase.character;
newEvent.keyCode = eventBase.keyCode;
panel.dispatcher.Dispatch(UIElementsUtility.CreateEvent(newEvent, EventType.KeyUp), panel,
DispatchMode.Default);
}
else if (eventBase.eventTypeId == NavigationMoveEvent.TypeId())
{
panel.dispatcher.Dispatch(NavigationMoveEvent.GetPooled(eventBase.navigationDirection, eventBase.deviceType, eventBase.modifiers), panel,
DispatchMode.Default);
}
else if (eventBase.eventTypeId == NavigationSubmitEvent.TypeId())
{
panel.dispatcher.Dispatch(NavigationSubmitEvent.GetPooled(eventBase.deviceType, eventBase.modifiers), panel,
DispatchMode.Default);
}
else if (eventBase.eventTypeId == NavigationCancelEvent.TypeId())
{
panel.dispatcher.Dispatch(NavigationCancelEvent.GetPooled(eventBase.deviceType, eventBase.modifiers), panel,
DispatchMode.Default);
}
else if (eventBase.eventTypeId == DragUpdatedEvent.TypeId())
{
newEvent.type = EventType.DragUpdated;
panel.dispatcher.Dispatch(UIElementsUtility.CreateEvent(newEvent, EventType.DragUpdated), panel,
DispatchMode.Default);
}
else if (eventBase.eventTypeId == DragPerformEvent.TypeId())
{
newEvent.type = EventType.DragPerform;
panel.dispatcher.Dispatch(UIElementsUtility.CreateEvent(newEvent, EventType.DragPerform), panel,
DispatchMode.Default);
}
else if (eventBase.eventTypeId == DragExitedEvent.TypeId())
{
newEvent.type = EventType.DragExited;
panel.dispatcher.Dispatch(UIElementsUtility.CreateEvent(newEvent, EventType.DragExited), panel,
DispatchMode.Default);
}
else if (eventBase.eventTypeId == ValidateCommandEvent.TypeId())
{
newEvent.type = EventType.ValidateCommand;
newEvent.commandName = eventBase.commandName;
panel.dispatcher.Dispatch(UIElementsUtility.CreateEvent(newEvent, EventType.ValidateCommand), panel,
DispatchMode.Default);
}
else if (eventBase.eventTypeId == ExecuteCommandEvent.TypeId())
{
newEvent.type = EventType.ExecuteCommand;
newEvent.commandName = eventBase.commandName;
panel.dispatcher.Dispatch(UIElementsUtility.CreateEvent(newEvent, EventType.ExecuteCommand), panel,
DispatchMode.Default);
}
else if (eventBase.eventTypeId == IMGUIEvent.TypeId())
{
Debug.Log("Skipped IMGUI event (" + eventBase.eventBaseName + "): " + eventBase);
var awaitSkipped = AwaitForNextEvent(i);
while (awaitSkipped.MoveNext())
{
yield return(null);
}
continue;
}
else
{
Debug.Log("Skipped event (" + eventBase.eventBaseName + "): " + eventBase);
var awaitSkipped = AwaitForNextEvent(i);
while (awaitSkipped.MoveNext())
{
yield return(null);
}
continue;
}
refreshList?.Invoke(i, sortedEventsCount);
Debug.Log($"Replayed event {eventBase.eventId.ToString()} ({eventBase.eventBaseName}): {newEvent}");
var await = AwaitForNextEvent(i);
while (await.MoveNext())
{
yield return(null);
}
}
isReplaying = false;
}
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;
}
}
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;
}
// 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(PointerMoveEvent.GetPooled(systemEvent));
case EventType.MouseDrag:
return(PointerMoveEvent.GetPooled(systemEvent));
case EventType.MouseDown:
// If some buttons are already down, we generate PointerMove/MouseDown events.
// Otherwise we generate PointerDown/MouseDown events.
// See W3C pointer events recommendation: https://www.w3.org/TR/pointerevents2
// Note: sometimes systemEvent.button is already pressed (systemEvent is processed multiple times).
if (PointerDeviceState.HasAdditionalPressedButtons(PointerId.mousePointerId, systemEvent.button))
{
return(PointerMoveEvent.GetPooled(systemEvent));
}
else
{
return(PointerDownEvent.GetPooled(systemEvent));
}
case EventType.MouseUp:
// If more buttons are still down, we generate PointerMove/MouseUp events.
// Otherwise we generate PointerUp/MouseUp events.
// See W3C pointer events recommendation: https://www.w3.org/TR/pointerevents2
if (PointerDeviceState.HasAdditionalPressedButtons(PointerId.mousePointerId, systemEvent.button))
{
return(PointerMoveEvent.GetPooled(systemEvent));
}
else
{
return(PointerUpEvent.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));
#if UNITY_EDITOR
case EventType.DragUpdated:
return(DragUpdatedEvent.GetPooled(systemEvent));
case EventType.DragPerform:
return(DragPerformEvent.GetPooled(systemEvent));
case EventType.DragExited:
return(DragExitedEvent.GetPooled(systemEvent));
#endif
case EventType.ValidateCommand:
return(ValidateCommandEvent.GetPooled(systemEvent));
case EventType.ExecuteCommand:
return(ExecuteCommandEvent.GetPooled(systemEvent));
default: // Layout, Ignore, Used
return(IMGUIEvent.GetPooled(systemEvent));
}
}