public PersistentCall(Object target, string methodName, PersistentListenerMode mode, string argument)
{
this.target = target;
this.methodName = methodName;
this.mode = mode;
this.argument = argument;
}
internal static MethodInfo FindMethod(object target, string methodName, PersistentListenerMode mode)
{
//var type = typeof(Object);
//if (!string.IsNullOrEmpty(call.arguments.unityObjectArgumentAssemblyTypeName))
// type = Type.GetType(call.arguments.unityObjectArgumentAssemblyTypeName, false) ?? typeof(Object);
switch (mode)
{
case PersistentListenerMode.Void:
return(UnityEventBase.GetValidMethodInfo(target, methodName, new Type[0]));
case PersistentListenerMode.Float:
return(UnityEventBase.GetValidMethodInfo(target, methodName, new[] { typeof(float) }));
case PersistentListenerMode.Int:
return(UnityEventBase.GetValidMethodInfo(target, methodName, new[] { typeof(int) }));
case PersistentListenerMode.Bool:
return(UnityEventBase.GetValidMethodInfo(target, methodName, new[] { typeof(bool) }));
case PersistentListenerMode.String:
return(UnityEventBase.GetValidMethodInfo(target, methodName, new[] { typeof(string) }));
//case PersistentListenerMode.Object:
// return UnityEventBase.GetValidMethodInfo(target, methodName, new[] { argumentType ?? typeof(Object) });
default:
return(null);
}
//call += (UnityAction<float>)theFunction.CreateDelegate(typeof(UnityAction<float>), target);
}
private static void AddFunctionsForScript(GenericMenu menu, SerializedProperty listener, ValidMethodMap method, string targetName)
{
PersistentListenerMode mode = method.mode;
UnityEngine.Object objectReferenceValue = listener.FindPropertyRelative("m_Target").objectReferenceValue;
string stringValue = listener.FindPropertyRelative("m_MethodName").stringValue;
PersistentListenerMode mode2 = GetMode(listener.FindPropertyRelative("m_Mode"));
SerializedProperty property = listener.FindPropertyRelative("m_Arguments").FindPropertyRelative("m_ObjectArgumentAssemblyTypeName");
StringBuilder builder = new StringBuilder();
int length = method.methodInfo.GetParameters().Length;
for (int i = 0; i < length; i++)
{
System.Reflection.ParameterInfo info = method.methodInfo.GetParameters()[i];
builder.Append($"{GetTypeName(info.ParameterType)}");
if (i < (length - 1))
{
builder.Append(", ");
}
}
bool on = ((objectReferenceValue == method.target) && (stringValue == method.methodInfo.Name)) && (mode == mode2);
if ((on && (mode == PersistentListenerMode.Object)) && (method.methodInfo.GetParameters().Length == 1))
{
on &= method.methodInfo.GetParameters()[0].ParameterType.AssemblyQualifiedName == property.stringValue;
}
string text = GetFormattedMethodName(targetName, method.methodInfo.Name, builder.ToString(), mode == PersistentListenerMode.EventDefined);
if (< > f__mg$cache1 == null)
{
internal MethodInfo FindMethod(string name, Type listenerType, PersistentListenerMode mode, Type argumentType)
{
switch (mode)
{
case PersistentListenerMode.EventDefined:
return(FindMethod_Impl(name, listenerType));
case PersistentListenerMode.Void:
return(GetValidMethodInfo(listenerType, name, new Type[0]));
case PersistentListenerMode.Float:
return(GetValidMethodInfo(listenerType, name, new[] { typeof(float) }));
case PersistentListenerMode.Int:
return(GetValidMethodInfo(listenerType, name, new[] { typeof(int) }));
case PersistentListenerMode.Bool:
return(GetValidMethodInfo(listenerType, name, new[] { typeof(bool) }));
case PersistentListenerMode.String:
return(GetValidMethodInfo(listenerType, name, new[] { typeof(string) }));
case PersistentListenerMode.Object:
return(GetValidMethodInfo(listenerType, name, new[] { argumentType ?? typeof(Object) }));
default:
return(null);
}
}
private static void AddFunctionsForScript(GenericMenu menu, SerializedProperty listener, ValidMethodMap method, string targetName)
{
PersistentListenerMode mode = method.mode;
Object objectReferenceValue = listener.FindPropertyRelative("m_Target").objectReferenceValue;
string stringValue = listener.FindPropertyRelative("m_MethodName").stringValue;
PersistentListenerMode mode2 = GetMode(listener.FindPropertyRelative("m_Mode"));
SerializedProperty property = listener.FindPropertyRelative("m_Arguments").FindPropertyRelative("m_ObjectArgumentAssemblyTypeName");
StringBuilder builder = new StringBuilder();
int length = method.methodInfo.GetParameters().Length;
for (int i = 0; i < length; i++)
{
ParameterInfo info = method.methodInfo.GetParameters()[i];
builder.Append(string.Format("{0}", GetTypeName(info.ParameterType)));
if (i < (length - 1))
{
builder.Append(", ");
}
}
bool on = ((objectReferenceValue == method.target) && (stringValue == method.methodInfo.Name)) && (mode == mode2);
if ((on && (mode == PersistentListenerMode.Object)) && (method.methodInfo.GetParameters().Length == 1))
{
on &= method.methodInfo.GetParameters()[0].ParameterType.AssemblyQualifiedName == property.stringValue;
}
string text = GetFormattedMethodName(targetName, method.methodInfo.Name, builder.ToString(), mode == PersistentListenerMode.EventDefined);
menu.AddItem(new GUIContent(text), on, new GenericMenu.MenuFunction2(UnityEventDrawer.SetEventFunction), new UnityEventFunction(listener, method.target, method.methodInfo, mode));
}
protected bool ValidateRegistration(MethodInfo method, object targetObj, PersistentListenerMode mode, Type argumentType)
{
if (method == null)
{
throw new ArgumentNullException("method", UnityString.Format("Can not register null method on {0} for callback!", targetObj));
}
var obj = targetObj as Object;
if (obj == null || obj.GetInstanceID() == 0)
{
throw new ArgumentException(
UnityString.Format("Could not register callback {0} on {1}. The class {2} does not derive from UnityEngine.Object",
method.Name,
targetObj,
targetObj == null ? "null" : targetObj.GetType().ToString()));
}
if (method.IsStatic)
{
throw new ArgumentException(UnityString.Format("Could not register listener {0} on {1} static functions are not supported.", method, GetType()));
}
if (FindMethod(method.Name, targetObj, mode, argumentType) == null)
{
Debug.LogWarning(UnityString.Format("Could not register listener {0}.{1} on {2} the method could not be found.", targetObj, method, GetType()));
return(false);
}
return(true);
}
public UnityEventFunction(SerializedProperty prop, Object target, MethodInfo method, PersistentListenerMode mode)
{
_prop = prop;
_target = target;
_method = method;
_mode = mode;
}
static void AddFunctionsForScript(GenericMenu menu, SerializedProperty propCall, ValidMethodMap method, string targetName)
{
PersistentListenerMode mode = method.mode;
var propTarget = propCall.FindPropertyRelative(targetPath).objectReferenceValue;
var propMethodName = propCall.FindPropertyRelative(methodNamePath).stringValue;
var propMode = GetMode(propCall.FindPropertyRelative(modePath));
var args = new StringBuilder();
var count = method.methodInfo.GetParameters().Length;
for (int index = 0; index < count; index++)
{
var methodArg = method.methodInfo.GetParameters()[index];
args.Append(string.Format("{0}", GetTypeName(methodArg.ParameterType)));
if (index < count - 1)
{
args.Append(", ");
}
}
var isCurrentlySet = propTarget == method.target &&
propMethodName == method.methodInfo.Name &&
mode == propMode;
string path = GetFormattedMethodName(targetName, method.methodInfo.Name, args.ToString(), mode == PersistentListenerMode.EventDefined);
menu.AddItem(new GUIContent(path),
isCurrentlySet,
SetEventFunction,
new UnityEventFunction(propCall, method.target, method.methodInfo, mode));
}
static MethodInfo FindMethod(object target, string methodName, PersistentListenerMode mode)
{
switch (mode)
{
case PersistentListenerMode.Void:
return(UnityEventBase.GetValidMethodInfo(target, methodName, new Type[0]));
case PersistentListenerMode.Float:
return(UnityEventBase.GetValidMethodInfo(target, methodName, new[] { typeof(float) }));
case PersistentListenerMode.Int:
return(UnityEventBase.GetValidMethodInfo(target, methodName, new[] { typeof(int) }));
case PersistentListenerMode.Bool:
return(UnityEventBase.GetValidMethodInfo(target, methodName, new[] { typeof(bool) }));
case PersistentListenerMode.String:
return(UnityEventBase.GetValidMethodInfo(target, methodName, new[] { typeof(string) }));
//case PersistentListenerMode.Object:
// return UnityEventBase.GetValidMethodInfo(target, methodName, new[] { argumentType ?? typeof(Object) });
default:
return(null);
}
}
public UnityEventFunction(SerializedProperty listener, UnityEngine.Object target, MethodInfo method, PersistentListenerMode mode)
{
this.m_Listener = listener;
this.m_Target = target;
this.m_Method = method;
this.m_Mode = mode;
}
private void ValidateObjectParamater(SerializedProperty arguments, PersistentListenerMode mode)
{
var fullArgumentType = arguments.FindPropertyRelative(kObjectArgumentAssemblyTypeName);
var argument = arguments.FindPropertyRelative(kObjectArgument);
var argumentObj = argument.objectReferenceValue;
if (mode != PersistentListenerMode.Object)
{
fullArgumentType.stringValue = typeof(Object).AssemblyQualifiedName;
argument.objectReferenceValue = null;
return;
}
if (argumentObj == null)
{
return;
}
Type t = Type.GetType(fullArgumentType.stringValue, false);
if (!typeof(Object).IsAssignableFrom(t) || !t.IsInstanceOfType(argumentObj))
{
argument.objectReferenceValue = null;
}
}
public void AddDataBinding(Object target, string methodName, PersistentListenerMode mode, string argument)
{
var call = new PersistentCall(target, methodName, mode, argument);
dataBinding.calls.Add(call);
call.Init(this);
}
private static void AddFunctionsForScript(GenericMenu menu, SerializedProperty listener, UnityEventDrawer.ValidMethodMap method, string targetName)
{
PersistentListenerMode mode1 = method.mode;
UnityEngine.Object objectReferenceValue = listener.FindPropertyRelative("m_Target").objectReferenceValue;
string stringValue = listener.FindPropertyRelative("m_MethodName").stringValue;
PersistentListenerMode mode2 = UnityEventDrawer.GetMode(listener.FindPropertyRelative("m_Mode"));
SerializedProperty propertyRelative = listener.FindPropertyRelative("m_Arguments").FindPropertyRelative("m_ObjectArgumentAssemblyTypeName");
StringBuilder stringBuilder = new StringBuilder();
int length = method.methodInfo.GetParameters().Length;
for (int index = 0; index < length; ++index)
{
System.Reflection.ParameterInfo parameter = method.methodInfo.GetParameters()[index];
stringBuilder.Append(string.Format("{0}", (object)UnityEventDrawer.GetTypeName(parameter.ParameterType)));
if (index < length - 1)
{
stringBuilder.Append(", ");
}
}
bool on = objectReferenceValue == method.target && stringValue == method.methodInfo.Name && mode1 == mode2;
if (on && mode1 == PersistentListenerMode.Object && method.methodInfo.GetParameters().Length == 1)
{
on &= method.methodInfo.GetParameters()[0].ParameterType.AssemblyQualifiedName == propertyRelative.stringValue;
}
string formattedMethodName = UnityEventDrawer.GetFormattedMethodName(targetName, method.methodInfo.Name, stringBuilder.ToString(), mode1 == PersistentListenerMode.EventDefined);
menu.AddItem(new GUIContent(formattedMethodName), on, new GenericMenu.MenuFunction2(UnityEventDrawer.SetEventFunction), (object)new UnityEventDrawer.UnityEventFunction(listener, method.target, method.methodInfo, mode1));
}
private void ValidateObjectParamater(SerializedProperty arguments, PersistentListenerMode mode)
{
var propertyRelative1 = arguments.FindPropertyRelative("m_ObjectArgumentAssemblyTypeName");
var propertyRelative2 = arguments.FindPropertyRelative("m_ObjectArgument");
var objectReferenceValue = propertyRelative2.objectReferenceValue;
if (mode != PersistentListenerMode.Object)
{
propertyRelative1.stringValue = typeof(UnityEngine.Object).AssemblyQualifiedName;
propertyRelative2.objectReferenceValue = null;
}
else
{
if (objectReferenceValue == null)
{
return;
}
var type = Type.GetType(propertyRelative1.stringValue, false);
if (typeof(UnityEngine.Object).IsAssignableFrom(type) && type.IsInstanceOfType(objectReferenceValue))
{
return;
}
propertyRelative2.objectReferenceValue = null;
}
}
protected bool ValidateRegistration(MethodInfo method, object targetObj, PersistentListenerMode mode, System.Type argumentType)
{
if (method == null)
{
object[] args = new object[] { targetObj };
throw new ArgumentNullException("method", UnityString.Format("Can not register null method on {0} for callback!", args));
}
UnityEngine.Object obj2 = targetObj as UnityEngine.Object;
if ((obj2 == null) || (obj2.GetInstanceID() == 0))
{
object[] objArray2 = new object[] { method.Name, targetObj, (targetObj != null) ? targetObj.GetType().ToString() : "null" };
throw new ArgumentException(UnityString.Format("Could not register callback {0} on {1}. The class {2} does not derive from UnityEngine.Object", objArray2));
}
if (method.IsStatic)
{
object[] objArray3 = new object[] { method, base.GetType() };
throw new ArgumentException(UnityString.Format("Could not register listener {0} on {1} static functions are not supported.", objArray3));
}
if (this.FindMethod(method.Name, targetObj, mode, argumentType) == null)
{
object[] objArray4 = new object[] { targetObj, method, base.GetType() };
Debug.LogWarning(UnityString.Format("Could not register listener {0}.{1} on {2} the method could not be found.", objArray4));
return(false);
}
return(true);
}
private static void AddFunctionsForScript(GenericMenu menu, SerializedProperty listener, UnityEventDrawer.ValidMethodMap method, string targetName)
{
PersistentListenerMode mode = method.mode;
UnityEngine.Object objectReferenceValue = listener.FindPropertyRelative("m_Target").objectReferenceValue;
string stringValue = listener.FindPropertyRelative("m_MethodName").stringValue;
PersistentListenerMode mode2 = UnityEventDrawer.GetMode(listener.FindPropertyRelative("m_Mode"));
SerializedProperty serializedProperty = listener.FindPropertyRelative("m_Arguments").FindPropertyRelative("m_ObjectArgumentAssemblyTypeName");
StringBuilder stringBuilder = new StringBuilder();
int num = method.methodInfo.GetParameters().Length;
for (int i = 0; i < num; i++)
{
ParameterInfo parameterInfo = method.methodInfo.GetParameters()[i];
stringBuilder.Append(string.Format("{0}", UnityEventDrawer.GetTypeName(parameterInfo.ParameterType)));
if (i < num - 1)
{
stringBuilder.Append(", ");
}
}
bool flag = objectReferenceValue == method.target && stringValue == method.methodInfo.Name && mode == mode2;
if (flag && mode == PersistentListenerMode.Object && method.methodInfo.GetParameters().Length == 1)
{
flag &= (method.methodInfo.GetParameters()[0].ParameterType.AssemblyQualifiedName == serializedProperty.stringValue);
}
string formattedMethodName = UnityEventDrawer.GetFormattedMethodName(targetName, method.methodInfo.Name, stringBuilder.ToString(), mode == PersistentListenerMode.EventDefined);
menu.AddItem(new GUIContent(formattedMethodName), flag, new GenericMenu.MenuFunction2(UnityEventDrawer.SetEventFunction), new UnityEventDrawer.UnityEventFunction(listener, method.target, method.methodInfo, mode));
}
public UnityEventFunction(SerializedProperty listener, Object target, MethodInfo method, PersistentListenerMode mode)
{
m_Listener = listener;
m_Target = target;
m_Method = method;
m_Mode = mode;
}
public object[] GetCallParam(PersistentListenerMode mode)
{
switch (mode)
{
case PersistentListenerMode.Void:
return(null);
case PersistentListenerMode.Object:
return(new object[] { unityObjectArgument });
case PersistentListenerMode.Int:
return(new object[] { intArgument });
case PersistentListenerMode.Float:
return(new object[] { floatArgument });
case PersistentListenerMode.String:
return(new object[] { stringArgument });
case PersistentListenerMode.Bool:
return(new object[] { boolArgument });
default:
throw new ArgumentOutOfRangeException(nameof(mode), mode, null);
}
}
internal MethodInfo FindMethod(string name, object listener, PersistentListenerMode mode, Type argumentType)
{
MethodInfo result;
switch (mode)
{
case PersistentListenerMode.EventDefined:
result = this.FindMethod_Impl(name, listener);
break;
case PersistentListenerMode.Void:
result = UnityEventBase.GetValidMethodInfo(listener, name, new Type[0]);
break;
case PersistentListenerMode.Object:
result = UnityEventBase.GetValidMethodInfo(listener, name, new Type[]
{
argumentType ?? typeof(UnityEngine.Object)
});
break;
case PersistentListenerMode.Int:
result = UnityEventBase.GetValidMethodInfo(listener, name, new Type[]
{
typeof(int)
});
break;
case PersistentListenerMode.Float:
result = UnityEventBase.GetValidMethodInfo(listener, name, new Type[]
{
typeof(float)
});
break;
case PersistentListenerMode.String:
result = UnityEventBase.GetValidMethodInfo(listener, name, new Type[]
{
typeof(string)
});
break;
case PersistentListenerMode.Bool:
result = UnityEventBase.GetValidMethodInfo(listener, name, new Type[]
{
typeof(bool)
});
break;
default:
result = null;
break;
}
return(result);
}
public LimitsInfo(Object limiter, string targetField, object fieldValue, SerializedProperty limiterProperty, PersistentListenerMode listenerMode,
SerializedProperty fieldNameProperty, SerializedProperty argumentsProperty)
{
Limiter = limiter;
TargetField = targetField;
FieldValue = fieldValue;
LimiterProperty = limiterProperty;
ListenerMode = listenerMode;
FieldNameProperty = fieldNameProperty;
ArgumentsProperty = argumentsProperty;
}
protected bool ValidateRegistration(MethodInfo method, object targetObj, PersistentListenerMode mode, Type argumentType)
{
if (method == null)
{
throw new ArgumentNullException("method", UnityString.Format("Can not register null method on {0} for callback!", targetObj));
}
if (method.DeclaringType == null)
{
throw new NullReferenceException(
UnityString.Format(
"Method '{0}' declaring type is null, global methods are not supported",
method.Name));
}
Type targetType;
if (!method.IsStatic)
{
var obj = targetObj as Object;
if (obj == null || obj.GetInstanceID() == 0)
{
throw new ArgumentException(
UnityString.Format(
"Could not register callback {0} on {1}. The class {2} does not derive from UnityEngine.Object",
method.Name,
targetObj,
targetObj == null ? "null" : targetObj.GetType().ToString()));
}
targetType = obj.GetType();
if (!method.DeclaringType.IsAssignableFrom(targetType))
{
throw new ArgumentException(
UnityString.Format(
"Method '{0}' declaring type '{1}' is not assignable from object type '{2}'",
method.Name,
method.DeclaringType.Name,
obj.GetType().Name));
}
}
else
{
targetType = method.DeclaringType;
}
if (FindMethod(method.Name, targetType, mode, argumentType) == null)
{
Debug.LogWarning(UnityString.Format("Could not register listener {0}.{1} on {2} the method could not be found.", targetObj, method, GetType()));
return(false);
}
return(true);
}
public UnityEventFunction(
SerializedProperty listener,
string target,
MethodInfo method,
PersistentListenerMode mode,
string field)
{
this.m_Listener = listener;
this.m_Target = target;
this.m_Method = method;
this.m_Mode = mode;
this.m_Field = field;
}
private static void GetMethodsForTargetAndMode(
string target,
System.Type[] delegateArgumentsTypes,
List <ValidMethodMap> methods,
PersistentListenerMode mode)
{
foreach (ValidMethodMap method in CalculateMethodMap(target, delegateArgumentsTypes, mode == PersistentListenerMode.Object))
{
var validMethodMap = method;
validMethodMap.mode = mode;
methods.Add(validMethodMap);
}
}
private static void AddFunctionsForScript(
GenericMenu menu,
SerializedProperty listener,
ValidMethodMap method,
string targetName)
{
PersistentListenerMode mode1 = method.mode;
var objectReferenceValue = listener.FindPropertyRelative("_vmName").stringValue;
string stringValue = listener.FindPropertyRelative("_methodName").stringValue;
PersistentListenerMode mode2 = GetMode(listener.FindPropertyRelative("_mode"));
SerializedProperty propertyRelative = listener.FindPropertyRelative("_arguments").FindPropertyRelative("m_ObjectArgumentAssemblyTypeName");
StringBuilder stringBuilder = new StringBuilder();
int length = method.methodInfo.GetParameters().Length;
for (int index = 0; index < length; ++index)
{
System.Reflection.ParameterInfo parameter = method.methodInfo.GetParameters()[index];
stringBuilder.Append(string.Format("{0}", (object)GetTypeName(parameter.ParameterType)));
if (index < length - 1)
{
stringBuilder.Append(", ");
}
}
bool flag = objectReferenceValue == method.target && stringValue == method.methodInfo.Name && mode1 == mode2;
if (flag && mode1 == PersistentListenerMode.Object && method.methodInfo.GetParameters().Length == 1)
{
flag &= method.methodInfo.GetParameters()[0].ParameterType.AssemblyQualifiedName == propertyRelative.stringValue;
}
string formattedMethodName = GetFormattedMethodName(targetName, method.fieldName, stringBuilder.ToString(), mode1 == PersistentListenerMode.EventDefined);
GenericMenu genericMenu = menu;
GUIContent content = new GUIContent(formattedMethodName);
int num = flag ? 1 : 0;
// ISSUE: reference to a compiler-generated field
if (_menuCallBack1 == null)
{
// ISSUE: reference to a compiler-generated field
_menuCallBack1 = new GenericMenu.MenuFunction2(SetEventFunction);
}
// ISSUE: reference to a compiler-generated field
GenericMenu.MenuFunction2 fMgCache1 = _menuCallBack1;
// ISSUE: variable of a boxed type
var local = (ValueType) new UnityEventFunction(listener, method.target, method.methodInfo, mode1, method.fieldName);
genericMenu.AddItem(content, num != 0, fMgCache1, (object)local);
}
static Type Mode2Type(PersistentListenerMode mode)
{
switch (mode)
{
case PersistentListenerMode.Float: return(typeof(float));
case PersistentListenerMode.Int: return(typeof(int));
case PersistentListenerMode.Bool: return(typeof(bool));
case PersistentListenerMode.String: return(typeof(string));
case PersistentListenerMode.Object: return(typeof(Object));
default: return(typeof(Object));
}
}
protected bool ValidateRegistration(MethodInfo method, object targetObj, PersistentListenerMode mode, Type argumentType)
{
if (method == null)
{
throw new ArgumentNullException("method", UnityString.Format("Can not register null method on {0} for callback!", new object[]
{
targetObj
}));
}
UnityEngine.Object @object = targetObj as UnityEngine.Object;
if (@object == null || @object.GetInstanceID() == 0)
{
throw new ArgumentException(UnityString.Format("Could not register callback {0} on {1}. The class {2} does not derive from UnityEngine.Object", new object[]
{
method.Name,
targetObj,
(targetObj != null) ? targetObj.GetType().ToString() : "null"
}));
}
if (method.IsStatic)
{
throw new ArgumentException(UnityString.Format("Could not register listener {0} on {1} static functions are not supported.", new object[]
{
method,
base.GetType()
}));
}
bool result;
if (this.FindMethod(method.Name, targetObj, mode, argumentType) == null)
{
Debug.LogWarning(UnityString.Format("Could not register listener {0}.{1} on {2} the method could not be found.", new object[]
{
targetObj,
method,
base.GetType()
}));
result = false;
}
else
{
result = true;
}
return(result);
}
private void ValidateObjectParamater(SerializedProperty arguments, PersistentListenerMode mode)
{
SerializedProperty serializedProperty = arguments.FindPropertyRelative("m_ObjectArgumentAssemblyTypeName");
SerializedProperty serializedProperty2 = arguments.FindPropertyRelative("m_ObjectArgument");
UnityEngine.Object objectReferenceValue = serializedProperty2.objectReferenceValue;
if (mode != PersistentListenerMode.Object)
{
serializedProperty.stringValue = typeof(UnityEngine.Object).AssemblyQualifiedName;
serializedProperty2.objectReferenceValue = null;
}
else if (!(objectReferenceValue == null))
{
Type type = Type.GetType(serializedProperty.stringValue, false);
if (!typeof(UnityEngine.Object).IsAssignableFrom(type) || !type.IsInstanceOfType(objectReferenceValue))
{
serializedProperty2.objectReferenceValue = null;
}
}
}
private void ValidateObjectParamater(SerializedProperty arguments, PersistentListenerMode mode)
{
SerializedProperty serializedProperty = arguments.FindPropertyRelative("m_ObjectArgumentAssemblyTypeName");
SerializedProperty serializedProperty2 = arguments.FindPropertyRelative("m_ObjectArgument");
UnityEngine.Object objectReferenceValue = serializedProperty2.objectReferenceValue;
if (mode != PersistentListenerMode.Object)
{
serializedProperty.stringValue = typeof(UnityEngine.Object).AssemblyQualifiedName;
serializedProperty2.objectReferenceValue = null;
return;
}
if (objectReferenceValue == null)
{
return;
}
Type type = Type.GetType(serializedProperty.stringValue, false);
if (!typeof(UnityEngine.Object).IsAssignableFrom(type) || !type.IsInstanceOfType(objectReferenceValue))
{
serializedProperty2.objectReferenceValue = null;
}
}
static void AddFunctionsForScript(GenericMenu menu, SerializedProperty listener, ValidMethodMap method, string targetName)
{
PersistentListenerMode mode = method.mode;
// find the current event target...
var listenerTarget = listener.FindPropertyRelative(kInstancePath).objectReferenceValue;
var methodName = listener.FindPropertyRelative(kMethodNamePath).stringValue;
var setMode = GetMode(listener.FindPropertyRelative(kModePath));
var typeName = listener.FindPropertyRelative(kArgumentsPath).FindPropertyRelative(kObjectArgumentAssemblyTypeName);
var args = new StringBuilder();
var count = method.methodInfo.GetParameters().Length;
for (int index = 0; index < count; index++)
{
var methodArg = method.methodInfo.GetParameters()[index];
args.Append(string.Format("{0}", GetTypeName(methodArg.ParameterType)));
if (index < count - 1)
{
args.Append(", ");
}
}
var isCurrentlySet = listenerTarget == method.target &&
methodName == method.methodInfo.Name &&
mode == setMode;
if (isCurrentlySet && mode == PersistentListenerMode.Object && method.methodInfo.GetParameters().Length == 1)
{
isCurrentlySet &= (method.methodInfo.GetParameters()[0].ParameterType.AssemblyQualifiedName == typeName.stringValue);
}
string path = GetFormattedMethodName(targetName, method.methodInfo.Name, args.ToString(), mode == PersistentListenerMode.EventDefined);
menu.AddItem(new GUIContent(path),
isCurrentlySet,
SetEventFunction,
new UnityEventFunction(listener, method.target, method.methodInfo, mode));
}
internal MethodInfo FindMethod(string name, object listener, PersistentListenerMode mode, System.Type argumentType)
{
switch (mode)
{
case PersistentListenerMode.EventDefined:
return(this.FindMethod_Impl(name, listener));
case PersistentListenerMode.Void:
return(UnityEventBase.GetValidMethodInfo(listener, name, new System.Type[0]));
case PersistentListenerMode.Object:
return(UnityEventBase.GetValidMethodInfo(listener, name, new System.Type[1] {
argumentType ?? typeof(UnityEngine.Object)
}));
case PersistentListenerMode.Int:
return(UnityEventBase.GetValidMethodInfo(listener, name, new System.Type[1] {
typeof(int)
}));
case PersistentListenerMode.Float:
return(UnityEventBase.GetValidMethodInfo(listener, name, new System.Type[1] {
typeof(float)
}));
case PersistentListenerMode.String:
return(UnityEventBase.GetValidMethodInfo(listener, name, new System.Type[1] {
typeof(string)
}));
case PersistentListenerMode.Bool:
return(UnityEventBase.GetValidMethodInfo(listener, name, new System.Type[1] {
typeof(bool)
}));
default:
return((MethodInfo)null);
}
}
public virtual MethodInfo FindMethod(string name, Type listenerType, PersistentListenerMode mode, Type argumentType)
{
switch (mode)
{
case PersistentListenerMode.EventDefined:
return(FindMethod_Impl(name, listenerType));
case PersistentListenerMode.Void:
return(GetValidMethodInfo(listenerType, name, new Type[0]));
case PersistentListenerMode.Float:
return(GetValidMethodInfo(listenerType, name, new[] { typeof(float) }));
case PersistentListenerMode.Int:
return(GetValidMethodInfo(listenerType, name, new[] { typeof(int) }));
case PersistentListenerMode.Bool:
return(GetValidMethodInfo(listenerType, name, new[] { typeof(bool) }));
case PersistentListenerMode.String:
{
//Serialized Data
if (argumentType != null && !argumentType.IsSubclassOf(typeof(string)) && argumentType != typeof(string))
{
return(GetValidMethodInfo(listenerType, name, new[] { argumentType }));
}
else
{
return(GetValidMethodInfo(listenerType, name, new[] { typeof(string) }));
}
}
case PersistentListenerMode.Object:
return(GetValidMethodInfo(listenerType, name, new[] { argumentType ?? typeof(UnityEngine.Object) }));
default:
return(null);
}
}
public void ReadFrom(object obj)
{
if (obj == null)
{
m_Arguments = default(PersistentArgumentCache);
m_CallState = default(UnityEventCallState);
m_MethodName = null;
m_Mode = default(PersistentListenerMode);
m_Target = 0;
return;
}
Initialize(obj.GetType());
m_Arguments = new PersistentArgumentCache();
m_Arguments.ReadFrom(m_argumentsFieldInfo.GetValue(obj));
m_CallState = (UnityEventCallState)m_callStatFieldInfo.GetValue(obj);
m_MethodName = (string)m_methodNameFieldInfo.GetValue(obj);
m_Mode = (PersistentListenerMode)m_modeFieldInfo.GetValue(obj);
UnityObject target = (UnityObject)m_targetFieldInfo.GetValue(obj);
m_Target = target.GetMappedInstanceID();
}
public static bool IsPersistantListenerValid(UnityEventBase dummyEvent, string methodName, UnityEngine.Object uObject, PersistentListenerMode modeEnum, Type argumentType)
{
return !(uObject == null) && !string.IsNullOrEmpty(methodName) && dummyEvent.FindMethod(methodName, uObject, modeEnum, argumentType) != null;
}
private static void GetMethodsForTargetAndMode(UnityEngine.Object target, Type[] delegateArgumentsTypes, List<UnityEventDrawer.ValidMethodMap> methods, PersistentListenerMode mode)
{
IEnumerable<UnityEventDrawer.ValidMethodMap> enumerable = UnityEventDrawer.CalculateMethodMap(target, delegateArgumentsTypes, mode == PersistentListenerMode.Object);
foreach (UnityEventDrawer.ValidMethodMap current in enumerable)
{
UnityEventDrawer.ValidMethodMap item = current;
item.mode = mode;
methods.Add(item);
}
}
private void ValidateObjectParamater(SerializedProperty arguments, PersistentListenerMode mode)
{
SerializedProperty propertyRelative1 = arguments.FindPropertyRelative("m_ObjectArgumentAssemblyTypeName");
SerializedProperty propertyRelative2 = arguments.FindPropertyRelative("m_ObjectArgument");
UnityEngine.Object objectReferenceValue = propertyRelative2.objectReferenceValue;
if (mode != PersistentListenerMode.Object)
{
propertyRelative1.stringValue = typeof (UnityEngine.Object).AssemblyQualifiedName;
propertyRelative2.objectReferenceValue = (UnityEngine.Object) null;
}
else
{
if (objectReferenceValue == (UnityEngine.Object) null)
return;
System.Type type = System.Type.GetType(propertyRelative1.stringValue, false);
if (typeof (UnityEngine.Object).IsAssignableFrom(type) && type.IsInstanceOfType((object) objectReferenceValue))
return;
propertyRelative2.objectReferenceValue = (UnityEngine.Object) null;
}
}
private static void GetMethodsForTargetAndMode(UnityEngine.Object target, System.Type[] delegateArgumentsTypes, List<UnityEventDrawer.ValidMethodMap> methods, PersistentListenerMode mode)
{
foreach (UnityEventDrawer.ValidMethodMap method in UnityEventDrawer.CalculateMethodMap(target, delegateArgumentsTypes, mode == PersistentListenerMode.Object))
{
method.mode = mode;
methods.Add(method);
}
}
public static bool IsPersistantListenerValid(UnityEventBase dummyEvent, string methodName, UnityEngine.Object uObject, PersistentListenerMode modeEnum, System.Type argumentType)
{
if (uObject == (UnityEngine.Object) null || string.IsNullOrEmpty(methodName))
return false;
return dummyEvent.FindMethod(methodName, (object) uObject, modeEnum, argumentType) != null;
}
private void ValidateObjectParamater(SerializedProperty arguments, PersistentListenerMode mode)
{
SerializedProperty property = arguments.FindPropertyRelative("m_ObjectArgumentAssemblyTypeName");
SerializedProperty property2 = arguments.FindPropertyRelative("m_ObjectArgument");
UnityEngine.Object objectReferenceValue = property2.objectReferenceValue;
if (mode != PersistentListenerMode.Object)
{
property.stringValue = typeof(UnityEngine.Object).AssemblyQualifiedName;
property2.objectReferenceValue = null;
}
else if (objectReferenceValue != null)
{
System.Type c = System.Type.GetType(property.stringValue, false);
if (!typeof(UnityEngine.Object).IsAssignableFrom(c) || !c.IsInstanceOfType(objectReferenceValue))
{
property2.objectReferenceValue = null;
}
}
}
