Minor refactor changes

Author: arimger

Assets/Editor Toolbox/Editor/Internal/ReorderableListBase.cs

@@ -882,6 +882,8 @@ protected static class Style
             internal static readonly float sizeAreaWidth = 19.0f;
             internal static readonly float minEmptyHeight = 8.0f;
 
+            internal static readonly Color selectionColor = new Color(0.3f, 0.47f, 0.75f);
+
             internal static readonly GUIContent sizePropertyContent;
             internal static readonly GUIContent iconToolbarAddContent;
             internal static readonly GUIContent iconToolbarDropContent;

Assets/Editor Toolbox/Editor/Internal/ToolboxEditorList.cs

@@ -6,8 +6,6 @@
 
 namespace Toolbox.Editor.Internal
 {
-    using Toolbox.Editor.Drawers;
-
     /// <summary>
     /// Version of the <see cref="ReorderableList"/> dedicated for <see cref="ToolboxDrawer"/>s.
     /// Can be used only together with the internal layouting system.
@@ -75,61 +73,65 @@ private void DrawElementRow(int index, bool isActive, bool isTarget, bool hasFoc
                 var elementRowRect = elementRowGroup.rect;
                 var isSelected = isActive || isTarget;
                 elementsRects[index] = elementRowRect;
-                //draw element background (handle selection and targeting)
-                if (drawElementBackgroundCallback != null)
-                {
-                    drawElementBackgroundCallback(elementRowRect, index, isSelected, hasFocus);
-                }
-                else
-                {
-                    DrawStandardElementBackground(elementRowRect, index, isSelected, hasFocus, Draggable);
-                }
-
-                //prepare handle-related properties
-                var handleRect = GetHandleRect(elementRowRect);
-                var drawHandle = !IsDragging;
-                //draw handles only for static array or currently dragged element
-                if (isSelected && IsDragging)
-                {
-                    drawHandle = true;
-                    handleRect = GetHandleRect(draggedY);
-                }
-
-                if (drawHandle)
-                {
-                    if (drawElementHandleCallback != null)
-                    {
-                        drawElementHandleCallback(handleRect, index, isActive, hasFocus);
-                    }
-                    else
-                    {
-                        DrawStandardElementHandle(handleRect, index, isActive, hasFocus, Draggable);
-                    }
-                }
 
+                DrawElementBackground(elementRowRect, index, isSelected, hasFocus);
+                DrawElementDragHandle(elementRowRect, index, isSelected, hasFocus);
                 //draw the real property in separate vertical group
                 using (var elementGroup = new EditorGUILayout.VerticalScope(Style.contentGroupStyle))
                 {
                     var elementRect = elementGroup.rect;
                     //adjust label width to the known dragging area
                     EditorGUIUtility.labelWidth -= Style.dragAreaWidth;
-                    if (drawElementCallback != null)
-                    {
-                        drawElementCallback(elementRect, index, isActive, hasFocus);
-                    }
-                    else
-                    {
-                        DrawStandardElement(elementRect, index, isActive, hasFocus, Draggable);
-                    }
-
+                    DrawElement(index);
                     EditorGUIUtility.labelWidth += Style.dragAreaWidth;
                 }
 
-                //create additional space between element and right margin
+                //create additional space between item and right margin
                 DrawEmptySpace(Style.spacing);
             }
         }
 
+        private void DrawElementBackground(Rect rect, int index, bool isSelected, bool hasFocus)
+        {
+            if (drawElementBackgroundCallback != null)
+            {
+                drawElementBackgroundCallback(rect, index, isSelected, hasFocus);
+            }
+            else
+            {
+                DrawStandardElementBackground(rect, index, isSelected, hasFocus, Draggable);
+            }
+        }
+
+        private void DrawElementDragHandle(Rect rect, int index, bool isSelected, bool hasFocus)
+        {
+            DrawHandleArea();
+            //draw handles only for static array or currently dragged element
+            if (IsDragging && !isSelected)
+            {
+                return;
+            }
+
+            var handleRect = IsDragging
+                ? GetHandleRect(draggedY)
+                : GetHandleRect(rect);
+            if (drawElementHandleCallback != null)
+            {
+                drawElementHandleCallback(handleRect, index, isSelected, hasFocus);
+            }
+            else
+            {
+                DrawStandardElementHandle(handleRect, index, isSelected, hasFocus, Draggable);
+            }
+        }
+
+        private void DrawElement(int index)
+        {
+            var element = List.GetArrayElementAtIndex(index);
+            var content = GetElementContent(element, index);
+            ToolboxEditorGui.DrawToolboxProperty(element, content);
+        }
+
         /// <summary>
         /// Creates empty space in a layout-based structure.
         /// </summary>
@@ -138,14 +140,18 @@ private void DrawEmptySpace(float space)
             GuiLayoutUtility.CreateSpace(space);
         }
 
+        private void DrawHandleArea()
+        {
+            DrawEmptySpace(Style.dragAreaWidth);
+        }
+
         /// <summary>
         /// Creates empty space for the dragging area and returns adjusted <see cref="Rect"/>.
         /// </summary>
         private Rect GetHandleRect(Rect rowRect)
         {
             var handleRect = new Rect(rowRect);
             handleRect.xMax = handleRect.xMin + Style.dragAreaWidth;
-            DrawEmptySpace(Style.dragAreaWidth);
             return handleRect;
         }
 
@@ -171,26 +177,15 @@ private Rect GetHandleRect(float draggedY)
         /// <summary>
         /// Creates small, colored rect to visualize the dragging target (gap between elements).
         /// </summary>
-        private Rect DrawTargetGap(int targetIndex, int draggingIndex, Color color, float width, float margin)
+        private void DrawTargetGap(int targetIndex, int draggingIndex)
         {
-            //TODO: refactor + custom texture/method for the gap
-            var targetsRect = elementsRects[targetIndex];
-            var rect = new Rect(targetsRect);
-            //handle differently situation above and under target
-            if (targetIndex < draggingIndex)
-            {
-                rect.yMax = rect.yMin;
-                rect.yMin = rect.yMax - width;
-            }
-            else
-            {
-                rect.yMin = rect.yMax;
-                rect.yMax = rect.yMin + width;
-            }
-
-            rect.xMin += margin;
-            EditorGUI.DrawRect(rect, color);
-            return rect;
+            var rect = elementsRects[targetIndex];
+            rect.yMax = targetIndex < draggingIndex
+                      ? rect.yMin
+                      : rect.yMax + Style.spacing;
+            rect.yMin = rect.yMax - Style.spacing;
+            rect.xMin += Style.dragAreaWidth;
+            EditorGUI.DrawRect(rect, Style.selectionColor);
         }
 
 
@@ -229,7 +224,9 @@ protected override void DoListMiddle(Rect middleRect)
                 return;
             }
 
-            DrawEmptySpace(Style.padding);
+            var upperPadding = Style.padding - ElementSpacing;
+            var lowerPadding = Style.padding;
+            DrawEmptySpace(upperPadding);
             //if there are elements, we need to draw them - we will do
             //this differently depending on if we are dragging or not
             for (var i = 0; i < arraySize; i++)
@@ -240,25 +237,15 @@ protected override void DoListMiddle(Rect middleRect)
                 var isTarget = (i == lastCoveredIndex && !isActive);
                 var isEnding = (i == arraySize - 1);
 
-                //draw current array element
+                DrawEmptySpace(ElementSpacing);
                 DrawElementRow(i, isActive, isTarget, hasFocus);
-
-                //draw dragging element gap
                 if (isTarget)
                 {
-                    DrawTargetGap(i, Index, GapColor, GapWidth, Style.dragAreaWidth);
-                }
-
-                if (isEnding)
-                {
-                    continue;
+                    DrawTargetGap(i, Index);
                 }
-
-                //create spacing for elements
-                DrawEmptySpace(ElementSpacing);
             }
 
-            DrawEmptySpace(Style.padding);
+            DrawEmptySpace(lowerPadding);
         }
 
         protected override bool DoListHeader()
@@ -339,18 +326,6 @@ protected override int GetCoveredElementIndex(Vector2 mousePosition)
         }
 
 
-        #region Methods: Default interaction/draw calls
-
-        /// <inheritdoc/>
-        public override void DrawStandardElement(Rect rect, int index, bool selected, bool focused, bool draggable)
-        {
-            var element = List.GetArrayElementAtIndex(index);
-            var content = GetElementContent(element, index);
-            ToolboxEditorGui.DrawToolboxProperty(element, content);
-        }
-
-        #endregion
-
         /// <inheritdoc/>
         public override void DoList()
         {
@@ -380,9 +355,5 @@ public Rect LastFooterRect
         {
             get => footerRect;
         }
-
-        public Color GapColor { get; set; } = new Color(0.3f, 0.47f, 0.75f);
-
-        public float GapWidth { get; set; } = 2.0f;
     }
 }

Assets/Editor Toolbox/Editor/Utilities/InspectorUtility.cs

@@ -138,7 +138,7 @@ internal static void SimulateOnValidate(Object target)
 
     internal static partial class InspectorUtility
     {
-        private static List<Component> copiedComponents = new List<Component>();
+        private static readonly List<Component> copiedComponents = new List<Component>();
 
 
         [MenuItem("CONTEXT/Component/Copy Components", false, priority = 200)]

Assets/Editor Toolbox/Editor/Utilities/PropertyUtility.cs

@@ -193,8 +193,8 @@ internal static void SetProperValue(this SerializedProperty property, FieldInfo
                     fieldInfo.SetValue(targetParent, value);
                 }
 
-                EnsureOnValidateBroadcast(targetObject, callOnValidate);
-                EnsureTargetSerialization(targetObject);
+                ForceOnValidateBroadcast(targetObject, callOnValidate);
+                ForceTargetSerialization(targetObject);
             }
         }
 
@@ -388,17 +388,17 @@ internal static void EnsureReflectionSafeness(SerializedProperty property)
             }
         }
 
-        internal static void EnsureTargetSerialization(Object targetObject)
+        internal static void ForceTargetSerialization(Object targetObject)
         {
             if (AssetDatabase.Contains(targetObject))
             {
                 EditorUtility.SetDirty(targetObject);
             }
         }
 
-        internal static void EnsureOnValidateBroadcast(Object targetObject, bool callNeeded)
+        internal static void ForceOnValidateBroadcast(Object targetObject, bool isForced)
         {
-            if (callNeeded)
+            if (isForced)
             {
                 InspectorUtility.SimulateOnValidate(targetObject);
             }