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);
}
