Merge pull request #12 from techno-dwarf-works/feature/extensions

Version 0.0.9

Editor/CustomEditors/Base/ExtendedEditor.cs

@@ -1,6 +1,5 @@
 using UnityEditor;
 using UnityEngine;
-using UnityEngine.UIElements;
 
 namespace Better.Commons.EditorAddons.CustomEditors.Base
 {
@@ -23,21 +22,20 @@ protected ExtendedEditor(Object target, SerializedObject serializedObject)
         /// This method called just right after instance created
         /// </summary>
         public abstract void OnEnable();
-
+        
         /// <summary>
         /// Use to draw your inspector
         /// </summary>
-        public abstract VisualElement CreateInspectorGUI();
-
+        public abstract void OnInspectorGUI();
+        
         /// <summary>
         /// This method called than editor disables
         /// </summary>
         public abstract void OnDisable();
-
+        
         /// <summary>
         /// Called when object data in editor is changed
         /// </summary>
-        /// <param name="serializedObject"></param>
-        public abstract void OnChanged(SerializedObject serializedObject);
+        public abstract void OnChanged();
     }
 }

Editor/CustomEditors/MultiEditor.cs

@@ -7,8 +7,6 @@
 using Better.Commons.EditorAddons.Extensions;
 using Better.Commons.Runtime.Extensions;
 using UnityEditor;
-using UnityEditor.UIElements;
-using UnityEngine.UIElements;
 using Object = UnityEngine.Object;
 
 namespace Better.Commons.EditorAddons.CustomEditors
@@ -92,47 +90,35 @@ private void Iterate(IReadOnlyList<(Type type, MultiEditorAttribute)> extensions
             }
         }
 
-        public override VisualElement CreateInspectorGUI()
+        public override void OnInspectorGUI()
         {
-            var container = new VisualElement();
-
-            for (var i = 0; i < _preEditors.Count; i++)
+            using (var change = new EditorGUI.ChangeCheckScope())
             {
-                var element = _preEditors[i].CreateInspectorGUI();
-                if (element != null)
+                for (var i = 0; i < _preEditors.Count; i++)
                 {
-                    container.Add(element);
+                    _preEditors[i].OnInspectorGUI();
                 }
-            }
-
-            if (!_overrideDefault)
-            {
-                InspectorElement.FillDefaultInspector(container, serializedObject, this);
-            }
 
-            for (var i = 0; i < _postEditors.Count; i++)
-            {
-                var element = _postEditors[i].CreateInspectorGUI();
-                if (element != null)
+                if (!_overrideDefault)
                 {
-                    container.Add(element);
+                    base.OnInspectorGUI();
                 }
-            }
 
-            container.TrackSerializedObjectValue(serializedObject, OnSerializedObjectTrack);
-            return container;
-        }
+                for (var i = 0; i < _postEditors.Count; i++)
+                {
+                    _postEditors[i].OnInspectorGUI();
+                }
 
-        private void OnSerializedObjectTrack(SerializedObject serializedObject)
-        {
-            for (var i = 0; i < _preEditors.Count; i++)
-            {
-                _preEditors[i].OnChanged(serializedObject);
-            }
+                if (!change.changed) return;
+                for (var i = 0; i < _preEditors.Count; i++)
+                {
+                    _preEditors[i].OnChanged();
+                }
 
-            for (var i = 0; i < _postEditors.Count; i++)
-            {
-                _postEditors[i].OnChanged(serializedObject);
+                for (var i = 0; i < _postEditors.Count; i++)
+                {
+                    _postEditors[i].OnChanged();
+                }
             }
         }
 

Editor/Drawers/Base/FieldDrawer.cs

@@ -10,19 +10,92 @@ public abstract class FieldDrawer
     {
         protected readonly FieldInfo _fieldInfo;
         protected readonly MultiPropertyAttribute _attribute;
+        protected FieldDrawer _nextDrawer;
 
         protected FieldDrawer(FieldInfo fieldInfo, MultiPropertyAttribute attribute)
         {
+            Selection.selectionChanged += OnSelectionChanged;
             _fieldInfo = fieldInfo;
             _attribute = attribute;
         }
 
-        public virtual void Initialize()
+        ~FieldDrawer()
         {
+            EditorApplication.update += DeconstructOnMainThread;
         }
 
-        protected internal abstract void Deconstruct();
+        public virtual void Initialize(FieldDrawer drawer)
+        {
+            _nextDrawer = drawer;
+        }
+
+        private void DeconstructOnMainThread()
+        {
+            EditorApplication.update -= DeconstructOnMainThread;
+            Selection.selectionChanged -= OnSelectionChanged;
+            Deconstruct();
+        }
+
+        private void OnSelectionChanged()
+        {
+            Selection.selectionChanged -= OnSelectionChanged;
+            Deconstruct();
+        }
+
+        protected abstract void Deconstruct();
+
+        protected virtual void DrawField(Rect position, SerializedProperty property, GUIContent label)
+        {
+            var buffer = PreparePropertyRect(position);
+            EditorGUI.PropertyField(buffer, property, label, true);
+        }
+
+        internal void DrawFieldInternal(Rect position, SerializedProperty property, GUIContent label)
+        {
+            if (_nextDrawer != null)
+            {
+                _nextDrawer.DrawFieldInternal(position, property, label);
+                return;
+            }
+
+            DrawField(position, property, label);
+        }
+
+        internal bool PreDrawInternal(ref Rect position, SerializedProperty property, GUIContent label)
+        {
+            if (_nextDrawer != null)
+            {
+                return PreDraw(ref position, property, label) && _nextDrawer.PreDrawInternal(ref position, property, label);
+            }
+
+            return PreDraw(ref position, property, label);
+        }
+
+        internal void PostDrawInternal(Rect position, SerializedProperty property, GUIContent label)
+        {
+            _nextDrawer?.PostDrawInternal(position, property, label);
+            PostDraw(position, property, label);
+        }
 
-        protected internal abstract void PopulateContainer(ElementsContainer container);
+        internal HeightCacheValue GetPropertyHeightInternal(SerializedProperty property, GUIContent label)
+        {
+            var propertyHeight = GetPropertyHeight(property, label);
+            if (_nextDrawer != null)
+            {
+                var heightInternal = _nextDrawer.GetPropertyHeightInternal(property, label);
+                return propertyHeight + heightInternal;
+            }
+
+            return propertyHeight;
+        }
+
+        protected abstract bool PreDraw(ref Rect position, SerializedProperty property, GUIContent label);
+        protected abstract Rect PreparePropertyRect(Rect original);
+        protected abstract void PostDraw(Rect position, SerializedProperty property, GUIContent label);
+
+        protected virtual HeightCacheValue GetPropertyHeight(SerializedProperty property, GUIContent label)
+        {
+            return HeightCacheValue.GetFull(EditorGUI.GetPropertyHeight(property, label, true));
+        }
     }
 }

Editor/Drawers/Base/MultiFieldDrawer.cs

@@ -9,13 +9,13 @@
 
 namespace Better.Commons.EditorAddons.Drawers.Base
 {
-    public abstract class MultiFieldDrawer<T> : FieldDrawer where T : SerializedPropertyHandler
+    public abstract class MultiFieldDrawer<T> : FieldDrawer where T : UtilityWrapper
     {
         private static readonly CacheValue CacheValueField = new CacheValue();
 
-        protected HandlerCollection<T> _handlers;
+        protected WrapperCollection<T> _wrappers;
 
-        protected class CacheValue : CacheValue<CollectionValue<T>>
+        protected class CacheValue : CacheValue<WrapperCollectionValue<T>>
         {
         }
 
@@ -24,20 +24,20 @@ protected MultiFieldDrawer(FieldInfo fieldInfo, MultiPropertyAttribute attribute
         }
 
         /// <summary>
-        /// Method generates explicit typed collection inherited from <see cref="HandlerCollection{T}"/> 
+        /// Method generates explicit typed collection inherited from <see cref="WrapperCollection{T}"/> 
         /// </summary>
         /// <returns></returns>
-        protected abstract HandlerCollection<T> GenerateCollection();
+        protected abstract WrapperCollection<T> GenerateCollection();
 
-        public override void Initialize()
+        public override void Initialize(FieldDrawer drawer)
         {
-            base.Initialize();
-            _handlers = GenerateCollection();
+            base.Initialize(drawer);
+            _wrappers = GenerateCollection();
         }
 
-        protected internal override void Deconstruct()
+        protected override void Deconstruct()
         {
-            _handlers?.Deconstruct();
+            _wrappers.Deconstruct();
         }
 
         protected virtual Type GetFieldOrElementType()
@@ -50,16 +50,16 @@ protected virtual Type GetFieldOrElementType()
         }
 
         /// <summary>
-        /// Validates if <see cref="_handlers"/> contains property by <see cref="SerializedPropertyComparer"/>
+        /// Validates if <see cref="_wrappers"/> contains property by <see cref="SerializedPropertyComparer"/>
         /// </summary>
-        /// <param name="property">SerializedProperty what will be stored into <see cref="_handlers"/></param>
-        /// <param name="handler"><see cref="HandlerMap{THandler}"/> used to validate current stored wrappers and gets instance for recently added property</param>
+        /// <param name="property">SerializedProperty what will be stored into <see cref="_wrappers"/></param>
+        /// <param name="handler"><see cref="BaseUtility{THandler}"/> used to validate current stored wrappers and gets instance for recently added property</param>
         /// <typeparam name="THandler"></typeparam>
-        /// <returns>Returns true if wrapper for <paramref name="property"/> was already stored into <see cref="_handlers"/></returns>
-        protected CacheValue ValidateCachedProperties<THandler>(SerializedProperty property, HandlerMap<THandler> handler)
-            where THandler : HandlerMap<THandler>, new()
+        /// <returns>Returns true if wrapper for <paramref name="property"/> was already stored into <see cref="_wrappers"/></returns>
+        protected CacheValue ValidateCachedProperties<THandler>(SerializedProperty property, BaseUtility<THandler> handler)
+            where THandler : new()
         {
-            ValidateCachedPropertiesUtility.Validate(_handlers, CacheValueField, property, GetFieldOrElementType(), _attribute.GetType(), handler);
+            ValidateCachedPropertiesUtility.Validate(_wrappers, CacheValueField, property, GetFieldOrElementType(), _attribute.GetType(), handler);
             return CacheValueField;
         }
     }

Editor/Drawers/Base/HandlerCollection.cs → Editor/Drawers/Base/WrapperCollection.cs

@@ -5,10 +5,10 @@
 
 namespace Better.Commons.EditorAddons.Drawers.Base
 {
-    public class HandlerCollection<T> : Dictionary<SerializedProperty, CollectionValue<T>>
-        where T : SerializedPropertyHandler
+    public class WrapperCollection<T> : Dictionary<SerializedProperty, WrapperCollectionValue<T>>
+        where T : UtilityWrapper
     {
-        public HandlerCollection() : base(SerializedPropertyComparer.Instance)
+        public WrapperCollection() : base(SerializedPropertyComparer.Instance)
         {
         }
 

Editor/Drawers/Base/CollectionValue.cs → Editor/Drawers/Base/WrapperCollectionValue.cs

@@ -3,9 +3,9 @@
 
 namespace Better.Commons.EditorAddons.Drawers.Base
 {
-    public class CollectionValue<T> where T : SerializedPropertyHandler
+    public class WrapperCollectionValue<T> where T : UtilityWrapper
     {
-        public CollectionValue(T wrapper, Type type)
+        public WrapperCollectionValue(T wrapper, Type type)
         {
             Wrapper = wrapper;
             Type = type;