public bool InterceptMouseEvent(IPanel panel, IMouseEvent ev)
{
if (!m_Context.pickElement)
{
return(false);
}
var evtBase = ev as EventBase;
var evtType = evtBase.eventTypeId;
var target = evtBase.target as VisualElement;
// Ignore events on detached elements
if (panel == null)
{
return(false);
}
if (((BaseVisualElementPanel)panel).ownerObject is HostView hostView && hostView.actualView is PlayModeView playModeView)
{
// Send event to runtime panels from closest to deepest
var panels = UIElementsRuntimeUtility.GetSortedPlayerPanels();
for (var i = panels.Count - 1; i >= 0; i--)
{
if (SendEventToRuntimePanel((BaseRuntimePanel)panels[i], evtBase, playModeView.viewPadding, playModeView.viewMouseScale))
{
return(true);
}
}
// If no RuntimePanel catches it, select GameView editor panel and let interception fall through.
if (evtType == MouseMoveEvent.TypeId() && m_Context.selectedElement != target)
{
OnPickMouseOver(target, panel);
}
}
private void TrySelectWindow()
{
VisualElement root = null;
if (m_WindowToDebug is GameView)
{
var runtimePanels = UIElementsRuntimeUtility.GetSortedPlayerPanels();
if (runtimePanels != null && runtimePanels.Count > 0)
{
root = runtimePanels[0].visualTree;
}
}
if (root == null)
{
root = m_WindowToDebug.rootVisualElement;
}
if (root == null)
{
return;
}
IPanel searchedPanel = root.panel;
SelectPanelToDebug(searchedPanel);
if (m_SelectedPanel != null)
{
m_WindowToDebug = null;
m_ConnectWindowScheduledItem.Pause();
}
}
/// <summary>
/// Create a new panel.
/// </summary>
/// <param name="scriptableObject">The owner of the panel.</param>
/// <returns>Returns the new panel.</returns>
public static IPanel CreatePanel(ScriptableObject scriptableObject)
{
var panel = UIElementsRuntimeUtility.CreateRuntimePanel(scriptableObject);
#if UNITY_EDITOR
EditorInternalBridge.CreateDebugPanel(panel);
#endif
panel.visualTree.pseudoStates |= PseudoStates.Root;
return(panel);
}
protected override void OnEnable()
{
base.OnEnable();
m_EventSystems.Add(this);
#if PACKAGE_UITOOLKIT
if (sendUIToolkitEvents)
{
UIElementsRuntimeUtility.RegisterEventSystem(this);
}
#endif
}
protected override void Start()
{
base.Start();
#if PACKAGE_UITOOLKIT
if (createUIToolkitPanelGameObjectsOnStart)
{
foreach (BaseRuntimePanel panel in UIElementsRuntimeUtility.GetSortedPlayerPanels())
{
CreateUIToolkitPanelGameObject(panel);
}
UIElementsRuntimeUtility.onCreatePanel += CreateUIToolkitPanelGameObject;
}
#endif
}
public void ProcessKeyboardEvents(InputSystemEventSystem eventSystem)
{
while (Event.PopEvent(m_Event))
{
if (m_Event.type != EventType.KeyDown && m_Event.type != EventType.KeyUp)
{
continue;
}
using (EventBase evt = UIElementsRuntimeUtility.CreateEvent(m_Event))
{
eventSystem.focusedPanel.visualTree.SendEvent(evt);
}
}
}
protected override void OnDisable()
{
#if PACKAGE_UITOOLKIT
UIElementsRuntimeUtility.UnregisterEventSystem(this);
#endif
if (m_CurrentInputModule != null)
{
m_CurrentInputModule.DeactivateModule();
m_CurrentInputModule = null;
}
m_EventSystems.Remove(this);
base.OnDisable();
}
public bool InterceptMouseEvent(IPanel panel, IMouseEvent ev)
{
if (!m_Context.pickElement)
{
return(false);
}
var evtBase = ev as EventBase;
var evtType = evtBase.eventTypeId;
var target = evtBase.target as VisualElement;
// Ignore events on detached elements
if (panel == null)
{
return(false);
}
if (((BaseVisualElementPanel)panel).ownerObject is HostView hostView && hostView.actualView is GameView)
{
var innerArea = panel.GetRootVisualElement();
var gameViewPadding =
(innerArea.parent.contentRect.height - innerArea.contentRect.height) * Vector2.up +
innerArea.layout.position; // Measured to: gameViewPadding = new Vector2(1, 40)
// Send event to runtime panels from closest to deepest
var panels = UIElementsRuntimeUtility.GetSortedPlayerPanels();
for (var i = panels.Count - 1; i >= 0; i--)
{
if (SendEventToRuntimePanel((BaseRuntimePanel)panels[i], evtBase, gameViewPadding))
{
return(true);
}
}
// If no RuntimePanel catches it, select GameView editor panel and let interception fall through.
if (evtType == MouseMoveEvent.TypeId() && m_Context.selectedElement != target)
{
OnPickMouseOver(target, panel);
}
}
/// <summary>
/// Sets how UI Toolkit runtime panels receive events and handle selection
/// when interacting with other objects that use the EventSystem, such as components from the Unity UI package.
/// </summary>
/// <param name="activeEventSystem">
/// The EventSystem used to override UI Toolkit panel events and selection.
/// If activeEventSystem is null, UI Toolkit panels will use current enabled EventSystem
/// or, if there is none, the default InputManager-based event system will be used.
/// </param>
/// <param name="sendEvents">
/// If true, UI Toolkit events will come from this EventSystem
/// instead of the default InputManager-based event system.
/// </param>
/// <param name="createPanelGameObjectsOnStart">
/// If true, UI Toolkit panels' unassigned selectableGameObject will be automatically initialized
/// with children GameObjects of this EventSystem on Start.
/// </param>
public static void SetUITookitEventSystemOverride(EventSystem activeEventSystem, bool sendEvents = true, bool createPanelGameObjectsOnStart = true)
{
#if PACKAGE_UITOOLKIT
UIElementsRuntimeUtility.UnregisterEventSystem(UIElementsRuntimeUtility.activeEventSystem);
s_UIToolkitOverride = new UIToolkitOverrideConfig
{
activeEventSystem = activeEventSystem,
sendEvents = sendEvents,
createPanelGameObjectsOnStart = createPanelGameObjectsOnStart,
};
if (sendEvents)
{
var eventSystem = activeEventSystem != null ? activeEventSystem : EventSystem.current;
if (eventSystem.isActiveAndEnabled)
{
UIElementsRuntimeUtility.RegisterEventSystem(activeEventSystem);
}
}
#endif
}
/// <summary>
/// Create a UIElements event from an Event.
/// </summary>
/// <param name="evt">The event to use as the source event.</param>
/// <returns>Returns a new UIElements event.</returns>
public static EventBase CreateEvent(Event evt)
{
return(UIElementsRuntimeUtility.CreateEvent(evt));
}
public static void DisposePanel(ScriptableObject scriptableObject)
{
UIElementsRuntimeUtility.DisposeRuntimePanel(scriptableObject);
}
/// <summary>
/// Unregister the panel from the engine.
/// </summary>
/// <param name="ownerID">The id of the ScriptableObject that owns the panel.</param>
public static void UnregisterPanel(int ownerID)
{
UIElementsRuntimeUtility.RemoveCachedPanel(ownerID);
}
/// <summary>
/// Register the panel in the engine.
/// </summary>
/// <param name="ownerID">The id of the ScriptableObject that owns the panel.</param>
/// <param name="panel">The panel to register.</param>
public static void RegisterPanel(int ownerID, IPanel panel)
{
var runtimePanel = panel as RuntimePanel;
UIElementsRuntimeUtility.RegisterCachedPanel(ownerID, runtimePanel);
}
