UITK drag and drop (ISX-1141)

Packages/com.unity.inputsystem/CHANGELOG.md

@@ -21,6 +21,7 @@ however, it has to be formatted properly to pass verification tests.
   - [`InputAction.WasCompletedThisFrame`](xref:UnityEngine.InputSystem.InputAction.WasCompletedThisFrame) returns `true` on the frame that the action stopped being in the performed phase. This allows for similar functionality to [`WasPressedThisFrame`](xref:UnityEngine.InputSystem.InputAction.WasPressedThisFrame)/[`WasReleasedThisFrame`](xref:UnityEngine.InputSystem.InputAction.WasReleasedThisFrame) when paired with [`WasPerformedThisFrame`](xref:UnityEngine.InputSystem.InputAction.WasPerformedThisFrame) except it is directly based on the interactions driving the action. For example, you can use it to distinguish between the button being released or whether it was released after being held for long enough to perform when using the Hold interaction.
 - Added Copy, Paste and Cut support for Action Maps, Actions and Bindings via context menu and key command shortcuts.
 - Added Dual Sense Edge controller to be mapped to the same layout as the Dual Sense controller
+- Added drag and drop support in the Input Action Asset Editor for Action Maps, Actions and Bindings.
 
 ### Fixed
 - Fixed syntax of code examples in API documentation for [`AxisComposite`](xref:UnityEngine.InputSystem.Composites.AxisComposite).

Packages/com.unity.inputsystem/InputSystem/Editor/Internal/InputActionSerializationHelpers.cs

@@ -148,6 +148,24 @@ public static void DeleteActionMap(SerializedObject asset, Guid id)
             mapArrayProperty.DeleteArrayElementAtIndex(mapIndex);
         }
 
+        public static void MoveActionMap(SerializedObject asset, int fromIndex, int toIndex)
+        {
+            var mapArrayProperty = asset.FindProperty("m_ActionMaps");
+            mapArrayProperty.MoveArrayElement(fromIndex, toIndex);
+        }
+
+        public static void MoveAction(SerializedProperty actionMap, int fromIndex, int toIndex)
+        {
+            var actionArrayProperty = actionMap.FindPropertyRelative(nameof(InputActionMap.m_Actions));
+            actionArrayProperty.MoveArrayElement(fromIndex, toIndex);
+        }
+
+        public static void MoveBinding(SerializedProperty actionMap, int fromIndex, int toIndex)
+        {
+            var arrayProperty = actionMap.FindPropertyRelative(nameof(InputActionMap.m_Bindings));
+            arrayProperty.MoveArrayElement(fromIndex, toIndex);
+        }
+
         // Append a new action to the end of the set.
         public static SerializedProperty AddAction(SerializedProperty actionMap, int index = -1)
         {

Packages/com.unity.inputsystem/InputSystem/Editor/UITKAssetEditor/Commands/Commands.cs

@@ -149,6 +149,17 @@ public static Command PasteActionMaps()
             };
         }
 
+        public static Command PasteActionIntoActionMap(int actionMapIndex)
+        {
+            return (in InputActionsEditorState state) =>
+            {
+                var lastPastedElement = CopyPasteHelper.PasteActionsOrBindingsFromClipboard(state, true, actionMapIndex);
+                if (lastPastedElement != null)
+                    state.serializedObject.ApplyModifiedProperties();
+                return state;
+            };
+        }
+
         public static Command PasteActionFromActionMap()
         {
             return (in InputActionsEditorState state) =>
@@ -230,6 +241,117 @@ private static InputActionsEditorState SelectPrevActionMap(InputActionsEditorSta
             return state.SelectActionMap(index);
         }
 
+        public static Command ReorderActionMap(int oldIndex, int newIndex)
+        {
+            return (in InputActionsEditorState state) =>
+            {
+                InputActionSerializationHelpers.MoveActionMap(state.serializedObject, oldIndex, newIndex);
+                state.serializedObject.ApplyModifiedProperties();
+                return state.SelectActionMap(newIndex);
+            };
+        }
+
+        public static Command MoveAction(int oldIndex, int newIndex)
+        {
+            return (in InputActionsEditorState state) =>
+            {
+                var actionMap = Selectors.GetSelectedActionMap(state)?.wrappedProperty;
+                InputActionSerializationHelpers.MoveAction(actionMap, oldIndex, newIndex);
+                state.serializedObject.ApplyModifiedProperties();
+                return state.SelectAction(newIndex);
+            };
+        }
+
+        public static Command MoveBinding(int oldIndex, int actionIndex, int childIndex)
+        {
+            return (in InputActionsEditorState state) =>
+            {
+                var newBindingIndex = MoveBindingOrComposite(state, oldIndex, actionIndex, childIndex);
+                state.serializedObject.ApplyModifiedProperties();
+                return state.SelectBinding(newBindingIndex);
+            };
+        }
+
+        public static Command MoveComposite(int oldIndex, int actionIndex, int childIndex)
+        {
+            return (in InputActionsEditorState state) =>
+            {
+                var actionMap = Selectors.GetSelectedActionMap(state)?.wrappedProperty;
+                var compositeBindings = CopyPasteHelper.GetBindingsForComposite(actionMap?.FindPropertyRelative(nameof(InputActionMap.m_Bindings)), oldIndex);
+                //move the composite element
+                var newBindingIndex = MoveBindingOrComposite(state, oldIndex, actionIndex, childIndex);
+                var actionTo = Selectors.GetActionForIndex(actionMap, actionIndex).FindPropertyRelative(nameof(InputAction.m_Name)).stringValue;
+                var toIndex = newBindingIndex;
+                foreach (var compositePart in compositeBindings)
+                {
+                    // the index of the composite part stays the same if composite was moved down as previous elements are shifted down (the index seems to update async so it's safer to use the oldIndex)
+                    // if the composite was moved up, the index of the composite part is not changing so we are safe to use it
+                    var from = oldIndex < newBindingIndex ? oldIndex : compositePart.GetIndexOfArrayElement();
+                    // if added below the old position the array changes as composite parts are added on top (increase the index)
+                    // if added above the oldIndex, the index does not change
+                    var to = oldIndex < newBindingIndex ? newBindingIndex : ++toIndex;
+                    InputActionSerializationHelpers.MoveBinding(actionMap, from, to);
+                    Selectors.GetCompositeOrBindingInMap(actionMap, to).wrappedProperty.FindPropertyRelative("m_Action").stringValue = actionTo;
+                }
+                state.serializedObject.ApplyModifiedProperties();
+                return state.SelectBinding(newBindingIndex);
+            };
+        }
+
+        private static int MoveBindingOrComposite(InputActionsEditorState state, int oldIndex, int actionIndex, int childIndex)
+        {
+            var actionMap = Selectors.GetSelectedActionMap(state)?.wrappedProperty;
+            var bindingsForAction = Selectors.GetBindingsForAction(state, actionMap, actionIndex);
+            var allBindings = actionMap?.FindPropertyRelative(nameof(InputActionMap.m_Bindings));
+            var actionTo = Selectors.GetActionForIndex(actionMap, actionIndex).FindPropertyRelative(nameof(InputAction.m_Name)).stringValue;
+            var actionFrom = Selectors.GetCompositeOrBindingInMap(actionMap, oldIndex).wrappedProperty.FindPropertyRelative("m_Action");
+            int newBindingIndex;
+            if (bindingsForAction.Count == 0) //if there are no bindings for an action retrieve the first binding index of a binding before (iterate previous actions)
+                newBindingIndex = Selectors.GetBindingIndexBeforeAction(allBindings, actionIndex, allBindings);
+            else
+            {
+                var toSkip = GetNumberOfCompositePartItemsToSkip(bindingsForAction, childIndex, oldIndex); //skip composite parts if there are - avoid moving into a composite
+                newBindingIndex = bindingsForAction[0].GetIndexOfArrayElement() + Math.Clamp(childIndex + toSkip, 0, bindingsForAction.Count);
+                newBindingIndex -= newBindingIndex > oldIndex && !actionTo.Equals(actionFrom.stringValue) ? 1 : 0; // reduce index by one in case the moved binding will be shifted underneath to another action
+            }
+
+            actionFrom.stringValue = actionTo;
+            InputActionSerializationHelpers.MoveBinding(actionMap, oldIndex, newBindingIndex);
+            return newBindingIndex;
+        }
+
+        private static int GetNumberOfCompositePartItemsToSkip(List<SerializedProperty> bindings, int childIndex, int oldIndex)
+        {
+            var toSkip = 0;
+            var normalBindings = 0;
+            foreach (var binding in bindings)
+            {
+                if (binding.GetIndexOfArrayElement() == oldIndex)
+                    continue;
+                if (normalBindings > childIndex)
+                    break;
+                if (binding.FindPropertyRelative(nameof(InputBinding.m_Flags)).intValue ==
+                    (int)InputBinding.Flags.PartOfComposite)
+                    toSkip++;
+                else
+                    normalBindings++;
+            }
+            return toSkip;
+        }
+
+        public static Command MovePartOfComposite(int oldIndex, int newIndex, int compositeIndex)
+        {
+            return (in InputActionsEditorState state) =>
+            {
+                var actionMap = Selectors.GetSelectedActionMap(state)?.wrappedProperty;
+                var actionTo = actionMap?.FindPropertyRelative(nameof(InputActionMap.m_Bindings)).GetArrayElementAtIndex(compositeIndex).FindPropertyRelative("m_Action").stringValue;
+                InputActionSerializationHelpers.MoveBinding(actionMap, oldIndex, newIndex);
+                Selectors.GetCompositeOrBindingInMap(actionMap, newIndex).wrappedProperty.FindPropertyRelative("m_Action").stringValue = actionTo;
+                state.serializedObject.ApplyModifiedProperties();
+                return state.SelectBinding(newIndex);
+            };
+        }
+
         public static Command DeleteAction(int actionMapIndex, string actionName)
         {
             return (in InputActionsEditorState state) =>

Packages/com.unity.inputsystem/InputSystem/Editor/UITKAssetEditor/Views/ActionMapsView.cs

@@ -17,7 +17,7 @@ public ActionMapsView(VisualElement root, StateContainer stateContainer)
         {
             m_ListView = root.Q<ListView>("action-maps-list-view");
             m_ListView.selectionType = UIElements.SelectionType.Single;
-
+            m_ListView.reorderable = true;
             m_ListViewSelectionChangeFilter = new CollectionViewSelectionChangeFilter(m_ListView);
             m_ListViewSelectionChangeFilter.selectedIndicesChanged += (selectedIndices) =>
             {
@@ -34,6 +34,7 @@ public ActionMapsView(VisualElement root, StateContainer stateContainer)
                 treeViewItem.DuplicateCallback = _ => DuplicateActionMap(i);
                 treeViewItem.OnDeleteItem += treeViewItem.DeleteCallback;
                 treeViewItem.OnDuplicateItem += treeViewItem.DuplicateCallback;
+                treeViewItem.userData = i;
 
                 ContextMenu.GetContextMenuForActionMapItem(treeViewItem);
             };
@@ -55,6 +56,10 @@ public ActionMapsView(VisualElement root, StateContainer stateContainer)
 
             m_ListView.RegisterCallback<ExecuteCommandEvent>(OnExecuteCommand);
             m_ListView.RegisterCallback<ValidateCommandEvent>(OnValidateCommand);
+            var treeView = root.Q<TreeView>("actions-tree-view");
+            m_ListView.AddManipulator(new DropManipulator(OnDroppedHandler, treeView));
+            m_ListView.itemIndexChanged += OnReorder;
+
 
             CreateSelector(s => new ViewStateCollection<string>(Selectors.GetActionMapNames(s)),
                 (actionMapNames, state) => new ViewState(Selectors.GetSelectedActionMap(state), actionMapNames));
@@ -64,6 +69,17 @@ public ActionMapsView(VisualElement root, StateContainer stateContainer)
             ContextMenu.GetContextMenuForActionMapListView(this, m_ListView.parent);
         }
 
+        void OnDroppedHandler(int mapIndex)
+        {
+            Dispatch(Commands.CutActionsOrBindings());
+            Dispatch(Commands.PasteActionIntoActionMap(mapIndex));
+        }
+
+        void OnReorder(int oldIndex, int newIndex)
+        {
+            Dispatch(Commands.ReorderActionMap(oldIndex, newIndex));
+        }
+
         public override void RedrawUI(ViewState viewState)
         {
             m_ListView.itemsSource = viewState.actionMapNames?.ToList() ?? new List<string>();