Add possibility to drag and drop reference values into arrays/lists

Author: arimger

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

@@ -12,20 +12,45 @@ internal class PropertyScope : IDisposable
     {
         private readonly SerializedProperty property;
 
+
         public PropertyScope(SerializedProperty property, GUIContent label)
         {
             this.property = property;
             var rowHeight = EditorGUIUtility.singleLineHeight;
             var labelRect = EditorGUILayout.GetControlRect(true, rowHeight);
             label = EditorGUI.BeginProperty(labelRect, label, property);
-            property.isExpanded = EditorGUI.Foldout(labelRect, property.isExpanded, label, true);
+            HandleEvents(labelRect);
+            TryDrawLabel(labelRect, label);
+        }
+
+
+        private void HandleEvents(Rect rect)
+        {
+            if (property.isArray)
+            {
+                DragAndDropUtility.DoDragAndDropForProperty(rect, property);
+            }
         }
 
+        private void TryDrawLabel(Rect rect, GUIContent label)
+        {
+            if (property.hasChildren)
+            {
+                property.isExpanded = EditorGUI.Foldout(rect, property.isExpanded, label, true);
+            }
+            else
+            {
+                EditorGUI.LabelField(rect, label);
+            }
+        }
+
+
         public void Dispose()
         {
             EditorGUI.EndProperty();
         }
 
+
         public bool IsVisible => property.isExpanded;
     }
 }

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

@@ -301,6 +301,7 @@ protected virtual bool DoListHeader(Rect headerRect)
                 }
             }
 
+            HandleHeaderEvents(headerRect);
             //apply the padding to get the internal rect
             headerRect.xMin += Style.padding;
             headerRect.xMax -= Style.padding;
@@ -397,6 +398,9 @@ protected virtual bool IsMouseInActiveElement()
             return GetCoveredElementIndex(Event.current.mousePosition.y) == Index;
         }
 
+        protected virtual void HandleHeaderEvents(Rect rect)
+        { }
+
         protected abstract int GetCoveredElementIndex(float localY);
 
         protected abstract int GetCoveredElementIndex(Vector2 mousePosition);

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

@@ -87,7 +87,7 @@ private void DrawElementRow(int index, bool isActive, bool isTarget, bool hasFoc
                 }
 
                 //create additional space between item and right margin
-                DrawEmptySpace(Style.spacing);
+                CreateSpace(Style.spacing);
             }
         }
 
@@ -133,16 +133,19 @@ private void DrawElement(int index)
         }
 
         /// <summary>
-        /// Creates empty space in a layout-based structure.
+        /// Preserves additional space for the dragging handle.
         /// </summary>
-        private void DrawEmptySpace(float space)
+        private void DrawHandleArea()
         {
-            GuiLayoutUtility.CreateSpace(space);
+            CreateSpace(Style.dragAreaWidth);
         }
 
-        private void DrawHandleArea()
+        /// <summary>
+        /// Creates empty space in a layout-based structure.
+        /// </summary>
+        private void CreateSpace(float pixels)
         {
-            DrawEmptySpace(Style.dragAreaWidth);
+            GuiLayoutUtility.CreateSpace(pixels);
         }
 
         /// <summary>
@@ -226,7 +229,7 @@ protected override void DoListMiddle(Rect middleRect)
 
             var upperPadding = Style.padding - ElementSpacing;
             var lowerPadding = Style.padding;
-            DrawEmptySpace(upperPadding);
+            CreateSpace(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++)
@@ -235,17 +238,16 @@ protected override void DoListMiddle(Rect middleRect)
                 var isActive = (i == Index);
                 var hasFocus = (i == Index && HasKeyboardFocus());
                 var isTarget = (i == lastCoveredIndex && !isActive);
-                var isEnding = (i == arraySize - 1);
 
-                DrawEmptySpace(ElementSpacing);
+                CreateSpace(ElementSpacing);
                 DrawElementRow(i, isActive, isTarget, hasFocus);
                 if (isTarget)
                 {
                     DrawTargetGap(i, Index);
                 }
             }
 
-            DrawEmptySpace(lowerPadding);
+            CreateSpace(lowerPadding);
         }
 
         protected override bool DoListHeader()
@@ -325,6 +327,12 @@ protected override int GetCoveredElementIndex(Vector2 mousePosition)
             return middleRect.Contains(mousePosition) ? GetCoveredElementIndex(mousePosition.y) : -1;
         }
 
+        protected override void HandleHeaderEvents(Rect rect)
+        {
+            base.HandleHeaderEvents(rect);
+            DragAndDropUtility.DoDragAndDropForProperty(rect, List);
+        }
+
 
         /// <inheritdoc/>
         public override void DoList()

Assets/Editor Toolbox/Editor/Utilities/DragAndDropUtility.cs

@@ -0,0 +1,100 @@
+using System;
+using System.Reflection;
+using UnityEditor;
+using UnityEngine;
+using Object = UnityEngine.Object;
+
+namespace Toolbox.Editor
+{
+    public static class DragAndDropUtility
+    {
+        static DragAndDropUtility()
+        {
+            validateAssignmentMethod = typeof(EditorGUI)
+                .GetMethod("ValidateObjectFieldAssignment",
+                BindingFlags.NonPublic | BindingFlags.Static);
+            appendFoldoutValueMethod = typeof(SerializedProperty)
+                .GetMethod("AppendFoldoutPPtrValue",
+                BindingFlags.NonPublic | BindingFlags.Instance);
+        }
+
+
+        private static readonly MethodInfo validateAssignmentMethod;
+        private static readonly MethodInfo appendFoldoutValueMethod;
+
+        private static readonly int dragAndDropHash = "customDragAndDrop".GetHashCode();
+
+
+        public static Object ValidateAssignment(Object[] references, SerializedProperty property, Type type, bool exactType)
+        {
+#if UNITY_2017_1_OR_NEWER
+            var methodParams = new object[4];
+            methodParams[3] = exactType ? 1 : 0;
+#else
+            var methodParams = new object[3];
+#endif
+            methodParams[0] = references;
+            methodParams[1] = type;
+            methodParams[2] = property;
+            return validateAssignmentMethod?.Invoke(null, methodParams) as Object;
+        }
+
+        public static void AppendDragAndDropValue(Object value, SerializedProperty property)
+        {
+            property.serializedObject.Update();
+            appendFoldoutValueMethod?.Invoke(property, new object[] { value });
+            property.serializedObject.ApplyModifiedProperties();
+        }
+
+        public static void DoDragAndDropForProperty(Rect rect, SerializedProperty property)
+        {
+            var controlId = GUIUtility.GetControlID(dragAndDropHash, FocusType.Passive, rect);
+            var currentEvent = Event.current;
+            switch (currentEvent.type)
+            {
+                case EventType.DragExited:
+                    if (GUI.enabled)
+                    {
+                        HandleUtility.Repaint();
+                    }
+
+                    break;
+                case EventType.DragUpdated:
+                case EventType.DragPerform:
+                    if (GUI.enabled && rect.Contains(currentEvent.mousePosition))
+                    {
+                        var references = DragAndDrop.objectReferences;
+                        var candidates = new Object[1];
+                        var dragAccepted = true;
+                        foreach (var o in references)
+                        {
+                            candidates[0] = o;
+                            var validatedObject = ValidateAssignment(candidates, property, null, false);
+                            if (validatedObject)
+                            {
+                                DragAndDrop.visualMode = DragAndDropVisualMode.Copy;
+                                if (currentEvent.type == EventType.DragPerform)
+                                {
+                                    AppendDragAndDropValue(validatedObject, property);
+                                    dragAccepted = true;
+                                    DragAndDrop.activeControlID = 0;
+                                }
+                                else
+                                {
+                                    DragAndDrop.activeControlID = controlId;
+                                }
+                            }
+                        }
+
+                        if (dragAccepted)
+                        {
+                            GUI.changed = true;
+                            DragAndDrop.AcceptDrag();
+                        }
+                    }
+
+                    break;
+            }
+        }
+    }
+}