NEW: (ISXB-1524, ISX-2325, revisiting ISXB-1396) Fix for rebinding issues related to incorrect event suppression + Changed Rebinding Sample

Assets/Samples/InGameHints/InGameHintsActions.cs

@@ -1,7 +1,7 @@
 //------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was auto-generated by com.unity.inputsystem:InputActionCodeGenerator
-//     version 1.14.1
+//     version 1.15.0
 //     from Assets/Samples/InGameHints/InGameHintsActions.inputactions
 //
 //     Changes to this file may cause incorrect behavior and will be lost if

Assets/Samples/RebindingUI/ActionLabel.cs

@@ -0,0 +1,161 @@
+using System;
+using System.Collections.Generic;
+using UnityEngine.Events;
+using UnityEngine.UI;
+
+namespace UnityEngine.InputSystem.Samples.RebindUI
+{
+    public class ActionLabel : MonoBehaviour
+    {
+        [Tooltip("Reference to action that is to be rebound from the UI.")]
+        [SerializeField]
+        private InputActionReference m_Action;
+
+        [SerializeField]
+        private string m_BindingId;
+
+        [SerializeField]
+        private InputBinding.DisplayStringOptions m_DisplayStringOptions;
+
+        [Tooltip("Text label that will receive the current, formatted binding string.")]
+        [SerializeField]
+        private Text m_BindingText;
+
+        [Tooltip("Event that is triggered when the way the binding is display should be updated. This allows displaying "
+            + "bindings in custom ways, e.g. using images instead of text.")]
+        [SerializeField]
+        private UpdateBindingUIEvent m_UpdateBindingUIEvent;
+
+        private static List<ActionLabel> s_InputActionUIs;
+
+        /// <summary>
+        /// Reference to the action that is to be rebound.
+        /// </summary>
+        public InputActionReference actionReference
+        {
+            get => m_Action;
+            set
+            {
+                m_Action = value;
+                UpdateBindingDisplay();
+            }
+        }
+
+        /// <summary>
+        /// ID (in string form) of the binding that is to be rebound on the action.
+        /// </summary>
+        /// <seealso cref="InputBinding.id"/>
+        public string bindingId
+        {
+            get => m_BindingId;
+            set
+            {
+                m_BindingId = value;
+                UpdateBindingDisplay();
+            }
+        }
+
+        /// <summary>
+        /// Text component that receives the display string of the binding. Can be <c>null</c> in which
+        /// case the component entirely relies on <see cref="updateBindingUIEvent"/>.
+        /// </summary>
+        public Text bindingText
+        {
+            get => m_BindingText;
+            set
+            {
+                m_BindingText = value;
+                UpdateBindingDisplay();
+            }
+        }
+
+        /// <summary>
+        /// Display options for the binding.
+        /// </summary>
+        public InputBinding.DisplayStringOptions displayStringOptions
+        {
+            get => m_DisplayStringOptions;
+            set
+            {
+                m_DisplayStringOptions = value;
+                UpdateBindingDisplay();
+            }
+        }
+
+        /// <summary>
+        /// Trigger a refresh of the currently displayed binding.
+        /// </summary>
+        public void UpdateBindingDisplay()
+        {
+            var displayString = string.Empty;
+            var deviceLayoutName = default(string);
+            var controlPath = default(string);
+
+            // Get display string from action.
+            var action = m_Action?.action;
+            if (action != null)
+            {
+                var bindingIndex = action.bindings.IndexOf(x => x.id.ToString() == m_BindingId);
+                if (bindingIndex != -1)
+                    displayString = action.GetBindingDisplayString(bindingIndex, out deviceLayoutName, out controlPath, displayStringOptions);
+            }
+
+            // Set on label (if any).
+            if (m_BindingText != null)
+                m_BindingText.text = displayString;
+
+            // Give listeners a chance to configure UI in response.
+            m_UpdateBindingUIEvent?.Invoke(this, displayString, deviceLayoutName, controlPath);
+        }
+
+        protected void OnEnable()
+        {
+            if (s_InputActionUIs == null)
+                s_InputActionUIs = new List<ActionLabel>();
+            s_InputActionUIs.Add(this);
+            if (s_InputActionUIs.Count == 1)
+                InputSystem.onActionChange += OnActionChange;
+            UpdateBindingDisplay();
+        }
+
+        protected void OnDisable()
+        {
+            s_InputActionUIs.Remove(this);
+            if (s_InputActionUIs.Count == 0)
+            {
+                s_InputActionUIs = null;
+                InputSystem.onActionChange -= OnActionChange;
+            }
+        }
+
+        // When the action system re-resolves bindings, we want to update our UI in response
+        // to show the currently relevant binding.
+        private static void OnActionChange(object obj, InputActionChange change)
+        {
+            if (change != InputActionChange.BoundControlsChanged)
+                return;
+
+            var action = obj as InputAction;
+            var actionMap = action?.actionMap ?? obj as InputActionMap;
+            var actionAsset = actionMap?.asset ?? obj as InputActionAsset;
+
+            for (var i = 0; i < s_InputActionUIs.Count; ++i)
+            {
+                var component = s_InputActionUIs[i];
+                var referencedAction = component.actionReference?.action;
+                if (referencedAction == null)
+                    continue;
+
+                if (referencedAction == action ||
+                    referencedAction.actionMap == actionMap ||
+                    referencedAction.actionMap?.asset == actionAsset)
+                    component.UpdateBindingDisplay();
+            }
+        }
+    }
+
+    [Serializable]
+    public class UpdateBindingUIEvent : UnityEvent<ActionLabel, string, string, string>
+    {
+    }
+}

Assets/Samples/RebindingUI/ActionLabelEditor.cs

@@ -0,0 +1,162 @@
+#if UNITY_EDITOR
+using System.Linq;
+using UnityEditor;
+
+////TODO: support multi-object editing
+
+namespace UnityEngine.InputSystem.Samples.RebindUI
+{
+    /// <summary>
+    /// A custom inspector for <see cref="RebindActionUI"/> which provides a more convenient way for
+    /// picking the binding which to rebind.
+    /// </summary>
+    [CustomEditor(typeof(ActionLabel))]
+    public class ActionLabelEditor : UnityEditor.Editor
+    {
+        protected void OnEnable()
+        {
+            m_ActionProperty = serializedObject.FindProperty("m_Action");
+            m_BindingIdProperty = serializedObject.FindProperty("m_BindingId");
+            m_BindingTextProperty = serializedObject.FindProperty("m_BindingText");
+            m_DisplayStringOptionsProperty = serializedObject.FindProperty("m_DisplayStringOptions");
+            m_UpdateBindingUIEventProperty = serializedObject.FindProperty("m_UpdateBindingUIEvent");
+
+            RefreshBindingOptions();
+        }
+
+        public override void OnInspectorGUI()
+        {
+            EditorGUI.BeginChangeCheck();
+
+            // Binding section.
+            EditorGUILayout.LabelField(m_BindingLabel, Styles.boldLabel);
+            using (new EditorGUI.IndentLevelScope())
+            {
+                EditorGUILayout.PropertyField(m_ActionProperty);
+
+                var newSelectedBinding = EditorGUILayout.Popup(m_BindingLabel, m_SelectedBindingOption, m_BindingOptions);
+                if (newSelectedBinding != m_SelectedBindingOption)
+                {
+                    var bindingId = m_BindingOptionValues[newSelectedBinding];
+                    m_BindingIdProperty.stringValue = bindingId;
+                    m_SelectedBindingOption = newSelectedBinding;
+                }
+
+                var optionsOld = (InputBinding.DisplayStringOptions)m_DisplayStringOptionsProperty.intValue;
+                var optionsNew = (InputBinding.DisplayStringOptions)EditorGUILayout.EnumFlagsField(m_DisplayOptionsLabel, optionsOld);
+                if (optionsOld != optionsNew)
+                    m_DisplayStringOptionsProperty.intValue = (int)optionsNew;
+            }
+
+            // UI section.
+            EditorGUILayout.Space();
+            EditorGUILayout.LabelField(m_UILabel, Styles.boldLabel);
+            using (new EditorGUI.IndentLevelScope())
+            {
+                EditorGUILayout.PropertyField(m_BindingTextProperty);
+            }
+
+            // Events section.
+            EditorGUILayout.Space();
+            EditorGUILayout.LabelField(m_EventsLabel, Styles.boldLabel);
+            using (new EditorGUI.IndentLevelScope())
+            {
+                EditorGUILayout.PropertyField(m_UpdateBindingUIEventProperty);
+            }
+
+            if (EditorGUI.EndChangeCheck())
+            {
+                serializedObject.ApplyModifiedProperties();
+                RefreshBindingOptions();
+            }
+        }
+
+        protected void RefreshBindingOptions()
+        {
+            var actionReference = (InputActionReference)m_ActionProperty.objectReferenceValue;
+            var action = actionReference?.action;
+
+            if (action == null)
+            {
+                m_BindingOptions = new GUIContent[0];
+                m_BindingOptionValues = new string[0];
+                m_SelectedBindingOption = -1;
+                return;
+            }
+
+            var bindings = action.bindings;
+            var bindingCount = bindings.Count;
+
+            m_BindingOptions = new GUIContent[bindingCount];
+            m_BindingOptionValues = new string[bindingCount];
+            m_SelectedBindingOption = -1;
+
+            var currentBindingId = m_BindingIdProperty.stringValue;
+            for (var i = 0; i < bindingCount; ++i)
+            {
+                var binding = bindings[i];
+                var bindingId = binding.id.ToString();
+                var haveBindingGroups = !string.IsNullOrEmpty(binding.groups);
+
+                // If we don't have a binding groups (control schemes), show the device that if there are, for example,
+                // there are two bindings with the display string "A", the user can see that one is for the keyboard
+                // and the other for the gamepad.
+                var displayOptions =
+                    InputBinding.DisplayStringOptions.DontUseShortDisplayNames | InputBinding.DisplayStringOptions.IgnoreBindingOverrides;
+                if (!haveBindingGroups)
+                    displayOptions |= InputBinding.DisplayStringOptions.DontOmitDevice;
+
+                // Create display string.
+                var displayString = action.GetBindingDisplayString(i, displayOptions);
+
+                // If binding is part of a composite, include the part name.
+                if (binding.isPartOfComposite)
+                    displayString = $"{ObjectNames.NicifyVariableName(binding.name)}: {displayString}";
+
+                // Some composites use '/' as a separator. When used in popup, this will lead to to submenus. Prevent
+                // by instead using a backlash.
+                displayString = displayString.Replace('/', '\\');
+
+                // If the binding is part of control schemes, mention them.
+                if (haveBindingGroups)
+                {
+                    var asset = action.actionMap?.asset;
+                    if (asset != null)
+                    {
+                        var controlSchemes = string.Join(", ",
+                            binding.groups.Split(InputBinding.Separator)
+                                .Select(x => asset.controlSchemes.FirstOrDefault(c => c.bindingGroup == x).name));
+
+                        displayString = $"{displayString} ({controlSchemes})";
+                    }
+                }
+
+                m_BindingOptions[i] = new GUIContent(displayString);
+                m_BindingOptionValues[i] = bindingId;
+
+                if (currentBindingId == bindingId)
+                    m_SelectedBindingOption = i;
+            }
+        }
+
+        private SerializedProperty m_ActionProperty;
+        private SerializedProperty m_BindingIdProperty;
+        private SerializedProperty m_BindingTextProperty;
+        private SerializedProperty m_UpdateBindingUIEventProperty;
+        private SerializedProperty m_DisplayStringOptionsProperty;
+
+        private GUIContent m_BindingLabel = new GUIContent("Binding");
+        private GUIContent m_DisplayOptionsLabel = new GUIContent("Display Options");
+        private GUIContent m_UILabel = new GUIContent("UI");
+        private GUIContent m_EventsLabel = new GUIContent("Events");
+        private GUIContent[] m_BindingOptions;
+        private string[] m_BindingOptionValues;
+        private int m_SelectedBindingOption;
+
+        private static class Styles
+        {
+            public static GUIStyle boldLabel = new GUIStyle("MiniBoldLabel");
+        }
+    }
+}
+#endif

Assets/Samples/RebindingUI/CanvasGroupModifier.cs

@@ -0,0 +1,51 @@
+using UnityEngine.EventSystems;
+
+namespace UnityEngine.InputSystem.Samples.RebindUI
+{
+    /// <summary>
+    /// Simple utility that modifies a referenced CanvasGroup while being active.
+    /// </summary>
+    public class CanvasGroupModifier : MonoBehaviour
+    {
+        [Tooltip("The Canvas Group to be modified while this component is active")]
+        public CanvasGroup canvasGroup;
+
+        [Tooltip("The interactable setting to use for the Canvas Group while this component is active")]
+        public bool interactable = false;
+
+        private bool m_SavedInteractable;
+        private GameObject m_SelectedObject;
+
+        private void OnEnable()
+        {
+            if (canvasGroup != null)
+            {
+                // Store selection to make sure it is not changed when switching "windows".
+                m_SelectedObject = EventSystem.current.currentSelectedGameObject;
+
+                // Save current setting and override
+                m_SavedInteractable = canvasGroup.interactable;
+                canvasGroup.interactable = interactable;
+            }
+        }
+
+        private void OnDisable()
+        {
+            if (canvasGroup != null)
+            {
+                // Restore previous setting.
+                canvasGroup.interactable = m_SavedInteractable;
+
+                // Restore previous selection.
+                var eventSystem = EventSystem.current;
+                if (eventSystem != null)
+                {
+                    if (m_SelectedObject != null)
+                        eventSystem.SetSelectedGameObject(m_SelectedObject);
+                    else if (EventSystem.current.currentSelectedGameObject == null)
+                        eventSystem.SetSelectedGameObject(eventSystem.firstSelectedGameObject);
+                }
+            }
+        }
+    }
+}