attempt at removing uielements dependency

Assets/Tests/InputSystem.Editor/ControlSchemeEditorTests.cs

@@ -43,7 +43,7 @@ public void RemoveRequirementCommand_RemovesDeviceRequirements()
         var state = TestData.editorState.Generate().With(selectedControlScheme: controlScheme);
 
 
-        var newState = ControlSchemeCommands.RemoveDeviceRequirement(0)(in state);
+        var newState = UnityEngine.InputSystem.Editor.ControlSchemeCommands.RemoveDeviceRequirement(0)(in state);
 
 
         Assert.That(newState.selectedControlScheme.deviceRequirements.Count, Is.EqualTo(1));

Assets/Tests/InputSystem.Editor/Unity.InputSystem.Tests.Editor.asmdef

@@ -5,6 +5,7 @@
         "UnityEngine.TestRunner",
         "UnityEditor.TestRunner",
         "Unity.InputSystem",
+        "Unity.InputSystem.Editor",
         "Unity.InputSystem.TestFramework"
     ],
     "includePlatforms": [

Assets/Tests/InputSystem/CoreTests_Editor.cs

@@ -23,6 +23,7 @@
 using UnityEngine.InputSystem.Users;
 using UnityEngine.InputSystem.Utilities;
 using UnityEngine.TestTools;
+using UnityEditor.InputSystem.Interactions;
 
 #pragma warning disable CS0649
 partial class CoreTests

Assets/Tests/InputSystem/Unity.InputSystem.Tests.asmdef

@@ -3,14 +3,16 @@
     "rootNamespace": "",
     "references": [
         "Unity.InputSystem",
+        "Unity.InputSystem.Editor",
         "Unity.InputSystem.TestFramework",
         "Unity.ugui",
         "Unity.PackageManagerDocTools.Editor",
         "UnityEngine.TestRunner",
         "UnityEditor.TestRunner",
         "Unity.PerformanceTesting",
         "Unity.Coding.Editor",
-        "Unity.InputSystem.ForUI"
+        "Unity.InputSystem.ForUI",
+        "Unity.InputSystem.ForUI.Editor"
     ],
     "includePlatforms": [],
     "excludePlatforms": [],

Packages/com.unity.inputsystem/Editor/Actions/AxisCompositeEditor.cs

@@ -0,0 +1,48 @@
+
+using UnityEngine;
+using UnityEngine.InputSystem.Composites;
+#if UNITY_EDITOR
+using System;
+using UnityEditor;
+using UnityEngine.InputSystem.Editor;
+using UnityEngine.UIElements;
+#endif
+
+namespace UnityEditor.InputSystem.Composites {
+#if UNITY_EDITOR
+    internal class AxisCompositeEditor : InputParameterEditor<AxisComposite>
+    {
+        private GUIContent m_WhichAxisWinsLabel = new GUIContent("Which Side Wins",
+            "Determine which axis 'wins' if both are actuated at the same time. "
+            + "If 'Neither' is selected, the result is 0 (or, more precisely, "
+            + "the midpoint between minValue and maxValue).");
+
+        public override void OnGUI()
+        {
+#if UNITY_INPUT_SYSTEM_PROJECT_WIDE_ACTIONS
+            if (!UnityEngine.InputSystem.InputSystem.settings.useIMGUIEditorForAssets) return;
+#endif
+            target.whichSideWins = (AxisComposite.WhichSideWins)EditorGUILayout.EnumPopup(m_WhichAxisWinsLabel, target.whichSideWins);
+        }
+
+#if UNITY_INPUT_SYSTEM_PROJECT_WIDE_ACTIONS
+        public override void OnDrawVisualElements(VisualElement root, Action onChangedCallback)
+        {
+            var modeField = new EnumField(m_WhichAxisWinsLabel.text, target.whichSideWins)
+            {
+                tooltip = m_WhichAxisWinsLabel.tooltip
+            };
+
+            modeField.RegisterValueChangedCallback(evt =>
+            {
+                target.whichSideWins = (AxisComposite.WhichSideWins)evt.newValue;
+                onChangedCallback();
+            });
+
+            root.Add(modeField);
+        }
+
+#endif
+    }
+    #endif
+}

Packages/com.unity.inputsystem/Editor/Actions/Interactions/HoldInteractionEditor.cs

@@ -0,0 +1,52 @@
+
+using System;
+using UnityEngine.InputSystem.Controls;
+using UnityEngine.InputSystem.Interactions;
+#if UNITY_EDITOR
+using UnityEngine.InputSystem.Editor;
+using UnityEngine.UIElements;
+#endif
+
+namespace UnityEditor.InputSystem.Interactions
+{
+    #if UNITY_EDITOR
+    /// <summary>
+    /// UI that is displayed when editing <see cref="HoldInteraction"/> in the editor.
+    /// </summary>
+    internal class HoldInteractionEditor : InputParameterEditor<HoldInteraction>
+    {
+        protected override void OnEnable()
+        {
+            m_PressPointSetting.Initialize("Press Point",
+                "Float value that an axis control has to cross for it to be considered pressed.",
+                "Default Button Press Point",
+                () => target.pressPoint, v => target.pressPoint = v, () => ButtonControl.s_GlobalDefaultButtonPressPoint);
+            m_DurationSetting.Initialize("Hold Time",
+                "Time (in seconds) that a control has to be held in order for it to register as a hold.",
+                "Default Hold Time",
+                () => target.duration, x => target.duration = x, () => UnityEngine.InputSystem.InputSystem.settings.defaultHoldTime);
+        }
+
+        public override void OnGUI()
+        {
+#if UNITY_INPUT_SYSTEM_PROJECT_WIDE_ACTIONS
+            if (!UnityEngine.InputSystem.InputSystem.settings.useIMGUIEditorForAssets) return;
+#endif
+            m_PressPointSetting.OnGUI();
+            m_DurationSetting.OnGUI();
+        }
+
+#if UNITY_INPUT_SYSTEM_PROJECT_WIDE_ACTIONS
+        public override void OnDrawVisualElements(VisualElement root, Action onChangedCallback)
+        {
+            m_PressPointSetting.OnDrawVisualElements(root, onChangedCallback);
+            m_DurationSetting.OnDrawVisualElements(root, onChangedCallback);
+        }
+
+#endif
+
+        private CustomOrDefaultSetting m_PressPointSetting;
+        private CustomOrDefaultSetting m_DurationSetting;
+    }
+    #endif
+}

Packages/com.unity.inputsystem/Editor/Actions/Interactions/MultiTapInteractionEditor.cs

@@ -0,0 +1,79 @@
+
+using System;
+using UnityEngine;
+using UnityEngine.InputSystem.Interactions;
+#if UNITY_EDITOR
+using UnityEditor;
+using UnityEngine.InputSystem.Editor;
+using UnityEngine.UIElements;
+using UnityEditor.UIElements;
+#endif
+
+namespace UnityEditor.InputSystem.Interactions {
+
+    #if UNITY_EDITOR
+    /// <summary>
+    /// UI that is displayed when editing <see cref="HoldInteraction"/> in the editor.
+    /// </summary>
+    internal class MultiTapInteractionEditor : InputParameterEditor<MultiTapInteraction>
+    {
+        protected override void OnEnable()
+        {
+            m_TapTimeSetting.Initialize("Max Tap Duration",
+                "Time (in seconds) within with a control has to be released again for it to register as a tap. If the control is held "
+                + "for longer than this time, the tap is canceled.",
+                "Default Tap Time",
+                () => target.tapTime, x => target.tapTime = x, () => UnityEngine.InputSystem.InputSystem.settings.defaultTapTime);
+            m_TapDelaySetting.Initialize("Max Tap Spacing",
+                "The maximum delay (in seconds) allowed between each tap. If this time is exceeded, the multi-tap is canceled.",
+                "Default Tap Spacing",
+                () => target.tapDelay, x => target.tapDelay = x, () => UnityEngine.InputSystem.InputSystem.settings.multiTapDelayTime);
+            m_PressPointSetting.Initialize("Press Point",
+                "The amount of actuation a control requires before being considered pressed. If not set, default to "
+                + "'Default Button Press Point' in the global input settings.",
+                "Default Button Press Point",
+                () => target.pressPoint, v => target.pressPoint = v,
+                () => UnityEngine.InputSystem.InputSystem.settings.defaultButtonPressPoint);
+        }
+
+        public override void OnGUI()
+        {
+#if UNITY_INPUT_SYSTEM_PROJECT_WIDE_ACTIONS
+            if (!UnityEngine.InputSystem.InputSystem.settings.useIMGUIEditorForAssets) return;
+#endif
+            target.tapCount = EditorGUILayout.IntField(m_TapCountLabel, target.tapCount);
+            m_TapDelaySetting.OnGUI();
+            m_TapTimeSetting.OnGUI();
+            m_PressPointSetting.OnGUI();
+        }
+
+#if UNITY_INPUT_SYSTEM_PROJECT_WIDE_ACTIONS
+        public override void OnDrawVisualElements(VisualElement root, Action onChangedCallback)
+        {
+            var tapCountField = new IntegerField(m_TapCountLabel.text)
+            {
+                value = target.tapCount,
+                tooltip = m_TapCountLabel.tooltip
+            };
+            tapCountField.RegisterValueChangedCallback(evt =>
+            {
+                target.tapCount = evt.newValue;
+                onChangedCallback?.Invoke();
+            });
+            root.Add(tapCountField);
+
+            m_TapDelaySetting.OnDrawVisualElements(root, onChangedCallback);
+            m_TapTimeSetting.OnDrawVisualElements(root, onChangedCallback);
+            m_PressPointSetting.OnDrawVisualElements(root, onChangedCallback);
+        }
+
+#endif
+
+        private readonly GUIContent m_TapCountLabel = new GUIContent("Tap Count", "How many taps need to be performed in succession. Two means double-tap, three means triple-tap, and so on.");
+
+        private CustomOrDefaultSetting m_PressPointSetting;
+        private CustomOrDefaultSetting m_TapTimeSetting;
+        private CustomOrDefaultSetting m_TapDelaySetting;
+    }
+    #endif
+}

Packages/com.unity.inputsystem/Editor/Actions/Interactions/PressInteractionEditor.cs

@@ -0,0 +1,74 @@
+
+using System;
+using UnityEngine;
+using UnityEngine.InputSystem.Interactions;
+#if UNITY_EDITOR
+using UnityEditor;
+using UnityEngine.InputSystem.Editor;
+using UnityEngine.UIElements;
+using UnityEditor.UIElements;
+#endif
+
+namespace UnityEditor.InputSystem.Interactions {
+
+    #if UNITY_EDITOR
+    /// <summary>
+    /// UI that is displayed when editing <see cref="PressInteraction"/> in the editor.
+    /// </summary>
+    // ReSharper disable once UnusedMember.Global
+    internal class PressInteractionEditor : InputParameterEditor<PressInteraction>
+    {
+        protected override void OnEnable()
+        {
+            m_PressPointSetting.Initialize("Press Point",
+                "The amount of actuation a control requires before being considered pressed. If not set, default to "
+                + "'Default Button Press Point' in the global input settings.",
+                "Default Button Press Point",
+                () => target.pressPoint, v => target.pressPoint = v,
+                () => UnityEngine.InputSystem.InputSystem.settings.defaultButtonPressPoint);
+        }
+
+        public override void OnGUI()
+        {
+#if UNITY_INPUT_SYSTEM_PROJECT_WIDE_ACTIONS
+            if (!UnityEngine.InputSystem.InputSystem.settings.useIMGUIEditorForAssets) return;
+#endif
+            EditorGUILayout.HelpBox(s_HelpBoxText);
+            target.behavior = (PressBehavior)EditorGUILayout.EnumPopup(s_PressBehaviorLabel, target.behavior);
+            m_PressPointSetting.OnGUI();
+        }
+
+#if UNITY_INPUT_SYSTEM_PROJECT_WIDE_ACTIONS
+        public override void OnDrawVisualElements(VisualElement root, Action onChangedCallback)
+        {
+            root.Add(new HelpBox(s_HelpBoxText.text, HelpBoxMessageType.None));
+
+            var behaviourDropdown = new EnumField(s_PressBehaviorLabel.text, target.behavior)
+            {
+                tooltip = s_PressBehaviorLabel.tooltip
+            };
+            behaviourDropdown.RegisterValueChangedCallback(evt =>
+            {
+                target.behavior = (PressBehavior)evt.newValue;
+                onChangedCallback?.Invoke();
+            });
+            root.Add(behaviourDropdown);
+
+            m_PressPointSetting.OnDrawVisualElements(root, onChangedCallback);
+        }
+
+#endif
+
+        private CustomOrDefaultSetting m_PressPointSetting;
+
+        private static readonly GUIContent s_HelpBoxText = EditorGUIUtility.TrTextContent("Note that the 'Press' interaction is only "
+            + "necessary when wanting to customize button press behavior. For default press behavior, simply set the action type to 'Button' "
+            + "and use the action without interactions added to it.");
+
+        private static readonly GUIContent s_PressBehaviorLabel = EditorGUIUtility.TrTextContent("Trigger Behavior",
+            "Determines how button presses trigger the action. By default (PressOnly), the action is performed on press. "
+            + "With ReleaseOnly, the action is performed on release. With PressAndRelease, the action is performed on press and "
+            + "canceled on release.");
+    }
+    #endif
+}