private void ValidateObjectParamater(SerializedProperty arguments, UnityEngine.Events.PersistentListenerMode mode)
            {
                var fullArgumentType = arguments.FindPropertyRelative(kObjectArgumentAssemblyTypeName);
                var argument         = arguments.FindPropertyRelative(kObjectArgument);
                var argumentObj      = argument.objectReferenceValue;

                if (mode != UnityEngine.Events.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 UnityEventFunction(SerializedProperty listener, Object target, MethodInfo method, UnityEngine.Events.PersistentListenerMode mode)
 {
     m_Listener = listener;
     m_Target   = target;
     m_Method   = method;
     m_Mode     = mode;
 }
        static void AddFunctionsForScript(GenericMenu menu, SerializedProperty listener, ValidMethodMap method, string targetName)
        {
            UnityEngine.Events.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 == UnityEngine.Events.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 == UnityEngine.Events.PersistentListenerMode.EventDefined);

            menu.AddItem(new GUIContent(path),
                         isCurrentlySet,
                         SetEventFunction,
                         new UnityEventFunction(listener, method.target, method.methodInfo, mode));
        }
        private static void GetMethodsForTargetAndMode(Object target, Type[] delegateArgumentsTypes, List <ValidMethodMap> methods, UnityEngine.Events.PersistentListenerMode mode)
        {
            IEnumerable <ValidMethodMap> newMethods = CalculateMethodMap(target, delegateArgumentsTypes, mode == UnityEngine.Events.PersistentListenerMode.Object || mode == UnityEngine.Events.PersistentListenerMode.String);

            foreach (var m in newMethods)
            {
                var method = m;
                method.mode = mode;
                methods.Add(method);
            }
        }
        public static bool IsPersistantListenerValid(UnityEventBaseEx dummyEvent, string methodName, Object uObject, UnityEngine.Events.PersistentListenerMode modeEnum, Type argumentType)
        {
            if (uObject == null || string.IsNullOrEmpty(methodName))
            {
                return(false);
            }

            return(dummyEvent.FindMethod(methodName, uObject.GetType(), modeEnum, argumentType) != null);
        }