Ejemplo n.º 1
0
 public void CreateDynamicMemberItems(MemberInfo[] membersInfo)
 {
     dynamicMembers = new MemberMenuItem[membersInfo.Length];
     for (int i = 0; i < membersInfo.Length; i++)
     {
         dynamicMembers[i] = new MemberMenuItem(i, true, membersInfo[i]);
     }
 }
Ejemplo n.º 2
0
 public void CreateStaticMemberItems(MemberInfo[] membersInfo)
 {
     staticMembers = new MemberMenuItem[membersInfo.Length];
     for (int i = 0; i < membersInfo.Length; i++)
     {
         staticMembers[i] = new MemberMenuItem(i, false, membersInfo[i]);
     }
 }
Ejemplo n.º 3
0
    private void GenericMenuSelectionHandler(object menuIndexInfo)
    {
        MemberMenuIndex menuIndex = menuIndexInfo as MemberMenuIndex;

        GetInspectorState(menuIndex.property);
        PersistentCallData persistentCall = inspectorState.inspectorData.persistentCallData[menuIndex.persistentCallIndex];

        if (menuIndex == null || persistentCall.targetProperty.objectReferenceValue == null)
        {
            return;
        }

        persistentCall.componentIndexProperty.intValue = menuIndex.componentIndex;
        persistentCall.memberIndexProperty.intValue    = menuIndex.memberIndex;
        persistentCall.isDynamicDataProperty.boolValue = menuIndex.isDynamic;
        persistentCall.isDynamicProperty.boolValue     = menuIndex.isDynamic;

        // Get the info of the option we selected in the generic menu
        MemberMenuItem menuItem = persistentCall.genericMenuData.GetComponent(menuIndex.componentIndex).GetMemberItem(menuIndex.memberIndex, menuIndex.isDynamic);

        // Set target object to reference of component selected in generic dropdown menu
        persistentCall.targetProperty.objectReferenceValue = (menuIndex.componentIndex < 0) ? persistentCall.targetGameObject : persistentCall.genericMenuData.GetComponent(menuIndex.componentIndex).component;

        if (menuItem == null)
        {
            return;
        }

        // Set target object to reference of component selected in generic dropdown menu
        persistentCall.targetProperty.objectReferenceValue = persistentCall.genericMenuData.GetComponent(menuIndex.componentIndex).component;
        // Set memberName to string at selectedIndex
        persistentCall.memberNameProperty.stringValue = menuItem.memberInfo.Name;
        // Set memberType enum value
        persistentCall.memberTypeProperty.enumValueIndex = GetMemberTypeIndex(menuItem.memberInfo.MemberType);

        // Set the function argument type
        Type argumentType = typeof(void);

        if (menuItem.memberInfo.MemberType == MemberTypes.Method)
        {
            ParameterInfo[] parameterInfo = (menuItem.memberInfo as MethodInfo).GetParameters();
            argumentType = parameterInfo.Length == 0 ? typeof(void) : parameterInfo[0].ParameterType;
        }
        else if (menuItem.memberInfo.MemberType == MemberTypes.Property)
        {
            argumentType = (menuItem.memberInfo as PropertyInfo).PropertyType;
        }
        else if (menuItem.memberInfo.MemberType == MemberTypes.Field)
        {
            argumentType = (menuItem.memberInfo as FieldInfo).FieldType;
        }

        persistentCall.argumentTypeProperty.enumValueIndex = (int)GetArgumentType(argumentType);
        inspectorState.inspectorData.UpdateDataValues(menuIndex.persistentCallIndex);
        inspectorState.inspectorData.property.serializedObject.ApplyModifiedProperties(); //TODO?

        GUIUtility.hotControl = 0;
    }
Ejemplo n.º 4
0
        public PersistentCallData(InspectorData inspectorData, int index, int indentLevel, Rect position, SerializedProperty property, SerializedProperty listProperty, GenericMenu.MenuFunction2 menuSelectionHandler, GenericMenu.MenuFunction2 noFunctionHandler)
        {
            this.inspectorData           = inspectorData;
            this.index                   = index;
            this.persistentCallProperty  = listProperty.GetArrayElementAtIndex(index);
            this.genericMenuDataProperty = persistentCallProperty.FindPropertyRelative("genericMenuData");
            this.componentIndexProperty  = genericMenuDataProperty.FindPropertyRelative("selectedComponent");
            this.memberIndexProperty     = genericMenuDataProperty.FindPropertyRelative("selectedMember");
            this.isDynamicDataProperty   = genericMenuDataProperty.FindPropertyRelative("isDynamic");

            this.targetProperty        = persistentCallProperty.FindPropertyRelative("target");
            this.memberNameProperty    = persistentCallProperty.FindPropertyRelative("memberName");
            this.memberTypeProperty    = persistentCallProperty.FindPropertyRelative("memberType");
            this.isDynamicProperty     = persistentCallProperty.FindPropertyRelative("isDynamic");
            this.isCallEnabledProperty = persistentCallProperty.FindPropertyRelative("isCallEnabled");
            this.argumentTypeProperty  = persistentCallProperty.FindPropertyRelative("argument").FindPropertyRelative("supportedType");

            // Try to cast assigned target to GameObject type
            targetGameObject = targetProperty.objectReferenceValue as GameObject;
            Component targetComponent = targetProperty.objectReferenceValue as Component;

            if (targetGameObject == null)
            {
                // If that doesn't work, perhaps a component was assigned
                if (targetComponent != null)
                {
                    targetGameObject = targetComponent.gameObject;
                }
                // If it wasn't a component or not an instance then set the field to null
                if (targetGameObject == null)
                {
                    targetProperty.objectReferenceValue = null;
                }
            }

            if (targetGameObject == null)
            {
                return;
            }

            // Add all components and the game object reference to the selectable list
            Component[] components = targetGameObject.GetComponents(typeof(Component));
            Object[]    gameObjectAndComponents = new Object[components.Length + 1];
            gameObjectAndComponents[0] = targetGameObject;
            components.CopyTo(gameObjectAndComponents, 1);
            genericMenuData = new MemberMenuData(inspectorData, gameObjectAndComponents);

            // Check if components have been added or moved up/down in the inspector
            if (componentIndexProperty.intValue != -1)
            {
                for (int i = 0; i < components.Length; i++)
                {
                    if (components[i] == targetComponent)
                    {
                        componentIndexProperty.intValue = i + 1;
                    }
                }
            }

            // Check if members have been renamed or removed
            if (componentIndexProperty.intValue >= 0 && memberIndexProperty.intValue >= 0)
            {
                MemberMenuComponent selectedComponent  = genericMenuData.components[Mathf.Clamp(componentIndexProperty.intValue, 0, genericMenuData.components.Length - 1)];
                MemberMenuItem      selectedMemberItem = selectedComponent.GetMemberItem(memberIndexProperty.intValue, isDynamicDataProperty.boolValue);
                if (selectedMemberItem != null)
                {
                    // Check if string value at memberIndexProperty.intValue equals the expected member name
                    string selectedMemberName = selectedMemberItem.memberInfo.Name;
                    if (selectedMemberName != memberNameProperty.stringValue)
                    {
                        // Get the relevant members array
                        MemberMenuItem[] members = isDynamicDataProperty.boolValue ? selectedComponent.dynamicMembers : selectedComponent.staticMembers;

                        // Try to find the correct index
                        for (int i = 0; i < members.Length; i++)
                        {
                            if (members[i].memberInfo.Name == memberNameProperty.stringValue)
                            {
                                memberIndexProperty.intValue = i;
                            }
                        }

                        // Ensure that if the member has been renamed we keep our current index and update the memberNameProperty value
                        memberNameProperty.stringValue = members[Mathf.Clamp(memberIndexProperty.intValue, 0, members.Length - 1)].memberInfo.Name;
                    }
                }
            }

            genericMenu = new GenericMenu();
            bool isNoFunctionSelected = componentIndexProperty.intValue == -1;

            genericMenu.AddItem(new GUIContent("No Function"), isNoFunctionSelected, noFunctionHandler, new MemberMenuIndex(property, index, 0, 0, false));
            genericMenu.AddSeparator("");

            for (int i = 0; i < genericMenuData.components.Length; i++)
            {
                MemberMenuComponent component = genericMenuData.components[i];

                for (int j = 0; j < component.dynamicMembers.Length; j++)
                {
                    string prefix = component.displayName + "/";
                    if (j == 0)
                    {
                        genericMenu.AddDisabledItem(new GUIContent(prefix + "Dynamic " + GetCleanTypeName(inspectorData.eventType)));
                    }

                    bool isSelected = (isDynamicProperty.boolValue && i == componentIndexProperty.intValue && component.GetMemberItem(j, true).index == memberIndexProperty.intValue);
                    genericMenu.AddItem(new GUIContent(prefix + component.dynamicMembers[j].memberInfo.Name), isSelected, menuSelectionHandler, new MemberMenuIndex(property, index, i, j, true));
                }

                if (component.dynamicMembers.Length > 0 && component.staticMembers.Length > 0)
                {
                    genericMenu.AddDisabledItem(new GUIContent(component.displayName + "/ "));
                }

                for (int j = 0; j < component.staticMembers.Length; j++)
                {
                    string prefix = component.displayName + "/";
                    if (j == 0)
                    {
                        genericMenu.AddDisabledItem(new GUIContent(prefix + "Static Parameters"));
                    }

                    bool isSelected = (!isDynamicProperty.boolValue && i == componentIndexProperty.intValue && component.GetMemberItem(j, false).index == memberIndexProperty.intValue);
                    genericMenu.AddItem(new GUIContent(prefix + component.staticMembers[j].menuDisplayName), isSelected, menuSelectionHandler, new MemberMenuIndex(property, index, i, j, false));
                }
            }

            selectedOptionText      = "No Function";
            shortSelectedOptionText = selectedOptionText;

            if (componentIndexProperty.intValue >= 0)
            {
                MemberMenuComponent menuComponent = genericMenuData.components[Mathf.Clamp(componentIndexProperty.intValue, 0, genericMenuData.components.Length - 1)];
                MemberMenuItem      menuItem      = menuComponent.GetMemberItem(memberIndexProperty.intValue, isDynamicProperty.boolValue);
                if (menuItem != null)
                {
                    shortSelectedOptionText = menuItem.shortDisplayName;
                    selectedOptionText      = menuComponent.component.GetType().Name + "." + shortSelectedOptionText;
                }
            }

            property.serializedObject.ApplyModifiedProperties();
        }