Fix keyboard shortcuts not working as expected on non-QWERTY keyboard

osu.Framework.Benchmarks/BenchmarkButtonInput.cs

@@ -7,6 +7,7 @@
 using osu.Framework.Input.StateChanges.Events;
 using osu.Framework.Input.States;
 using osuTK.Input;
+using KeyboardState = osu.Framework.Input.States.KeyboardState;
 
 namespace osu.Framework.Benchmarks
 {
@@ -20,14 +21,14 @@ public class BenchmarkButtonInput
         [Benchmark]
         public KeyboardKeyInput FromTwoStates(int count)
         {
-            var state1 = new ButtonStates<Key>();
-            var state2 = new ButtonStates<Key>();
+            var state1 = new KeyboardState();
+            var state2 = new KeyboardState();
 
             for (int i = 0; i < count; i++)
-                state1.SetPressed((Key)i, true);
+                state1.Keys.SetPressed((Key)i, true);
 
             for (int i = count; i < 2 * count; i++)
-                state2.SetPressed((Key)i, true);
+                state2.Keys.SetPressed((Key)i, true);
 
             return new KeyboardKeyInput(state1, state2);
         }

osu.Framework.Tests/Input/KeyBindingInputTest.cs

@@ -60,6 +60,35 @@ public void TestReleaseAlwaysPressedToOriginalTargets()
             AddAssert("receptorBelow received release", () => receptorBelow.ReleasedReceived);
         }
 
+        [Test]
+        public void TestKeycodeBindings()
+        {
+            InputReceptor receptor = null;
+
+            AddStep("setup", () =>
+            {
+                Child = new TestKeyBindingContainer
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Children = new Drawable[]
+                    {
+                        receptor = new InputReceptor(true)
+                        {
+                            Size = new Vector2(100),
+                        },
+                    }
+                };
+            });
+
+            AddStep("move mouse to receptor", () => InputManager.MoveMouseTo(receptor));
+            AddStep("press keybind3", () => InputManager.PressKey(new KeyboardKey(Key.B, 'a')));
+            AddAssert("receptor received press", () => receptor.PressedReceived);
+
+            // simulate changing keyboard layout mid-press (not sure how valid this test is, but it doesn't hurt to cover)
+            AddStep("release keybind3 with different character", () => InputManager.ReleaseKey(new KeyboardKey(Key.B, 'b')));
+            AddAssert("receptor received release", () => receptor.ReleasedReceived);
+        }
+
         private partial class InputReceptor : Box, IKeyBindingHandler<TestKeyBinding>
         {
             public bool PressedReceived { get; private set; }
@@ -121,13 +150,15 @@ public TestKeyBindingContainer()
             {
                 new KeyBinding(InputKey.Up, TestKeyBinding.Binding1),
                 new KeyBinding(InputKey.Down, TestKeyBinding.Binding2),
+                new KeyBinding(InputKey.KeycodeA, TestKeyBinding.Binding3),
             };
         }
 
         private enum TestKeyBinding
         {
             Binding1,
-            Binding2
+            Binding2,
+            Binding3,
         }
     }
 }

osu.Framework.Tests/Input/KeyBindingKeycodeTest.cs

@@ -0,0 +1,147 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Collections.Generic;
+using System.Linq;
+using NUnit.Framework;
+using osu.Framework.Input;
+using osu.Framework.Input.Bindings;
+using osu.Framework.Testing;
+using osuTK.Input;
+
+namespace osu.Framework.Tests.Input
+{
+    [HeadlessTest]
+    public partial class KeyBindingKeycodeTest : ManualInputManagerTestScene
+    {
+        private TestKeyBindingContainer keyBindingContainer = null!;
+
+        private void create(IEnumerable<IKeyBinding> keyBindings, SimultaneousBindingMode simultaneousMode, KeyCombinationMatchingMode matchingMode)
+        {
+            AddStep("create hierarchy", () =>
+            {
+                Child = keyBindingContainer = new TestKeyBindingContainer(keyBindings, simultaneousMode, matchingMode);
+            });
+        }
+
+        [Test]
+        public void TestConflictingKeys()
+        {
+            create(test_bindings, SimultaneousBindingMode.Unique, KeyCombinationMatchingMode.Modifiers);
+
+            press(new KeyboardKey(Key.A, 'a'));
+            check(TestKeyBinding.A, TestKeyBinding.KeycodeA);
+            release(new KeyboardKey(Key.A, 'a'));
+
+            press(KeyboardKey.FromKey(Key.LControl));
+            press(new KeyboardKey(Key.A, 'a'));
+            check(TestKeyBinding.CtrlA, TestKeyBinding.CtrlKeycodeA);
+            release(new KeyboardKey(Key.A, 'a'));
+            release(KeyboardKey.FromKey(Key.LControl));
+
+            check();
+        }
+
+        [TestCase(KeyCombinationMatchingMode.Any)]
+        [TestCase(KeyCombinationMatchingMode.Exact)]
+        [TestCase(KeyCombinationMatchingMode.Modifiers)]
+        public void TestExactMode(KeyCombinationMatchingMode mode)
+        {
+            create(test_bindings, SimultaneousBindingMode.Unique, mode);
+
+            press(new KeyboardKey(Key.U, 'a'));
+            check(TestKeyBinding.KeycodeA);
+
+            release(new KeyboardKey(Key.U, 'a'));
+            check();
+        }
+
+        [TestCase('d', 'm')]
+        [TestCase('m', 'd')] // swap D and M
+        public void TestSimpleGame(char keycodeForD, char keycodeForM)
+        {
+            create(simple_game_bindings, SimultaneousBindingMode.Unique, KeyCombinationMatchingMode.Modifiers);
+
+            var keyD = new KeyboardKey(Key.D, keycodeForD);
+            var keyM = new KeyboardKey(Key.M, keycodeForM);
+
+            press(keyD);
+            if (keyD.Character == 'm')
+                check(TestKeyBinding.Right, TestKeyBinding.Map); // map is also triggered, even if the developer wouldn't expect it
+            else
+                check(TestKeyBinding.Right);
+            release(keyD);
+
+            press(keyM);
+            if (keyM.Character == 'm')
+                check(TestKeyBinding.Map);
+            else
+                check(); // empty is expected here
+            release(keyM);
+
+            var keyForMenu = keyD.Character == 'm' ? keyD : keyM;
+
+            AddAssert("keycode 'm' will be pressed", () => keyForMenu.Character == 'm');
+
+            press(KeyboardKey.FromKey(Key.ControlLeft));
+            press(keyForMenu);
+            check(TestKeyBinding.Menu); // since Menu is using modifier keys different from Up/Down/Left/Right, it'll always work as expected
+            release(keyForMenu);
+            release(KeyboardKey.FromKey(Key.ControlLeft));
+
+            check();
+        }
+
+        private void press(KeyboardKey key) => AddStep($"press {key}", () => InputManager.PressKey(key));
+        private void release(KeyboardKey key) => AddStep($"release {key}", () => InputManager.ReleaseKey(key));
+
+        private void check(params TestKeyBinding[] bindings) => AddAssert($"check {(bindings.Any() ? string.Join(", ", bindings) : "<empty>")}", () => keyBindingContainer.PressedActions, () => Is.EquivalentTo(bindings));
+
+        private partial class TestKeyBindingContainer : KeyBindingContainer<TestKeyBinding>
+        {
+            public TestKeyBindingContainer(IEnumerable<IKeyBinding> keyBindings, SimultaneousBindingMode simultaneousMode, KeyCombinationMatchingMode matchingMode)
+                : base(simultaneousMode, matchingMode)
+            {
+                DefaultKeyBindings = keyBindings;
+            }
+
+            public override IEnumerable<IKeyBinding> DefaultKeyBindings { get; }
+        }
+
+        private static readonly IEnumerable<IKeyBinding> test_bindings = new[]
+        {
+            new KeyBinding(InputKey.A, TestKeyBinding.A),
+            new KeyBinding(InputKey.KeycodeA, TestKeyBinding.KeycodeA),
+            new KeyBinding(InputKey.KeycodeB, TestKeyBinding.KeycodeB),
+            new KeyBinding(new KeyCombination(InputKey.Control, InputKey.A), TestKeyBinding.CtrlA),
+            new KeyBinding(new KeyCombination(InputKey.Control, InputKey.KeycodeA), TestKeyBinding.CtrlKeycodeA),
+        };
+
+        /// sample keybinds for a simple game that will not as expected on some layouts
+        private static readonly IEnumerable<IKeyBinding> simple_game_bindings = new[]
+        {
+            new KeyBinding(InputKey.W, TestKeyBinding.Up),
+            new KeyBinding(InputKey.A, TestKeyBinding.Left),
+            new KeyBinding(InputKey.S, TestKeyBinding.Down),
+            new KeyBinding(InputKey.D, TestKeyBinding.Right),
+            new KeyBinding(InputKey.KeycodeM, TestKeyBinding.Map),
+            new KeyBinding(new KeyCombination(InputKey.Control, InputKey.KeycodeM), TestKeyBinding.Menu),
+        };
+
+        private enum TestKeyBinding
+        {
+            A,
+            KeycodeA,
+            KeycodeB,
+            CtrlA,
+            CtrlKeycodeA,
+
+            Up,
+            Left,
+            Down,
+            Right,
+            Map,
+            Menu,
+        }
+    }
+}

osu.Framework.Tests/Input/KeyCombinationTest.cs

@@ -1,8 +1,10 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System.Collections.Generic;
 using NUnit.Framework;
 using osu.Framework.Input.Bindings;
+using osuTK.Input;
 
 namespace osu.Framework.Tests.Input
 {
@@ -46,7 +48,7 @@ public class KeyCombinationTest
 
         [TestCaseSource(nameof(key_combination_display_test_cases))]
         public void TestLeftRightModifierHandling(KeyCombination candidate, KeyCombination pressed, KeyCombinationMatchingMode matchingMode, bool shouldContain)
-            => Assert.AreEqual(shouldContain, KeyCombination.ContainsAll(candidate.Keys, pressed.Keys, matchingMode));
+            => Assert.AreEqual(shouldContain, KeyCombination.ContainsAll(candidate.Keys, pressed.Keys, matchingMode, new Dictionary<Key, char?>()));
 
         [Test]
         public void TestCreationNoDuplicates()

osu.Framework.Tests/Input/KeyboardInputTest.cs

@@ -8,6 +8,7 @@
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
+using osu.Framework.Input;
 using osu.Framework.Input.Events;
 using osu.Framework.Testing;
 using osuTK;
@@ -168,6 +169,21 @@ public void TestReValidatedDrawableReceivesRepeat()
             AddUntilStep("wait for repeat on receptor 0", () => receptors[0].RepeatReceived);
         }
 
+        [Test]
+        public void TestKeyCharacterChangingDuringPress()
+        {
+            AddStep("press key as 'a'", () => InputManager.PressKey(new KeyboardKey(Key.A, 'a')));
+
+            AddAssert("key pressed", () => InputManager.CurrentState.Keyboard.IsPressed(Key.A));
+            AddAssert("char pressed", () => InputManager.CurrentState.Keyboard.IsPressed('a'));
+
+            AddStep("release same key as 'b'", () => InputManager.ReleaseKey(new KeyboardKey(Key.A, 'b')));
+
+            AddAssert("key released", () => InputManager.CurrentState.Keyboard.IsPressed(Key.A), () => Is.False);
+            AddAssert("char 'a' not pressed", () => InputManager.CurrentState.Keyboard.IsPressed('a'), () => Is.False);
+            AddAssert("char 'b' not pressed", () => InputManager.CurrentState.Keyboard.IsPressed('b'), () => Is.False);
+        }
+
         private partial class InputReceptor : Box
         {
             public bool DownReceived { get; set; }