Merge pull request #18 from arimger/develop

Develop

Author: arimger

Assets/Editor Toolbox/CHANGELOG.md

@@ -1,3 +1,16 @@
+## 0.8.11 [02.07.2021]
+
+### Added:
+- IgnoreParentAttribute
+- ShowDisabledIfAttribute
+- HideDisabledIfAttribute
+- Default constraint to the SerializedType drawer
+
+### Changed:
+- Fix assigning and clearing multiple drawers at once
+- Fix drawing default numeric types (Vector2, Vector3, etc.)
+- Fix drawing ReorderableList within horizontal groups
+
 ## 0.8.6 [13.06.2021]
 
 ### Added:

Assets/Editor Toolbox/Editor/Drawers/RegularDrawers/SerializedTypeDrawer.cs

@@ -6,14 +6,14 @@
 
 namespace Toolbox.Editor.Drawers
 {
-    [CustomPropertyDrawer(typeof(ClassTypeConstraintAttribute), true)]
+    [CustomPropertyDrawer(typeof(TypeConstraintAttribute), true)]
     [CustomPropertyDrawer(typeof(SerializedType))]
     public sealed class SerializedTypeDrawer : ToolboxNativePropertyDrawer
     {
         /// <summary>
-        /// Dictionary used to store all previously filtered types.
+        /// Dictionary used to store all previously filtered types matched to the targt attribute.
         /// </summary>
-        private readonly static Dictionary<Type, List<Type>> filteredTypes = new Dictionary<Type, List<Type>>();
+        private readonly static Dictionary<int, List<Type>> cachedfilteredTypes = new Dictionary<int, List<Type>>();
 
 
         /// <summary>
@@ -60,55 +60,82 @@ private static string GetClassReferencValue(int selectedType, List<Type> types)
             return selectedType > 0 ? SerializedType.GetClassReference(types[selectedType - 1]) : string.Empty;
         }
 
-        private bool IsDefaultField(Attribute attribute)
+        private bool IsDefaultField(TypeConstraintAttribute attribute)
         {
-            return IsDefaultField(attribute as ClassTypeConstraintAttribute);
+            return attribute == null || attribute.AssemblyType == null;
         }
 
-        private bool IsDefaultField(ClassTypeConstraintAttribute attribute)
+        /// <summary>
+        /// Creates default constraint attribute if the given one is invalid.
+        /// </summary>
+        private TypeConstraintAttribute GetVerifiedAttribute(Attribute attribute)
         {
-            return attribute == null || attribute.AssemblyType == null;
+            return GetVerifiedAttribute(attribute as TypeConstraintAttribute);
         }
 
+        /// <summary>
+        /// Creates default constraint attribute if the given one is invalid.
+        /// </summary>
+        private TypeConstraintAttribute GetVerifiedAttribute(TypeConstraintAttribute attribute)
+        {
+            return IsDefaultField(attribute) ? GetDefaultConstraint() : attribute;
+        }
 
-        protected override float GetPropertyHeightSafe(SerializedProperty property, GUIContent label)
+        /// <summary>
+        /// Returns default <see cref="TypeConstraintAttribute"/>.
+        /// </summary>
+        private TypeConstraintAttribute GetDefaultConstraint()
         {
-            return IsDefaultField(attribute)
-                ? EditorGUI.GetPropertyHeight(property)
-                : EditorStyles.popup.CalcHeight(GUIContent.none, 0);
+            return new ClassExtendsAttribute()
+            {
+                AddTextSearchField = true
+            };
         }
 
-        protected override void OnGUISafe(Rect position, SerializedProperty property, GUIContent label)
+        /// <summary>
+        /// Returns all <see cref="Type"/>s associated to the given constraint.
+        /// </summary>
+        private List<Type> GetFilteredTypes(TypeConstraintAttribute attribute)
         {
-            var attribute = Attribute;
-            //TODO: default drawer for fields without attributes
-            //validate serialized field
-            if (IsDefaultField(attribute))
+            var hashCode = attribute.GetHashCode();
+            if (cachedfilteredTypes.TryGetValue(hashCode, out var filteredTypes))
             {
-                EditorGUI.PropertyField(position, property, label, property.isExpanded);
-                return;
+                return filteredTypes;
             }
-
-            //TODO: cache different filter settings
-            //get stored types if possible or try to cache them
-            if (!filteredTypes.TryGetValue(attribute.AssemblyType, out var refTypes))
+            else
             {
-                filteredTypes[attribute.AssemblyType] = refTypes = attribute.GetFilteredTypes();
+                return cachedfilteredTypes[hashCode] = attribute.GetFilteredTypes();
             }
+        }
+
+
+        protected override float GetPropertyHeightSafe(SerializedProperty property, GUIContent label)
+        {
+            return EditorStyles.popup.CalcHeight(GUIContent.none, 0);
+        }
+
+        protected override void OnGUISafe(Rect position, SerializedProperty property, GUIContent label)
+        {
+            var validAttribute = GetVerifiedAttribute(attribute);
 
             var referenceProperty = property.FindPropertyRelative("classReference");
             var referenceValue = referenceProperty.stringValue;
-            var referenceType = !string.IsNullOrEmpty(referenceValue) ? Type.GetType(referenceValue) : null;
-            var optionsCount = refTypes.Count + 1;
+            var referenceType = !string.IsNullOrEmpty(referenceValue)
+                ? Type.GetType(referenceValue)
+                : null;
+
+            var filteredTypes = GetFilteredTypes(validAttribute);
+
+            var optionsCount = filteredTypes.Count + 1;
             var options = new string[optionsCount];
             var index = 0;
 
             //create labels for all types
             options[0] = "<None>";
             for (var i = 1; i < optionsCount; i++)
             {
-                var menuType = refTypes[i - 1];
-                var menuLabel = FormatGroupedTypeName(menuType, attribute.Grouping);
+                var menuType = filteredTypes[i - 1];
+                var menuLabel = FormatGroupedTypeName(menuType, validAttribute.Grouping);
                 if (menuType == referenceType)
                 {
                     index = i;
@@ -124,20 +151,20 @@ protected override void OnGUISafe(Rect position, SerializedProperty property, GU
             position = EditorGUI.PrefixLabel(position, label);
 
             //try to draw associated popup
-            if (attribute.AddTextSearchField)
+            if (validAttribute.AddTextSearchField)
             {
                 var buttonLabel = new GUIContent(options[index]);
                 ToolboxEditorGui.DrawSearchablePopup(position, buttonLabel, index, options, (i) =>
                 {
                     referenceProperty.serializedObject.Update();
-                    referenceProperty.stringValue = GetClassReferencValue(i, refTypes);
+                    referenceProperty.stringValue = GetClassReferencValue(i, filteredTypes);
                     referenceProperty.serializedObject.ApplyModifiedProperties();
                 });
             }
             else
             {
                 index = EditorGUI.Popup(position, index, options);
-                referenceProperty.stringValue = GetClassReferencValue(index, refTypes);
+                referenceProperty.stringValue = GetClassReferencValue(index, filteredTypes);
             }
 
             EditorGUI.EndProperty();
@@ -149,8 +176,5 @@ public override bool IsPropertyValid(SerializedProperty property)
         {
             return property.type == nameof(SerializedType);
         }
-
-
-        private ClassTypeConstraintAttribute Attribute => attribute as ClassTypeConstraintAttribute;
     }
 }

Assets/Editor Toolbox/Editor/Drawers/ToolboxDrawers/ConditionDrawers/HideDisabledIfAttributeDrawer.cs

@@ -0,0 +1,12 @@
+using UnityEngine;
+
+namespace Toolbox.Editor.Drawers
+{
+    public class HideDisabledIfAttributeDrawer : ComparisonAttributeDrawer<HideDisabledIfAttribute>
+    {
+        protected override PropertyCondition OnComparisonResult(bool result)
+        {
+            return result ? PropertyCondition.NonValid : PropertyCondition.Disabled;
+        }
+    }
+}

Assets/Editor Toolbox/Editor/Drawers/ToolboxDrawers/ConditionDrawers/HideDisabledIfAttributeDrawer.cs.meta

@@ -0,0 +1,12 @@
+using UnityEngine;
+
+namespace Toolbox.Editor.Drawers
+{
+    public class ShowDisabledIfAttributeDrawer : ComparisonAttributeDrawer<ShowDisabledIfAttribute>
+    {
+        protected override PropertyCondition OnComparisonResult(bool result)
+        {
+            return result ? PropertyCondition.Disabled : PropertyCondition.NonValid;
+        }
+    }
+}

Assets/Editor Toolbox/Editor/Drawers/ToolboxDrawers/ConditionDrawers/ShowDisabledIfAttributeDrawer.cs

@@ -1,9 +1,9 @@
 using System.Collections;
 using System.Reflection;
 
+using Unity.EditorCoroutines.Editor;
 using UnityEditor;
 using UnityEngine;
-using Unity.EditorCoroutines.Editor;
 
 namespace Toolbox.Editor.Drawers
 {
@@ -31,6 +31,43 @@ private bool IsCoroutine(MethodInfo method)
             return method.ReturnType == typeof(IEnumerator);
         }
 
+        private void CallMethods(EditorButtonAttribute attribute, Object[] targetObjects)
+        {
+            var methodInfo = ReflectionUtility.GetObjectMethod(attribute.MethodName, targetObjects);
+            //validate method name (check if method exists)
+            if (methodInfo == null)
+            {
+                ToolboxEditorLog.AttributeUsageWarning(attribute, string.Format("{0} method not found.", attribute.MethodName));
+                return;
+            }
+
+            //validate parameters count and log warning
+            var parameters = methodInfo.GetParameters();
+            if (parameters.Length > 0)
+            {
+                ToolboxEditorLog.AttributeUsageWarning(attribute, string.Format("{0} method has to be parameterless.", attribute.MethodName));
+                return;
+            }
+
+            //invoke method for all selected components
+            var isCoroutine = IsCoroutine(methodInfo);
+            for (var i = 0; i < targetObjects.Length; i++)
+            {
+                var target = targetObjects[i];
+                if (target == null)
+                {
+                    continue;
+                }
+
+                var result = methodInfo.Invoke(target, null);
+                //additionaly run Coroutine if possible
+                if (isCoroutine)
+                {
+                    EditorCoroutineUtility.StartCoroutineOwnerless((IEnumerator)result);
+                }
+            }
+        }
+
 
         protected override void OnGuiCloseSafe(EditorButtonAttribute attribute)
         {
@@ -52,39 +89,7 @@ protected override void OnGuiCloseSafe(EditorButtonAttribute attribute)
 
                 if (GUILayout.Button(content, Style.buttonStyle))
                 {
-                    var methodInfo = ReflectionUtility.GetObjectMethod(attribute.MethodName, targetObjects);
-                    //validate method name (check if method exists)
-                    if (methodInfo == null)
-                    {
-                        ToolboxEditorLog.AttributeUsageWarning(attribute, string.Format("{0} method not found.", attribute.MethodName));
-                        return;
-                    }
-
-                    //validate parameters count and log warning
-                    var parameters = methodInfo.GetParameters();
-                    if (parameters.Length > 0)
-                    {
-                        ToolboxEditorLog.AttributeUsageWarning(attribute, string.Format("{0} method has to be parameterless.", attribute.MethodName));
-                        return;
-                    }
-
-                    //invoke method for all selected components
-                    var isCoroutine = IsCoroutine(methodInfo);
-                    for (var i = 0; i < targetObjects.Length; i++)
-                    {
-                        var target = targetObjects[i];
-                        if (target == null)
-                        {
-                            continue;
-                        }
-
-                        var result = methodInfo.Invoke(target, null);
-                        //additionaly run Coroutine if possible
-                        if (isCoroutine)
-                        {
-                            EditorCoroutineUtility.StartCoroutineOwnerless((IEnumerator)result);
-                        }
-                    }
+                    CallMethods(attribute, targetObjects);
                 }
             }
         }

Assets/Editor Toolbox/Editor/Drawers/ToolboxDrawers/ConditionDrawers/ShowDisabledIfAttributeDrawer.cs.meta

@@ -0,0 +1,27 @@
+using UnityEditor;
+using UnityEngine;
+
+namespace Toolbox.Editor.Drawers
+{
+    public class IgnoreParentAttributeDrawer : ToolboxSelfPropertyDrawer<IgnoreParentAttribute>
+    {
+        protected override void OnGuiSafe(SerializedProperty property, GUIContent label, IgnoreParentAttribute attribute)
+        {
+            var targetProperty = property.Copy();
+            targetProperty.NextVisible(true);
+            //draw first child, right after the parent property
+            ToolboxEditorGui.DrawToolboxProperty(targetProperty.Copy());
+            var targetDepth = targetProperty.depth;
+            while (targetProperty.NextVisible(false))
+            {
+                if (targetProperty.depth > targetDepth)
+                {
+                    break;
+                }
+
+                //draw all children in order but only one level depth
+                ToolboxEditorGui.DrawToolboxProperty(targetProperty.Copy());
+            }
+        }
+    }
+}

Assets/Editor Toolbox/Editor/Drawers/ToolboxDrawers/DecoratorDrawers/EditorButtonAttributeDrawer.cs

@@ -124,7 +124,6 @@ protected override void OnGuiSafe(SerializedProperty property, GUIContent label,
                 }
 
                 InspectorUtility.SetIsEditorExpanded(editor, true);
-
                 //make useage of the created (cached) Editor instance
                 using (new FixedFieldsScope())
                 {