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