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); }
public EventCallbackList Get(EventCallbackList initializer) { EventCallbackList eventCallbackList; if (this.m_Stack.Count == 0) { if (initializer != null) { eventCallbackList = new EventCallbackList(initializer); } else { eventCallbackList = new EventCallbackList(); } } else { eventCallbackList = this.m_Stack.Pop(); if (initializer != null) { eventCallbackList.AddRange(initializer); } } return(eventCallbackList); }
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 InvokeCallbacks(EventBase evt) { if (this.m_Callbacks != null) { this.m_IsInvoking++; for (int i = 0; i < this.m_Callbacks.Count; i++) { if (evt.isImmediatePropagationStopped) { break; } this.m_Callbacks[i].Invoke(evt); } this.m_IsInvoking--; if (this.m_IsInvoking == 0) { if (this.m_TemporaryCallbacks != null) { EventCallbackRegistry.ReleaseCallbackList(this.m_Callbacks); this.m_Callbacks = EventCallbackRegistry.GetCallbackList(this.m_TemporaryCallbacks); EventCallbackRegistry.ReleaseCallbackList(this.m_TemporaryCallbacks); this.m_TemporaryCallbacks = null; } } } }
private EventCallbackList GetCallbackListForWriting() { EventCallbackList result; if (this.m_IsInvoking > 0) { if (this.m_TemporaryCallbacks == null) { if (this.m_Callbacks != null) { this.m_TemporaryCallbacks = EventCallbackRegistry.GetCallbackList(this.m_Callbacks); } else { this.m_TemporaryCallbacks = EventCallbackRegistry.GetCallbackList(null); } } result = this.m_TemporaryCallbacks; } else { if (this.m_Callbacks == null) { this.m_Callbacks = EventCallbackRegistry.GetCallbackList(null); } result = this.m_Callbacks; } return(result); }
public void RegisterCallback <TEventType, TCallbackArgs>(EventCallback <TEventType, TCallbackArgs> callback, TCallbackArgs userArgs, TrickleDown useTrickleDown = TrickleDown.NoTrickleDown) 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)); }
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 void RegisterCallback <TEventType, TCallbackArgs>(EventCallback <TEventType, TCallbackArgs> callback, TCallbackArgs userArgs, Capture useCapture = Capture.NoCapture) where TEventType : EventBase <TEventType>, new() { long eventTypeId = EventBase <TEventType> .TypeId(); var callbackPhase = useCapture == Capture.Capture ? CallbackPhase.CaptureAndTarget : CallbackPhase.TargetAndBubbleUp; if (ShouldRegisterCallback(eventTypeId, callback, callbackPhase)) { EventCallbackList callbackList = GetCallbackListForWriting(); callbackList.Add(new EventCallbackFunctor <TEventType, TCallbackArgs>(callback, userArgs, callbackPhase)); } }
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)); }
bool UnregisterCallback(long eventTypeId, Delegate callback, Capture useCapture) { if (callback == null) { return(false); } EventCallbackList callbackList = GetCallbackListForWriting(); var callbackPhase = useCapture == Capture.Capture ? CallbackPhase.CaptureAndTarget : CallbackPhase.TargetAndBubbleUp; return(callbackList.Remove(eventTypeId, callback, callbackPhase)); }
public void RegisterCallback <TEventType, TCallbackArgs>(EventCallback <TEventType, TCallbackArgs> callback, TCallbackArgs userArgs, Capture useCapture = Capture.NoCapture) where TEventType : EventBase <TEventType>, new() { long eventTypeId = EventBase <TEventType> .TypeId(); CallbackPhase phase = (useCapture != Capture.Capture) ? CallbackPhase.TargetAndBubbleUp : CallbackPhase.CaptureAndTarget; if (this.ShouldRegisterCallback(eventTypeId, callback, phase)) { EventCallbackList callbackListForWriting = this.GetCallbackListForWriting(); callbackListForWriting.Add(new EventCallbackFunctor <TEventType, TCallbackArgs>(callback, userArgs, phase)); } }
private bool ShouldRegisterCallback(long eventTypeId, Delegate callback, CallbackPhase phase) { bool result; if (callback == null) { result = false; } else { EventCallbackList callbackListForReading = this.GetCallbackListForReading(); result = (callbackListForReading == null || !callbackListForReading.Contains(eventTypeId, callback, phase)); } return(result); }
public void AddRange(EventCallbackList list) { this.m_List.AddRange(list.m_List); foreach (EventCallbackFunctorBase eventCallbackFunctorBase in list.m_List) { if (eventCallbackFunctorBase.phase == CallbackPhase.CaptureAndTarget) { this.capturingCallbackCount++; } else if (eventCallbackFunctorBase.phase == CallbackPhase.TargetAndBubbleUp) { this.bubblingCallbackCount++; } } }
private bool UnregisterCallback(long eventTypeId, Delegate callback, Capture useCapture) { bool result; if (callback == null) { result = false; } else { EventCallbackList callbackListForWriting = this.GetCallbackListForWriting(); CallbackPhase phase = (useCapture != Capture.Capture) ? CallbackPhase.TargetAndBubbleUp : CallbackPhase.CaptureAndTarget; result = callbackListForWriting.Remove(eventTypeId, callback, phase); } return(result); }
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); }
public void AddRange(EventCallbackList list) { m_List.AddRange(list.m_List); foreach (var item in list.m_List) { if (item.phase == CallbackPhase.CaptureAndTarget) { capturingCallbackCount++; } else if (item.phase == CallbackPhase.TargetAndBubbleUp) { bubblingCallbackCount++; } } }
public void RegisterCallback <TEventType>(EventCallback <TEventType> callback, TrickleDown useTrickleDown = TrickleDown.NoTrickleDown) 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)); } }
internal bool TryGetUserArgs <TEventType, TCallbackArgs>(EventCallback <TEventType, TCallbackArgs> callback, TrickleDown useTrickleDown, out TCallbackArgs userArgs) where TEventType : EventBase <TEventType>, new() { userArgs = default(TCallbackArgs); 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); }
private static void ReleaseCallbackList(EventCallbackList toRelease) { EventCallbackRegistry.s_ListPool.Release(toRelease); }
private static EventCallbackList GetCallbackList(EventCallbackList initializer = null) { return(EventCallbackRegistry.s_ListPool.Get(initializer)); }
public EventCallbackList(EventCallbackList source) { m_List = new List <EventCallbackFunctorBase>(source.m_List); trickleDownCallbackCount = 0; bubbleUpCallbackCount = 0; }
public EventCallbackList(EventCallbackList source) { m_List = new List <EventCallbackFunctorBase>(source.m_List); capturingCallbackCount = 0; bubblingCallbackCount = 0; }
public void Release(EventCallbackList element) { element.Clear(); m_Stack.Push(element); }