private void LocalInit() { this.timestamp = Panel.TimeSinceStartupMs(); this.triggerEventId = 0uL; ulong expr_1C = EventBase.s_NextEventId; EventBase.s_NextEventId = expr_1C + 1uL; this.eventId = expr_1C; this.propagation = EventBase.EventPropagation.None; PropagationPaths expr_39 = this.m_Path; if (expr_39 != null) { expr_39.Release(); } this.m_Path = null; this.leafTarget = null; this.target = null; this.skipElements.Clear(); this.isPropagationStopped = false; this.isImmediatePropagationStopped = false; this.isDefaultPrevented = false; this.propagationPhase = PropagationPhase.None; this.originalMousePosition = Vector2.zero; this.m_CurrentTarget = null; this.dispatch = false; this.stopDispatch = false; this.propagateToIMGUI = true; this.dispatched = false; this.processed = false; this.processedByFocusController = false; this.imguiEventIsValid = false; this.pooled = false; this.eventLogger = null; }
void LogPropagationPathsInternal(EventBase evt, PropagationPaths paths) { var pathsCopy = paths == null ? new PropagationPaths() : new PropagationPaths(paths); AddPropagationPaths(evt, pathsCopy); UpdateModificationCount(); }
public static void LogPropagationPaths(EventBase evt, PropagationPaths paths) { if (evt.log) { evt.eventLogger.LogPropagationPathsInternal(evt, paths); } }
void LocalInit() { timestamp = (long)(Time.realtimeSinceStartup * 1000.0f); propagation = EventPropagation.None; m_Path?.Release(); m_Path = null; leafTarget = null; target = null; skipElements.Clear(); isPropagationStopped = false; isImmediatePropagationStopped = false; isDefaultPrevented = false; propagationPhase = PropagationPhase.None; originalMousePosition = Vector2.zero; m_CurrentTarget = null; dispatch = false; stopDispatch = false; propagateToIMGUI = true; dispatched = false; imguiEventIsValid = false; pooled = false; }
private void LogPropagationPathsInternal(EventBase evt, PropagationPaths paths) { PropagationPaths paths2 = (paths == null) ? new PropagationPaths() : new PropagationPaths(paths); this.AddPropagationPaths(evt, paths2); this.UpdateModificationCount(); }
public static void LogPropagationPaths(EventBase evt, PropagationPaths paths) { #if UNITY_EDITOR if (evt.log) { evt.eventLogger.LogPropagationPathsInternal(evt, paths); } #endif }
internal static PropagationPaths Copy(PropagationPaths paths) { PropagationPaths propagationPaths = PropagationPaths.s_Pool.Get(); propagationPaths.trickleDownPath.AddRange(paths.trickleDownPath); propagationPaths.targetElements.AddRange(paths.targetElements); propagationPaths.bubbleUpPath.AddRange(paths.bubbleUpPath); return(propagationPaths); }
public static PropagationPaths Build(VisualElement elem, Type pathTypesRequested) { if (elem == null || pathTypesRequested == Type.None) { return(null); } PropagationPaths paths = s_Pool.Get(); while (elem.hierarchy.parent != null) { if (elem.hierarchy.parent.enabledInHierarchy) { if (elem.hierarchy.parent.isCompositeRoot) { // Callback for elem.hierarchy.parent must be called at the Target phase. var item = new PropagationPathElement { m_VisualElement = elem.hierarchy.parent, m_IsTarget = true }; paths.targetAndBubblePath.Add(item); } else { if ((pathTypesRequested & Type.TrickleDown) == Type.TrickleDown && elem.hierarchy.parent.HasTrickleDownHandlers()) { paths.trickleDownPath.Add(elem.hierarchy.parent); } if ((pathTypesRequested & Type.BubbleUp) == Type.BubbleUp && elem.hierarchy.parent.HasBubbleUpHandlers()) { var item = new PropagationPathElement { m_VisualElement = elem.hierarchy.parent, m_IsTarget = false }; paths.targetAndBubblePath.Add(item); } } } elem = elem.hierarchy.parent; } return(paths); }
public static PropagationPaths Build(VisualElement elem, PropagationPaths.Type pathTypesRequested) { bool flag = elem == null || pathTypesRequested == PropagationPaths.Type.None; PropagationPaths result; if (flag) { result = null; } else { PropagationPaths propagationPaths = PropagationPaths.s_Pool.Get(); propagationPaths.targetElements.Add(elem); while (elem.hierarchy.parent != null) { bool enabledInHierarchy = elem.hierarchy.parent.enabledInHierarchy; if (enabledInHierarchy) { bool isCompositeRoot = elem.hierarchy.parent.isCompositeRoot; if (isCompositeRoot) { propagationPaths.targetElements.Add(elem.hierarchy.parent); } else { bool flag2 = (pathTypesRequested & PropagationPaths.Type.TrickleDown) == PropagationPaths.Type.TrickleDown && elem.hierarchy.parent.HasTrickleDownHandlers(); if (flag2) { propagationPaths.trickleDownPath.Add(elem.hierarchy.parent); } bool flag3 = (pathTypesRequested & PropagationPaths.Type.BubbleUp) == PropagationPaths.Type.BubbleUp && elem.hierarchy.parent.HasBubbleUpHandlers(); if (flag3) { propagationPaths.bubbleUpPath.Add(elem.hierarchy.parent); } } } elem = elem.hierarchy.parent; } result = propagationPaths; } return(result); }
void AddPropagationPaths(EventBase evt, PropagationPaths paths) { if (m_Log) { var pathObject = new EventDebuggerPathTrace(panel, evt, paths); List <EventDebuggerPathTrace> list; if (m_EventPathObjects.ContainsKey(panel)) { list = m_EventPathObjects[panel]; } else { list = new List <EventDebuggerPathTrace>(); m_EventPathObjects.Add(panel, list); } list.Add(pathObject); } }
void AddPropagationPaths(EventBase evt, PropagationPaths paths) { if (suspended) { return; } if (m_Log) { var pathObject = new EventDebuggerPathTrace(panel, evt, paths); if (!m_EventPathObjects.TryGetValue(panel, out var list)) { list = new List <EventDebuggerPathTrace>(); m_EventPathObjects.Add(panel, list); } list.Add(pathObject); } }
private void AddPropagationPaths(EventBase evt, PropagationPaths paths) { bool log = this.m_Log; if (log) { EventDebuggerPathTrace item = new EventDebuggerPathTrace(this.panel, evt, paths); bool flag = this.m_EventPathObjects.ContainsKey(this.panel); List <EventDebuggerPathTrace> list; if (flag) { list = this.m_EventPathObjects[this.panel]; } else { list = new List <EventDebuggerPathTrace>(); this.m_EventPathObjects.Add(this.panel, list); } list.Add(item); } }
void LocalInit() { timestamp = Panel.TimeSinceStartupMs(); triggerEventId = 0; eventId = s_NextEventId++; propagation = EventPropagation.None; m_Path?.Release(); m_Path = null; leafTarget = null; target = null; skipElements.Clear(); isPropagationStopped = false; isImmediatePropagationStopped = false; isDefaultPrevented = false; propagationPhase = PropagationPhase.None; originalMousePosition = Vector2.zero; m_CurrentTarget = null; dispatch = false; stopDispatch = false; propagateToIMGUI = true; dispatched = false; processed = false; processedByFocusController = false; imguiEventIsValid = false; pooled = false; #if UNITY_EDITOR eventLogger = null; #endif }
public static PropagationPaths Build(VisualElement elem, EventBase evt) { PropagationPaths paths = s_Pool.Get(); var eventCategory = evt.eventCategory; // Skip element if it has no event callbacks, default action, or default action at target if (elem.HasEventCallbacksOrDefaultActions(eventCategory)) { paths.targetElements.Add(elem); } // Go through the entire hierarchy. Don't bother checking elem.HasParentEventCallbacks because // 1. It too goes through the entire parent hierarchy, and // 2. It would require dirtying the parent categories when we set isCompositeRoot, so more overhead for (var ve = elem.nextParentWithEventCallback; ve != null; ve = ve.nextParentWithEventCallback) { if (ve.isCompositeRoot && !evt.ignoreCompositeRoots) { // Callback for elem must be called at the Target phase. Skip if no callback. if (ve.HasEventCallbacksOrDefaultActions(eventCategory)) { paths.targetElements.Add(ve); } } else if (ve.HasEventCallbacks(eventCategory)) { if (evt.tricklesDown && ve.HasTrickleDownHandlers()) { paths.trickleDownPath.Add(ve); } if (evt.bubbles && ve.HasBubbleUpHandlers()) { paths.bubbleUpPath.Add(ve); } } } return(paths); }
void ProcessEvent(EventBase evt, [NotNull] IPanel panel) { Event e = evt.imguiEvent; // Sometimes (in tests only?) we receive Used events. Protect our verification from this case. bool imguiEventIsInitiallyUsed = e != null && e.rawType == EventType.Used; using (new EventDispatcherGate(this)) { evt.PreDispatch(panel); if (!evt.stopDispatch && !evt.isPropagationStopped) { ApplyDispatchingStrategies(evt, panel, imguiEventIsInitiallyUsed); } // Last chance to build a path. Some dispatching strategies (e.g. PointerCaptureDispatchingStrategy) // don't call PropagateEvents but still need to call ExecuteDefaultActions on composite roots. var path = evt.path; if (path == null && evt.bubblesOrTricklesDown && evt.leafTarget is VisualElement leafTarget) { path = PropagationPaths.Build(leafTarget, evt); evt.path = path; EventDebugger.LogPropagationPaths(evt, path); } if (path != null) { foreach (var element in path.targetElements) { if (element.panel == panel) { evt.target = element; EventDispatchUtilities.ExecuteDefaultAction(evt); } } // Reset target to leaf target evt.target = evt.leafTarget; } else { // If no propagation path, make sure EventDispatchUtilities.ExecuteDefaultAction has a target if (!(evt.target is VisualElement target)) { evt.target = target = panel.visualTree; } if (target.panel == panel) { EventDispatchUtilities.ExecuteDefaultAction(evt); } } m_DebuggerEventDispatchingStrategy.PostDispatch(evt, panel); evt.PostDispatch(panel); m_ClickDetector.ProcessEvent(evt); Debug.Assert(imguiEventIsInitiallyUsed || evt.isPropagationStopped || e == null || e.rawType != EventType.Used, "Event is used but not stopped."); } }
public EventDebuggerPathTrace(IPanel panel, EventBase evt, PropagationPaths paths) : base(panel, evt, -1L, null) { this.< paths > k__BackingField = paths; }
public PropagationPaths(PropagationPaths paths) { trickleDownPath = new List <VisualElement>(paths.trickleDownPath); targetAndBubblePath = new List <PropagationPathElement>(paths.targetAndBubblePath); }
private static void HandleEventAcrossPropagationPath(EventBase evt) { // Build and store propagation path var leafTarget = (VisualElement)evt.leafTarget; var path = PropagationPaths.Build(leafTarget, evt); evt.path = path; EventDebugger.LogPropagationPaths(evt, path); var panel = leafTarget.panel; // Phase 1: TrickleDown phase // Propagate event from root to target.parent if (evt.tricklesDown) { evt.propagationPhase = PropagationPhase.TrickleDown; for (int i = path.trickleDownPath.Count - 1; i >= 0; i--) { if (evt.isPropagationStopped) { break; } var element = path.trickleDownPath[i]; if (evt.Skip(element) || element.panel != panel) { continue; } evt.currentTarget = element; evt.currentTarget.HandleEvent(evt); } } // Phase 2: Target / DefaultActionAtTarget // Propagate event from target parent up to root for the target phase // Call HandleEvent() even if propagation is stopped, for the default actions at target. evt.propagationPhase = PropagationPhase.AtTarget; foreach (var element in path.targetElements) { if (evt.Skip(element) || element.panel != panel) { continue; } evt.target = element; evt.currentTarget = evt.target; evt.currentTarget.HandleEvent(evt); } // Call ExecuteDefaultActionAtTarget evt.propagationPhase = PropagationPhase.DefaultActionAtTarget; foreach (var element in path.targetElements) { if (evt.Skip(element) || element.panel != panel) { continue; } evt.target = element; evt.currentTarget = evt.target; evt.currentTarget.HandleEvent(evt); } // Reset target to original target evt.target = evt.leafTarget; // Phase 3: bubble up phase // Propagate event from target parent up to root if (evt.bubbles) { evt.propagationPhase = PropagationPhase.BubbleUp; foreach (var element in path.bubbleUpPath) { if (evt.Skip(element) || element.panel != panel) { continue; } evt.currentTarget = element; evt.currentTarget.HandleEvent(evt); } } evt.propagationPhase = PropagationPhase.None; evt.currentTarget = null; }
public PropagationPaths(PropagationPaths paths) { this.trickleDownPath = new List <VisualElement>(paths.trickleDownPath); this.targetElements = new List <VisualElement>(paths.targetElements); this.bubbleUpPath = new List <VisualElement>(paths.bubbleUpPath); }