public void RegisterVoidPersistentListener(int index, Object targetObj, string methodName)
{
PersistentCall listener = GetListener(index);
listener.RegisterPersistentListener(targetObj, methodName);
listener.mode = PersistentListenerMode.Void;
}
public void RegisterEventPersistentListener(int index, UnityEngine.Object targetObj, string methodName)
{
PersistentCall listener = this.GetListener(index);
listener.RegisterPersistentListener(targetObj, methodName);
listener.mode = PersistentListenerMode.EventDefined;
}
public void RegisterVoidPersistentListener(int index, UnityEngine.Object targetObj, Type targetObjType, string methodName)
{
PersistentCall listener = this.GetListener(index);
listener.RegisterPersistentListener(targetObj, targetObjType, methodName);
listener.mode = PersistentListenerMode.Void;
}
public void RegisterObjectPersistentListener(int index, object targetObj, object argument, string methodName)
{
PersistentCall listener = this.GetListener(index);
listener.RegisterPersistentListener(targetObj, methodName);
listener.mode = PersistentListenerMode.Object;
}
public BaseInvokableCall GetRuntimeCall(UnityEventBase theEvent)
{
BaseInvokableCall result;
if (this.m_CallState == UnityEventCallState.RuntimeOnly && !Application.isPlaying)
{
result = null;
}
else if (this.m_CallState == UnityEventCallState.Off || theEvent == null)
{
result = null;
}
else
{
MethodInfo methodInfo = theEvent.FindMethod(this);
if (methodInfo == null)
{
result = null;
}
else
{
switch (this.m_Mode)
{
case PersistentListenerMode.EventDefined:
result = theEvent.GetDelegate(this.target, methodInfo);
break;
case PersistentListenerMode.Void:
result = new InvokableCall(this.target, methodInfo);
break;
case PersistentListenerMode.Object:
result = PersistentCall.GetObjectCall(this.target, methodInfo, this.m_Arguments);
break;
case PersistentListenerMode.Int:
result = new CachedInvokableCall <int>(this.target, methodInfo, this.m_Arguments.intArgument);
break;
case PersistentListenerMode.Float:
result = new CachedInvokableCall <float>(this.target, methodInfo, this.m_Arguments.floatArgument);
break;
case PersistentListenerMode.String:
result = new CachedInvokableCall <string>(this.target, methodInfo, this.m_Arguments.stringArgument);
break;
case PersistentListenerMode.Bool:
result = new CachedInvokableCall <bool>(this.target, methodInfo, this.m_Arguments.boolArgument);
break;
default:
result = null;
break;
}
}
}
return(result);
}
public void RegisterBoolPersistentListener(int index, Object targetObj, bool argument, string methodName)
{
PersistentCall listener = GetListener(index);
listener.RegisterPersistentListener(targetObj, methodName);
listener.mode = PersistentListenerMode.Bool;
listener.arguments.boolArgument = argument;
}
public void RegisterObjectPersistentListener(int index, Object targetObj, Object argument, string methodName)
{
PersistentCall listener = GetListener(index);
listener.RegisterPersistentListener(targetObj, methodName);
listener.mode = PersistentListenerMode.Object;
listener.arguments.unityObjectArgument = argument;
}
public void RegisterFloatPersistentListener(int index, Object targetObj, float argument, string methodName)
{
PersistentCall listener = GetListener(index);
listener.RegisterPersistentListener(targetObj, methodName);
listener.mode = PersistentListenerMode.Float;
listener.arguments.floatArgument = argument;
}
public void RegisterIntPersistentListener(int index, object targetObj, int argument, string methodName)
{
PersistentCall listener = this.GetListener(index);
listener.RegisterPersistentListener(targetObj, methodName);
listener.mode = PersistentListenerMode.Int;
listener.arguments.intArgument = argument;
}
public void RegisterFloatPersistentListener(int index, UnityEngine.Object targetObj, Type targetObjType, float argument, string methodName)
{
PersistentCall listener = this.GetListener(index);
listener.RegisterPersistentListener(targetObj, targetObjType, methodName);
listener.mode = PersistentListenerMode.Float;
listener.arguments.floatArgument = argument;
}
public void RegisterStringPersistentListener(int index, UnityEngine.Object targetObj, string argument, string methodName)
{
PersistentCall listener = this.GetListener(index);
listener.RegisterPersistentListener(targetObj, methodName);
listener.mode = PersistentListenerMode.String;
listener.arguments.stringArgument = argument;
}
internal MethodInfo FindMethod(PersistentCall call)
{
System.Type argumentType = typeof(UnityEngine.Object);
if (!string.IsNullOrEmpty(call.arguments.unityObjectArgumentAssemblyTypeName))
{
argumentType = System.Type.GetType(call.arguments.unityObjectArgumentAssemblyTypeName, false) ?? typeof(UnityEngine.Object);
}
return(this.FindMethod(call.methodName, (object)call.target, call.mode, argumentType));
}
internal MethodInfo FindMethod(PersistentCall call)
{
Type argumentType = typeof(Object);
if (!string.IsNullOrEmpty(call.arguments.unityObjectArgumentAssemblyTypeName))
{
argumentType = (Type.GetType(call.arguments.unityObjectArgumentAssemblyTypeName, throwOnError: false) ?? typeof(Object));
}
return(FindMethod(call.methodName, call.target, call.mode, argumentType));
}
/// <summary>
/// <para>Get the target method name of the listener at index index.</para>
/// </summary>
/// <param name="index">Index of the listener to query.</param>
public string GetPersistentMethodName(int index)
{
PersistentCall listener = this.m_PersistentCalls.GetListener(index);
if (listener != null)
{
return(listener.methodName);
}
return(string.Empty);
}
/// <summary>
/// <para>Get the target component of the listener at index index.</para>
/// </summary>
/// <param name="index">Index of the listener to query.</param>
public UnityEngine.Object GetPersistentTarget(int index)
{
PersistentCall listener = this.m_PersistentCalls.GetListener(index);
if (listener != null)
{
return(listener.target);
}
return((UnityEngine.Object)null);
}
public void SetPersistentListenerState(int index, UnityEventCallState state)
{
PersistentCall listener = m_PersistentCalls.GetListener(index);
if (listener != null)
{
listener.callState = state;
}
DirtyPersistentCalls();
}
public void SetPersistentListenerState(int index, UnityEventCallState state)
{
PersistentCall listener = this.m_PersistentCalls.GetListener(index);
bool flag = listener != null;
if (flag)
{
listener.callState = state;
}
this.DirtyPersistentCalls();
}
internal MethodInfo FindMethod(PersistentCall call)
{
var type = typeof(Object);
if (!string.IsNullOrEmpty(call.arguments.unityObjectArgumentAssemblyTypeName))
{
type = Type.GetType(call.arguments.unityObjectArgumentAssemblyTypeName, false) ?? typeof(Object);
}
var targetType = call.target != null?call.target.GetType() : Type.GetType(call.targetAssemblyTypeName, false);
return(FindMethod(call.methodName, targetType, call.mode, type));
}
internal MethodInfo FindMethod(PersistentCall call)
{
Type argumentType = typeof(UnityEngine.Object);
bool flag = !string.IsNullOrEmpty(call.arguments.unityObjectArgumentAssemblyTypeName);
if (flag)
{
argumentType = (Type.GetType(call.arguments.unityObjectArgumentAssemblyTypeName, false) ?? typeof(UnityEngine.Object));
}
Type listenerType = (call.target != null) ? call.target.GetType() : Type.GetType(call.targetAssemblyTypeName, false);
return(this.FindMethod(call.methodName, listenerType, call.mode, argumentType));
}
internal MethodInfo FindMethod(PersistentCall call)
{
Type argumentType = typeof(Object);
if (!string.IsNullOrEmpty(call.arguments.unityObjectArgumentAssemblyTypeName))
{
Type type = Type.GetType(call.arguments.unityObjectArgumentAssemblyTypeName, false);
if (type != null)
{
argumentType = type;
}
else
{
argumentType = typeof(Object);
}
}
return(this.FindMethod(call.methodName, call.target, call.mode, argumentType));
}
public void Initialize(InvokableCallList invokableList, UnityEventBase unityEventBase)
{
using (List <PersistentCall> .Enumerator enumerator = this.m_Calls.GetEnumerator())
{
while (enumerator.MoveNext())
{
PersistentCall current = enumerator.Current;
if (current.IsValid())
{
BaseInvokableCall runtimeCall = current.GetRuntimeCall(unityEventBase);
if (runtimeCall != null)
{
invokableList.AddPersistentInvokableCall(runtimeCall);
}
}
}
}
}
public BaseInvokableCall GetRuntimeCall(UnityEventBase theEvent)
{
if (this.m_CallState == UnityEventCallState.RuntimeOnly && !Application.isPlaying)
{
return((BaseInvokableCall)null);
}
if (this.m_CallState == UnityEventCallState.Off || theEvent == null)
{
return((BaseInvokableCall)null);
}
MethodInfo method = theEvent.FindMethod(this);
if (method == null)
{
return((BaseInvokableCall)null);
}
switch (this.m_Mode)
{
case PersistentListenerMode.EventDefined:
return(theEvent.GetDelegate((object)this.target, method));
case PersistentListenerMode.Void:
return((BaseInvokableCall) new InvokableCall((object)this.target, method));
case PersistentListenerMode.Object:
return(PersistentCall.GetObjectCall(this.target, method, this.m_Arguments));
case PersistentListenerMode.Int:
return((BaseInvokableCall) new CachedInvokableCall <int>(this.target, method, this.m_Arguments.intArgument));
case PersistentListenerMode.Float:
return((BaseInvokableCall) new CachedInvokableCall <float>(this.target, method, this.m_Arguments.floatArgument));
case PersistentListenerMode.String:
return((BaseInvokableCall) new CachedInvokableCall <string>(this.target, method, this.m_Arguments.stringArgument));
case PersistentListenerMode.Bool:
return((BaseInvokableCall) new CachedInvokableCall <bool>(this.target, method, this.m_Arguments.boolArgument));
default:
return((BaseInvokableCall)null);
}
}
internal virtual MethodInfo FindMethod(PersistentCall call)
{
var type = typeof(UnityEngine.Object);
if (call.mode == PersistentListenerMode.String)
{
type = typeof(string);
if (!string.IsNullOrEmpty(call.arguments.serializedDataArgumentAssemblyTypeName))
{
type = Type.GetType(call.arguments.serializedDataArgumentAssemblyTypeName, false) ?? typeof(string);
}
}
else if (call.mode == PersistentListenerMode.Object)
{
if (!string.IsNullOrEmpty(call.arguments.unityObjectArgumentAssemblyTypeName))
{
type = Type.GetType(call.arguments.unityObjectArgumentAssemblyTypeName, false) ?? typeof(UnityEngine.Object);
}
}
var targetType = call.target != null?call.target.GetType() : Type.GetType(call.targetAssemblyTypeName, false);
return(FindMethod(call.methodName, targetType, call.mode, type));
}
public void AddListener(PersistentCall call)
{
this.m_Calls.Add(call);
}
public void AddListener(PersistentCall call)
{
this.m_Calls.Add(call);
}
public UnityEngine.Object GetPersistentTarget(int index)
{
PersistentCall listener = this.m_PersistentCalls.GetListener(index);
return((listener == null) ? null : listener.target);
}
public void UnregisterPersistentListener(int index)
{
PersistentCall listener = GetListener(index);
listener.UnregisterPersistentListener();
}
public string GetPersistentMethodName(int index)
{
PersistentCall listener = m_PersistentCalls.GetListener(index);
return((listener == null) ? string.Empty : listener.methodName);
}
