public EventCallbackList Get(EventCallbackList initializer) { EventCallbackList element; if (m_Stack.Count == 0) { if (initializer != null) { element = new EventCallbackList(initializer); } else { element = new EventCallbackList(); } } else { element = m_Stack.Pop(); if (initializer != null) { element.AddRange(initializer); } } return(element); }
private EventCallbackList GetCallbackListForWriting() { bool flag = this.m_IsInvoking > 0; EventCallbackList result; if (flag) { bool flag2 = this.m_TemporaryCallbacks == null; if (flag2) { bool flag3 = this.m_Callbacks != null; if (flag3) { this.m_TemporaryCallbacks = EventCallbackRegistry.GetCallbackList(this.m_Callbacks); } else { this.m_TemporaryCallbacks = EventCallbackRegistry.GetCallbackList(null); } } result = this.m_TemporaryCallbacks; } else { bool flag4 = this.m_Callbacks == null; if (flag4) { this.m_Callbacks = EventCallbackRegistry.GetCallbackList(null); } result = this.m_Callbacks; } return(result); }
public void InvokeCallbacks(EventBase evt) { if (m_Callbacks == null) { return; } m_IsInvoking++; for (var i = 0; i < m_Callbacks.Count; i++) { if (evt.isImmediatePropagationStopped) { break; } m_Callbacks[i].Invoke(evt); } m_IsInvoking--; if (m_IsInvoking == 0) { // If callbacks were modified during callback invocation, update them now. if (m_TemporaryCallbacks != null) { ReleaseCallbackList(m_Callbacks); m_Callbacks = GetCallbackList(m_TemporaryCallbacks); ReleaseCallbackList(m_TemporaryCallbacks); m_TemporaryCallbacks = null; } } }
public void RegisterCallback <TEventType, TCallbackArgs>(EventCallback <TEventType, TCallbackArgs> callback, TCallbackArgs userArgs, TrickleDown useTrickleDown = TrickleDown.NoTrickleDown, InvokePolicy invokePolicy = default) where TEventType : EventBase <TEventType>, new() { if (callback == null) { throw new ArgumentException("callback parameter is null"); } long eventTypeId = EventBase <TEventType> .TypeId(); var callbackPhase = useTrickleDown == TrickleDown.TrickleDown ? CallbackPhase.TrickleDownAndTarget : CallbackPhase.TargetAndBubbleUp; EventCallbackList callbackList = GetCallbackListForReading(); if (callbackList != null) { var functor = callbackList.Find(eventTypeId, callback, callbackPhase) as EventCallbackFunctor <TEventType, TCallbackArgs>; if (functor != null) { functor.userArgs = userArgs; return; } } callbackList = GetCallbackListForWriting(); callbackList.Add(new EventCallbackFunctor <TEventType, TCallbackArgs>(callback, userArgs, callbackPhase, invokePolicy)); }
public void InvokeCallbacks(EventBase evt) { bool flag = this.m_Callbacks == null; if (!flag) { this.m_IsInvoking++; for (int i = 0; i < this.m_Callbacks.Count; i++) { bool isImmediatePropagationStopped = evt.isImmediatePropagationStopped; if (isImmediatePropagationStopped) { break; } this.m_Callbacks[i].Invoke(evt); } this.m_IsInvoking--; bool flag2 = this.m_IsInvoking == 0; if (flag2) { bool flag3 = this.m_TemporaryCallbacks != null; if (flag3) { EventCallbackRegistry.ReleaseCallbackList(this.m_Callbacks); this.m_Callbacks = EventCallbackRegistry.GetCallbackList(this.m_TemporaryCallbacks); EventCallbackRegistry.ReleaseCallbackList(this.m_TemporaryCallbacks); this.m_TemporaryCallbacks = null; } } } }
internal bool TryGetUserArgs <TEventType, TCallbackArgs>(EventCallback <TEventType, TCallbackArgs> callback, TrickleDown useTrickleDown, out TCallbackArgs userArgs) where TEventType : EventBase <TEventType>, new() { userArgs = default(TCallbackArgs); bool flag = callback == null; bool result; if (flag) { result = false; } else { EventCallbackList callbackListForReading = this.GetCallbackListForReading(); long eventTypeId = EventBase <TEventType> .TypeId(); CallbackPhase phase = (useTrickleDown == TrickleDown.TrickleDown) ? CallbackPhase.TrickleDownAndTarget : CallbackPhase.TargetAndBubbleUp; EventCallbackFunctor <TEventType, TCallbackArgs> eventCallbackFunctor = callbackListForReading.Find(eventTypeId, callback, phase) as EventCallbackFunctor <TEventType, TCallbackArgs>; bool flag2 = eventCallbackFunctor == null; if (flag2) { result = false; } else { userArgs = eventCallbackFunctor.userArgs; result = true; } } return(result); }
public void RegisterCallback <TEventType, TCallbackArgs>(EventCallback <TEventType, TCallbackArgs> callback, TCallbackArgs userArgs, TrickleDown useTrickleDown = TrickleDown.NoTrickleDown) where TEventType : EventBase <TEventType>, new() { bool flag = callback == null; if (flag) { throw new ArgumentException("callback parameter is null"); } long eventTypeId = EventBase <TEventType> .TypeId(); CallbackPhase phase = (useTrickleDown == TrickleDown.TrickleDown) ? CallbackPhase.TrickleDownAndTarget : CallbackPhase.TargetAndBubbleUp; EventCallbackList eventCallbackList = this.GetCallbackListForReading(); bool flag2 = eventCallbackList != null; if (flag2) { EventCallbackFunctor <TEventType, TCallbackArgs> eventCallbackFunctor = eventCallbackList.Find(eventTypeId, callback, phase) as EventCallbackFunctor <TEventType, TCallbackArgs>; bool flag3 = eventCallbackFunctor != null; if (flag3) { eventCallbackFunctor.userArgs = userArgs; return; } } eventCallbackList = this.GetCallbackListForWriting(); eventCallbackList.Add(new EventCallbackFunctor <TEventType, TCallbackArgs>(callback, userArgs, phase)); }
EventCallbackList GetCallbackListForWriting() { if (m_IsInvoking > 0) { if (m_TemporaryCallbacks == null) { if (m_Callbacks != null) { m_TemporaryCallbacks = GetCallbackList(m_Callbacks); } else { m_TemporaryCallbacks = GetCallbackList(); } } return(m_TemporaryCallbacks); } else { if (m_Callbacks == null) { m_Callbacks = GetCallbackList(); } return(m_Callbacks); } }
public EventCallbackList Get(EventCallbackList initializer) { bool flag = this.m_Stack.Count == 0; EventCallbackList eventCallbackList; if (flag) { bool flag2 = initializer != null; if (flag2) { eventCallbackList = new EventCallbackList(initializer); } else { eventCallbackList = new EventCallbackList(); } } else { eventCallbackList = this.m_Stack.Pop(); bool flag3 = initializer != null; if (flag3) { eventCallbackList.AddRange(initializer); } } return(eventCallbackList); }
bool UnregisterCallback(long eventTypeId, Delegate callback, TrickleDown useTrickleDown) { if (callback == null) { return(false); } EventCallbackList callbackList = GetCallbackListForWriting(); var callbackPhase = useTrickleDown == TrickleDown.TrickleDown ? CallbackPhase.TrickleDownAndTarget : CallbackPhase.TargetAndBubbleUp; return(callbackList.Remove(eventTypeId, callback, callbackPhase)); }
public void AddRange(EventCallbackList list) { m_List.AddRange(list.m_List); foreach (var item in list.m_List) { if (item.phase == CallbackPhase.TrickleDownAndTarget) { trickleDownCallbackCount++; } else if (item.phase == CallbackPhase.TargetAndBubbleUp) { bubbleUpCallbackCount++; } } }
bool ShouldRegisterCallback(long eventTypeId, Delegate callback, CallbackPhase phase) { if (callback == null) { return(false); } EventCallbackList callbackList = GetCallbackListForReading(); if (callbackList != null) { return(!callbackList.Contains(eventTypeId, callback, phase)); } return(true); }
private bool ShouldRegisterCallback(long eventTypeId, Delegate callback, CallbackPhase phase) { bool flag = callback == null; bool result; if (flag) { result = false; } else { EventCallbackList callbackListForReading = this.GetCallbackListForReading(); bool flag2 = callbackListForReading != null; result = (!flag2 || !callbackListForReading.Contains(eventTypeId, callback, phase)); } return(result); }
private bool UnregisterCallback(long eventTypeId, Delegate callback, TrickleDown useTrickleDown) { bool flag = callback == null; bool result; if (flag) { result = false; } else { EventCallbackList callbackListForWriting = this.GetCallbackListForWriting(); CallbackPhase phase = (useTrickleDown == TrickleDown.TrickleDown) ? CallbackPhase.TrickleDownAndTarget : CallbackPhase.TargetAndBubbleUp; result = callbackListForWriting.Remove(eventTypeId, callback, phase); } return(result); }
public void RegisterCallback <TEventType>(EventCallback <TEventType> callback, TrickleDown useTrickleDown = TrickleDown.NoTrickleDown, InvokePolicy invokePolicy = default) where TEventType : EventBase <TEventType>, new() { if (callback == null) { throw new ArgumentException("callback parameter is null"); } long eventTypeId = EventBase <TEventType> .TypeId(); var callbackPhase = useTrickleDown == TrickleDown.TrickleDown ? CallbackPhase.TrickleDownAndTarget : CallbackPhase.TargetAndBubbleUp; EventCallbackList callbackList = GetCallbackListForReading(); if (callbackList == null || callbackList.Contains(eventTypeId, callback, callbackPhase) == false) { callbackList = GetCallbackListForWriting(); callbackList.Add(new EventCallbackFunctor <TEventType>(callback, callbackPhase, invokePolicy)); } }
public void RegisterCallback <TEventType>(EventCallback <TEventType> callback, TrickleDown useTrickleDown = TrickleDown.NoTrickleDown) where TEventType : EventBase <TEventType>, new() { bool flag = callback == null; if (flag) { throw new ArgumentException("callback parameter is null"); } long eventTypeId = EventBase <TEventType> .TypeId(); CallbackPhase phase = (useTrickleDown == TrickleDown.TrickleDown) ? CallbackPhase.TrickleDownAndTarget : CallbackPhase.TargetAndBubbleUp; EventCallbackList eventCallbackList = this.GetCallbackListForReading(); bool flag2 = eventCallbackList == null || !eventCallbackList.Contains(eventTypeId, callback, phase); if (flag2) { eventCallbackList = this.GetCallbackListForWriting(); eventCallbackList.Add(new EventCallbackFunctor <TEventType>(callback, phase)); } }
public void InvokeCallbacks(EventBase evt, PropagationPhase propagationPhase) { if (m_Callbacks == null) { return; } m_IsInvoking++; var currentTarget = (VisualElement)evt.currentTarget; var panel = currentTarget.panel; for (var i = 0; i < m_Callbacks.Count; i++) { if (evt.isImmediatePropagationStopped || currentTarget.panel != panel) { break; } if (evt.skipDisabledElements && !currentTarget.enabledInHierarchy && m_Callbacks[i].invokePolicy != InvokePolicy.IncludeDisabled) { continue; } m_Callbacks[i].Invoke(evt, propagationPhase); } m_IsInvoking--; if (m_IsInvoking == 0) { // If callbacks were modified during callback invocation, update them now. if (m_TemporaryCallbacks != null) { ReleaseCallbackList(m_Callbacks); m_Callbacks = GetCallbackList(m_TemporaryCallbacks); ReleaseCallbackList(m_TemporaryCallbacks); m_TemporaryCallbacks = null; } } }
public void AddRange(EventCallbackList list) { this.m_List.AddRange(list.m_List); foreach (EventCallbackFunctorBase current in list.m_List) { bool flag = current.phase == CallbackPhase.TrickleDownAndTarget; if (flag) { int num = this.trickleDownCallbackCount; this.trickleDownCallbackCount = num + 1; } else { bool flag2 = current.phase == CallbackPhase.TargetAndBubbleUp; if (flag2) { int num = this.bubbleUpCallbackCount; this.bubbleUpCallbackCount = num + 1; } } } }
internal bool TryGetUserArgs <TEventType, TCallbackArgs>(EventCallback <TEventType, TCallbackArgs> callback, TrickleDown useTrickleDown, out TCallbackArgs userArgs) where TEventType : EventBase <TEventType>, new() { userArgs = default; if (callback == null) { return(false); } EventCallbackList list = GetCallbackListForReading(); long eventTypeId = EventBase <TEventType> .TypeId(); var callbackPhase = useTrickleDown == TrickleDown.TrickleDown ? CallbackPhase.TrickleDownAndTarget : CallbackPhase.TargetAndBubbleUp; var functor = list.Find(eventTypeId, callback, callbackPhase) as EventCallbackFunctor <TEventType, TCallbackArgs>; if (functor == null) { return(false); } userArgs = functor.userArgs; return(true); }
public void Release(EventCallbackList element) { element.Clear(); m_Stack.Push(element); }
private static EventCallbackList GetCallbackList(EventCallbackList initializer = null) { return(s_ListPool.Get(initializer)); }
public EventCallbackList(EventCallbackList source) { this.m_List = new List <EventCallbackFunctorBase>(source.m_List); this.trickleDownCallbackCount = 0; this.bubbleUpCallbackCount = 0; }
private static void ReleaseCallbackList(EventCallbackList toRelease) { s_ListPool.Release(toRelease); }