Merge pull request #52 from arimger/develop

Develop - 0.11.7

Author: arimger

Assets/Editor Toolbox/CHANGELOG.md

@@ -1,3 +1,13 @@
+## 0.11.7 [04.09.2022]
+
+### Added:
+- Possibility to force default (built-in) behaviour for arrays/list
+
+### Changed:
+- Improvements to EditorButton labels
+- Improvements to type fields while drawing [ReferencePicker]-based properties
+- Types returned by the TypeUtilities can now be sorted (additional property for the TypeConstraintContext class)
+
 ## 0.11.5 [18.08.2022]
 
 ### Added:

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

@@ -53,6 +53,7 @@ private void UpdateConstraint(TypeConstraintAttribute attribute)
             sharedConstraint.ApplyTarget(attribute.AssemblyType);
             if (sharedConstraint is TypeConstraintStandard constraint)
             {
+                constraint.IsOrdered = attribute.OrderTypes;
                 constraint.AllowAbstract = attribute.AllowAbstract;
                 constraint.AllowObsolete = attribute.AllowObsolete;
                 constraint.Settings = attribute.TypeSettings;

Assets/Editor Toolbox/Editor/Drawers/Toolbox/Decorator/EditorButtonAttributeDrawer.cs

@@ -82,7 +82,7 @@ protected override void OnGuiCloseSafe(EditorButtonAttribute attribute)
             using (new EditorGUI.DisabledScope(disable))
             {
                 var label = string.IsNullOrEmpty(attribute.ExtraLabel)
-                            ? attribute.MethodName
+                            ? ObjectNames.NicifyVariableName(attribute.MethodName)
                             : attribute.ExtraLabel;
                 var tooltip = attribute.Tooltip;
                 var content = new GUIContent(label, tooltip);

Assets/Editor Toolbox/Editor/Drawers/Toolbox/PropertySelf/ReferencePickerAttributeDrawer.cs

@@ -10,6 +10,9 @@ namespace Toolbox.Editor.Drawers
 
     public class ReferencePickerAttributeDrawer : ToolboxSelfPropertyDrawer<ReferencePickerAttribute>
     {
+        private const float neededLabelWidth = 100.0f;
+        private const float labelWidthOffset = -80.0f;
+
         private static readonly TypeConstraintContext sharedConstraint = new TypeConstraintReference(null);
         private static readonly TypeAppearanceContext sharedAppearance = new TypeAppearanceContext(sharedConstraint, TypeGrouping.None, true);
         private static readonly TypeField typeField = new TypeField(sharedConstraint, sharedAppearance);
@@ -20,11 +23,27 @@ private void UpdateContexts(ReferencePickerAttribute attribute)
             sharedAppearance.TypeGrouping = attribute.TypeGrouping;
         }
 
-        private void CreateTypeProperty(SerializedProperty property, Type parentType)
+        private Type GetParentType(SerializedProperty property, ReferencePickerAttribute attribute)
+        {
+            property.GetFieldInfo(out Type propertyType);
+            var candidateType = attribute.ParentType;
+            if (candidateType != null)
+            {
+                if (propertyType.IsAssignableFrom(candidateType))
+                {
+                    return candidateType;
+                }
+
+                ToolboxEditorLog.AttributeUsageWarning(attribute, property,
+                    $"Provided {nameof(attribute.ParentType)} ({candidateType}) cannot be used because it's not assignable from: '{propertyType}'");
+            }
+
+            return propertyType;
+        }
+
+        private void CreateTypeProperty(Rect position, SerializedProperty property, Type parentType)
         {
             TypeUtilities.TryGetTypeFromManagedReferenceFullTypeName(property.managedReferenceFullTypename, out var currentType);
-            var position = EditorGUILayout.GetControlRect(false, EditorGUIUtility.singleLineHeight);
-            position = EditorGUI.IndentedRect(position);
             typeField.OnGui(position, true, (type) =>
             {
                 try
@@ -61,39 +80,48 @@ private void UpdateTypeProperty(SerializedProperty property, Type referenceType)
             property.serializedObject.ApplyModifiedProperties();
         }
 
-        private Type GetParentType(SerializedProperty property, ReferencePickerAttribute attribute)
+        private Rect PrepareTypePropertyPosition(in Rect labelPosition, in Rect inputPosition, bool isPropertyExpanded)
         {
-            property.GetFieldInfo(out Type propertyType);
-            var candidateType = attribute.ParentType;
-            if (candidateType != null)
+            var position = new Rect(inputPosition);
+            var baseLabelWidth = EditorGUIUtility.labelWidth + labelWidthOffset;
+            var realLabelWidth = labelPosition.width;
+            var labelWidth = Mathf.Max(baseLabelWidth, realLabelWidth);
+            if (isPropertyExpanded)
             {
-                if (propertyType.IsAssignableFrom(candidateType))
+                //property is expanded and we have place to move it to the next row
+                if (labelWidth < neededLabelWidth)
                 {
-                    return candidateType;
+                    position = EditorGUILayout.GetControlRect(false, EditorGUIUtility.singleLineHeight);
+                    position = EditorGUI.IndentedRect(position);
+                    return position;
                 }
-
-                ToolboxEditorLog.AttributeUsageWarning(attribute, property,
-                    $"Provided {nameof(attribute.ParentType)} ({candidateType}) cannot be used because it's not assignable from: '{propertyType}'");
             }
 
-            return propertyType;
+            //adjust position to already rendered label
+            position.xMin += labelWidth;
+            return position;
         }
 
+
         protected override void OnGuiSafe(SerializedProperty property, GUIContent label, ReferencePickerAttribute attribute)
         {
             using (var propertyScope = new PropertyScope(property, label))
             {
-                if (!propertyScope.IsVisible)
-                {
-                    return;
-                }
-
                 UpdateContexts(attribute);
-                var parentType = GetParentType(property, attribute);
 
+                var isPropertyExpanded = propertyScope.IsVisible;
                 EditorGUI.indentLevel++;
-                CreateTypeProperty(property, parentType);
-                ToolboxEditorGui.DrawPropertyChildren(property);
+                var labelRect = propertyScope.LabelRect;
+                var inputRect = propertyScope.InputRect;
+                var position = PrepareTypePropertyPosition(in labelRect, in inputRect, isPropertyExpanded);
+
+                var parentType = GetParentType(property, attribute);
+                CreateTypeProperty(position, property, parentType);
+                if (isPropertyExpanded)
+                {
+                    ToolboxEditorGui.DrawPropertyChildren(property);
+                }
+
                 EditorGUI.indentLevel--;
             }
         }

Assets/Editor Toolbox/Editor/Internal/PropertyScope.cs

@@ -17,9 +17,9 @@ internal class PropertyScope : IDisposable
         public PropertyScope(SerializedProperty property, GUIContent label)
         {
             this.property = property;
-            ToolboxEditorGui.BeginProperty(property, ref label, out var labelRect);
-            HandleEvents(labelRect);
-            TryDrawLabel(labelRect, label);
+            ToolboxEditorGui.BeginProperty(property, ref label, out var rect);
+            HandleEvents(rect);
+            TryDrawLabel(rect, label);
         }
 
 
@@ -33,8 +33,14 @@ private void HandleEvents(Rect rect)
 
         private void TryDrawLabel(Rect rect, GUIContent label)
         {
+            LabelRect = rect;
+            InputRect = rect;
             if (property.hasChildren)
             {
+                var size = EditorStyles.label.CalcSize(label);
+                size.x = Mathf.Max(EditorGuiUtility.FoldoutOffset, size.x);
+                rect.xMax = rect.xMin + size.x;
+                LabelRect = rect;
                 property.isExpanded = EditorGUI.Foldout(rect, property.isExpanded, label, true);
             }
             else
@@ -51,5 +57,7 @@ public void Dispose()
 
 
         public bool IsVisible => property.isExpanded;
+        public Rect LabelRect { get; private set; }
+        public Rect InputRect { get; private set; }
     }
-}
+}

Assets/Editor Toolbox/Editor/Internal/TypeConstraintContext.cs

@@ -32,16 +32,21 @@ public virtual void ApplyTarget(Type type)
 
         public override bool Equals(object obj)
         {
-            return obj is TypeConstraintContext constraint &&
-                   EqualityComparer<Type>.Default.Equals(targetType, constraint.targetType);
+            return obj is TypeConstraintContext context &&
+                   EqualityComparer<Type>.Default.Equals(TargetType, context.TargetType) &&
+                   IsOrdered == context.IsOrdered;
         }
 
         public override int GetHashCode()
         {
-            return 1673078848 + EqualityComparer<Type>.Default.GetHashCode(targetType);
+            var hashCode = -509589530;
+            hashCode = hashCode * -1521134295 + EqualityComparer<Type>.Default.GetHashCode(TargetType);
+            hashCode = hashCode * -1521134295 + IsOrdered.GetHashCode();
+            return hashCode;
         }
 
 
         public Type TargetType => targetType;
+        public bool IsOrdered { get; set; } = true;
     }
 }

Assets/Editor Toolbox/Editor/ToolboxDefines.cs

@@ -0,0 +1,7 @@
+namespace Toolbox.Editor
+{
+    internal static class ToolboxDefines
+    {
+        internal const string defaultListsDefine = "TOOLBOX_FORCE_DEFAULT_LISTS";
+    }
+}

Assets/Editor Toolbox/Editor/ToolboxDefines.cs.meta

@@ -10,6 +10,11 @@ namespace Toolbox.Editor
 {
     using Toolbox.Editor.Drawers;
 
+    //TODO:
+    //1. dedicated class to initialize and hold drawer-related data
+    //2. dedicated class used for settings initialization
+    //3. separate logic for resettings active drawers
+
     internal static class ToolboxDrawerModule
     {
         [InitializeOnLoadMethod]
@@ -244,6 +249,7 @@ internal static void UpdateDrawers(IToolboxInspectorSettings settings)
             //create all type-only-related drawers
             PrepareTargetTypeDrawers(settings);
 
+            HandleDefaultLists(settings.ForceDefaultLists);
             //log errors into console only once
             validationEnabled = false;
         }
@@ -268,6 +274,18 @@ internal static bool HasTargetTypeDrawer(Type type)
             return targetTypeDrawers.ContainsKey(type.IsGenericType ? type.GetGenericTypeDefinition() : type);
         }
 
+        internal static void HandleDefaultLists(bool value)
+        {
+            if (value)
+            {
+                ScriptingUtility.AppendDefine(ToolboxDefines.defaultListsDefine);
+            }
+            else
+            {
+                ScriptingUtility.RemoveDefine(ToolboxDefines.defaultListsDefine);
+            }
+        }
+
         internal static ToolboxDecoratorDrawerBase GetDecoratorDrawer<T>(T attribute) where T : ToolboxDecoratorAttribute
         {
             return GetDecoratorDrawer(attribute.GetType());
@@ -412,7 +430,7 @@ internal static ToolboxPropertyHandler GetPropertyHandler(SerializedProperty pro
 
         //TODO:
         //NOTE: unfortunately there is no valid, non-reflection way to check if property has a custom native drawer
-        private readonly static MethodInfo getDrawerTypeForTypeMethod =
+        private static readonly MethodInfo getDrawerTypeForTypeMethod =
             ReflectionUtility.GetEditorMethod("UnityEditor.ScriptAttributeUtility", "GetDrawerTypeForType",
                 BindingFlags.NonPublic | BindingFlags.Static);
     }

Assets/Editor Toolbox/Editor/ToolboxDrawerModule.cs

@@ -43,6 +43,7 @@ internal interface IToolboxInspectorSettings
         void SetAllPossibleTargetTypeDrawers();
 
         bool UseToolboxDrawers { get; }
+        bool ForceDefaultLists { get; }
 
         List<SerializedType> DecoratorDrawerHandlers { get; }
         List<SerializedType> ConditionDrawerHandlers { get; }
@@ -81,8 +82,11 @@ internal class ToolboxEditorSettings : ScriptableObject, IToolboxGeneralSettings
         [SerializeField, ReorderableList(ListStyle.Boxed)]
         private List<FolderData> customFolders = new List<FolderData>();
 
-        [SerializeField]
+        [SerializeField, Tooltip("Set to false if you don't want to use Toolbox attributes and related features.")]
         private bool useToolboxDrawers = true;
+        [SerializeField, Tooltip("By default, Inspectors will use the built-in version of the list instead of the Toolbox-based one. " +
+            "Keep in mind that built-in properties don't support Toolbox attributes. \n\n Changing this property will recompile the code.")]
+        private bool forceDefaultLists;
 
         [SerializeField, ReorderableList(ListStyle.Boxed), ClassExtends(typeof(ToolboxDecoratorDrawer<>))]
         private List<SerializedType> decoratorDrawerHandlers = new List<SerializedType>();
@@ -327,6 +331,12 @@ public bool UseToolboxDrawers
             set => useToolboxDrawers = value;
         }
 
+        public bool ForceDefaultLists 
+        { 
+            get => forceDefaultLists; 
+            set => forceDefaultLists = value; 
+        }
+
         public List<SerializedType> DecoratorDrawerHandlers
         {
             get => decoratorDrawerHandlers;
@@ -357,7 +367,6 @@ public List<SerializedType> TargetTypeDrawerHandlers
             set => targetTypeDrawerHandlers = value;
         }
 
-
         private static class Defaults
         {
             internal const float largeFolderIconScaleDefault = 0.8f;