Example #1
0
                private static List <Type> GetFilteredTypes(ClassTypeConstraintAttribute filter)
                {
                    var types = new List <Type>();

                    var excludedTypes = (ExcludedTypeCollectionGetter != null ? ExcludedTypeCollectionGetter() : null);

                    var assembly = Assembly.GetExecutingAssembly();

                    FilterTypes(assembly, filter, excludedTypes, types);

                    foreach (var referencedAssembly in assembly.GetReferencedAssemblies())
                    {
                        FilterTypes(Assembly.Load(referencedAssembly), filter, excludedTypes, types);
                    }

                    types.Sort((a, b) => a.FullName.CompareTo(b.FullName));

                    return(types);
                }
Example #2
0
        private static void FilterTypes(Assembly assembly, ClassTypeConstraintAttribute filter, ICollection <Type> excludedTypes, List <Type> output)
        {
            foreach (Type type in assembly.GetTypes())
            {
                if (!type.IsVisible || !type.IsClass)
                {
                    continue;
                }

                if (filter != null && !filter.IsConstraintSatisfied(type))
                {
                    continue;
                }

                if (excludedTypes != null && excludedTypes.Contains(type))
                {
                    continue;
                }

                output.Add(type);
            }
        }
Example #3
0
        private static List <Type> GetFilteredTypes(ClassTypeConstraintAttribute filter)
        {
            List <Type> types = new List <Type>();

            ICollection <Type> excludedTypes = (ExcludedTypeCollectionGetter != null ? ExcludedTypeCollectionGetter() : null);

            //Assembly assembly = Assembly.GetExecutingAssembly();
            foreach (var assembly in StratusReflection.allAssemblies)
            {
                FilterTypes(assembly, filter, excludedTypes, types);
            }

            //FilterTypes(assembly, filter, excludedTypes, types);
            //
            //foreach (AssemblyName referencedAssembly in assembly.GetReferencedAssemblies())
            //{
            //	FilterTypes(Assembly.Load(referencedAssembly), filter, excludedTypes, types);
            //}

            types.Sort((a, b) => a.FullName.CompareTo(b.FullName));

            return(types);
        }
Example #4
0
        private static void DrawTypeSelectionControl(Rect position, SerializedProperty property, GUIContent label, ClassTypeConstraintAttribute filter)
        {
            try
            {
                bool restoreShowMixedValue = EditorGUI.showMixedValue;
                EditorGUI.showMixedValue = property.hasMultipleDifferentValues;

                property.stringValue = DrawTypeSelectionControl(position, label, property.stringValue, filter);

                EditorGUI.showMixedValue = restoreShowMixedValue;
            }
            finally
            {
                ExcludedTypeCollectionGetter = null;
            }
        }
Example #5
0
        private static string DrawTypeSelectionControl(Rect position, GUIContent label, string classRef, ClassTypeConstraintAttribute filter)
        {
            if (label != null && label != GUIContent.none)
            {
                position = EditorGUI.PrefixLabel(position, label);
            }

            int controlID = GUIUtility.GetControlID(s_ControlHint, FocusType.Keyboard, position);

            bool triggerDropDown = false;

            switch (UnityEngine.Event.current.GetTypeForControl(controlID))
            {
            case EventType.ExecuteCommand:
                if (UnityEngine.Event.current.commandName == "TypeReferenceUpdated")
                {
                    if (s_SelectionControlID == controlID)
                    {
                        if (classRef != s_SelectedClassRef)
                        {
                            classRef    = s_SelectedClassRef;
                            GUI.changed = true;
                        }

                        s_SelectionControlID = 0;
                        s_SelectedClassRef   = null;
                    }
                }
                break;

            case EventType.MouseDown:
                if (GUI.enabled && position.Contains(UnityEngine.Event.current.mousePosition))
                {
                    GUIUtility.keyboardControl = controlID;
                    triggerDropDown            = true;
                    UnityEngine.Event.current.Use();
                }
                break;

            case EventType.KeyDown:
                if (GUI.enabled && GUIUtility.keyboardControl == controlID)
                {
                    if (UnityEngine.Event.current.keyCode == KeyCode.Return || UnityEngine.Event.current.keyCode == KeyCode.Space)
                    {
                        triggerDropDown = true;
                        UnityEngine.Event.current.Use();
                    }
                }
                break;

            case EventType.Repaint:
                // Remove assembly name from content of popup control.
                string[] classRefParts = classRef.Split(',');

                s_TempContent.text = classRefParts[0].Trim();
                if (s_TempContent.text == "")
                {
                    s_TempContent.text = "(None)";
                }
                else if (StratusReflection.ResolveType(classRef) == null)
                {
                    s_TempContent.text += " {Missing}";
                }

                EditorStyles.popup.Draw(position, s_TempContent, controlID);
                break;
            }

            if (triggerDropDown)
            {
                s_SelectionControlID = controlID;
                s_SelectedClassRef   = classRef;

                List <Type> filteredTypes = GetFilteredTypes(filter);
                DisplayDropDown(position, filteredTypes, StratusReflection.ResolveType(classRef), filter.Grouping);
            }

            return(classRef);
        }