Merge branch 'master' into overlay-dont-block-scroll

osu.Framework.Tests/Input/KeyCombinationTest.cs

···
             new object[] { new KeyCombination(InputKey.LAlt, InputKey.F4), "LAlt-F4" },
             new object[] { new KeyCombination(InputKey.D, InputKey.LControl), "LCtrl-D" },
             new object[] { new KeyCombination(InputKey.LShift, InputKey.F, InputKey.LControl), "LCtrl-LShift-F" },
-            new object[] { new KeyCombination(InputKey.LAlt, InputKey.LControl, InputKey.LSuper, InputKey.LShift), "LCtrl-LAlt-LShift-LWin" }
+            new object[] { new KeyCombination(InputKey.LAlt, InputKey.LControl, InputKey.LSuper, InputKey.LShift), "LCtrl-LAlt-LShift-LWin" },
+            new object[] { new KeyCombination(InputKey.Alt, InputKey.LAlt, InputKey.RControl, InputKey.A), "RCtrl-LAlt-A" },
+            new object[] { new KeyCombination(InputKey.Shift, InputKey.LControl, InputKey.X), "LCtrl-Shift-X" },
+            new object[] { new KeyCombination(InputKey.Control, InputKey.Shift, InputKey.Alt, InputKey.Super, InputKey.LAlt, InputKey.RShift, InputKey.LSuper), "Ctrl-LAlt-RShift-LWin" },
         };
 
         [TestCaseSource(nameof(key_combination_display_test_cases))]

osu.Framework/Extensions/Color4Extensions/Color4Extensions.cs

···
         /// </summary>
         /// <param name="colour">Original colour</param>
         /// <param name="scalar">A scalar to multiply with</param>
-        /// <returns></returns>
         public static Color4 Multiply(this Color4 colour, float scalar)
         {
             if (scalar < 0)
···
         /// <param name="h">The hue, between 0 and 360.</param>
         /// <param name="s">The saturation, between 0 and 1.</param>
         /// <param name="v">The value, between 0 and 1.</param>
-        /// <returns></returns>
         public static Color4 FromHSV(float h, float s, float v)
         {
             if (h < 0 || h > 360)

osu.Framework/Extensions/ExtensionMethods.cs

···
         /// </summary>
         /// <param name="dictionary">The dictionary.</param>
         /// <param name="lookup">The lookup key.</param>
-        /// <returns></returns>
         public static TValue GetOrDefault<TKey, TValue>(this Dictionary<TKey, TValue> dictionary, TKey lookup) => dictionary.TryGetValue(lookup, out TValue outVal) ? outVal : default;
 
         /// <summary>

osu.Framework/Extensions/TypeExtensions/TypeExtensions.cs

···
         /// Return every base type until (and excluding) <see cref="object"/>
         /// </summary>
         /// <param name="t"></param>
-        /// <returns></returns>
         public static IEnumerable<Type> EnumerateBaseTypes(this Type t)
         {
             while (t != null && t != typeof(object))

osu.Framework/Graphics/Colour4.cs

···
         /// The final alpha is clamped to the 0-1 range.
         /// </summary>
         /// <param name="scalar">The value that the existing alpha will be multiplied by.</param>
-        /// <returns></returns>
         public Colour4 MultiplyAlpha(float scalar)
         {
             if (scalar < 0)

osu.Framework/Graphics/Containers/ScrollContainer.cs

···
         /// </summary>
         /// <param name="position">The value to clamp.</param>
         /// <param name="extension">An extension value beyond the normal extent.</param>
-        /// <returns></returns>
         protected float Clamp(float position, float extension = 0) => Math.Max(Math.Min(position, ScrollableExtent + extension), -extension);
 
         protected override Container<T> Content => ScrollContent;

osu.Framework/Graphics/Lines/SmoothPath.cs

···
         /// Retrieves the colour from a position in the texture of the <see cref="Path"/>.
         /// </summary>
         /// <param name="position">The position within the texture. 0 indicates the outermost-point of the path, 1 indicates the centre of the path.</param>
-        /// <returns></returns>
         protected virtual Color4 ColourAt(float position) => Color4.White;
     }
 }

osu.Framework/Graphics/UserInterface/Menu.cs

···
         /// <summary>
         /// Creates a sub-menu for <see cref="MenuItem.Items"/> of <see cref="MenuItem"/>s added to this <see cref="Menu"/>.
         /// </summary>
-        /// <returns></returns>
         protected abstract Menu CreateSubMenu();
 
         /// <summary>

osu.Framework/Input/Bindings/KeyCombination.cs

···
 
         public string ReadableString()
         {
-            var sortedKeys = Keys.GetValuesInOrder();
-            return string.Join('-', sortedKeys.Select(getReadableKey));
+            var sortedKeys = Keys.GetValuesInOrder().ToArray();
+
+            return string.Join('-', sortedKeys.Select(key =>
+            {
+                switch (key)
+                {
+                    case InputKey.Control:
+                        if (sortedKeys.Contains(InputKey.LControl) || sortedKeys.Contains(InputKey.RControl))
+                            return null;
+
+                        break;
+
+                    case InputKey.Shift:
+                        if (sortedKeys.Contains(InputKey.LShift) || sortedKeys.Contains(InputKey.RShift))
+                            return null;
+
+                        break;
+
+                    case InputKey.Alt:
+                        if (sortedKeys.Contains(InputKey.LAlt) || sortedKeys.Contains(InputKey.RAlt))
+                            return null;
+
+                        break;
+
+                    case InputKey.Super:
+                        if (sortedKeys.Contains(InputKey.LSuper) || sortedKeys.Contains(InputKey.RSuper))
+                            return null;
+
+                        break;
+                }
+
+                return getReadableKey(key);
+            }).Where(s => !string.IsNullOrEmpty(s)));
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
···
             return false;
         }
 
-        private string getReadableKey(InputKey key)
+        private static string getReadableKey(InputKey key)
         {
             if (key >= InputKey.FirstTabletAuxiliaryButton)
                 return $"Tablet Aux {key - InputKey.FirstTabletAuxiliaryButton + 1}";

osu.Framework/Platform/Display.cs

···
         /// <param name="size">The <see cref="Size"/> to match.</param>
         /// <param name="bitsPerPixel">The bits per pixel to match. If null, the highest available bits per pixel will be used.</param>
         /// <param name="refreshRate">The refresh rate in hertz. If null, the highest available refresh rate will be used.</param>
-        /// <returns></returns>
         public DisplayMode FindDisplayMode(Size size, int? bitsPerPixel = null, int? refreshRate = null) =>
             DisplayModes.Where(mode => mode.Size.Width <= size.Width && mode.Size.Height <= size.Height &&
                                        (bitsPerPixel == null || mode.BitsPerPixel == bitsPerPixel) &&

osu.Framework/Platform/IWindow.cs

···
         /// Convert a screen based coordinate to local window space.
         /// </summary>
         /// <param name="point"></param>
-        /// <returns></returns>
         Point PointToClient(Point point);
 
         /// <summary>
         /// Convert a window based coordinate to global screen space.
         /// </summary>
         /// <param name="point"></param>
-        /// <returns></returns>
         Point PointToScreen(Point point);
 
         /// <summary>

osu.Framework/Statistics/GlobalStatistics.cs

···
         /// <param name="group">The group specification.</param>
         /// <param name="name">The name specification.</param>
         /// <typeparam name="T">The type.</typeparam>
-        /// <returns></returns>
         public static GlobalStatistic<T> Get<T>(string group, string name)
         {
             lock (statistics)

osu.Framework/Testing/TestScene.cs

···
         /// Remove the "TestScene" prefix from a name.
         /// </summary>
         /// <param name="name"></param>
-        /// <returns></returns>
         public static string RemovePrefix(string name)
         {
             return name.Replace("TestCase", string.Empty) // TestScene used to be called TestCase. This handles consumer projects which haven't updated their naming for the near future.

osu.Framework/Utils/Interpolation.cs

···
         /// <param name="final">The end value.</param>
         /// <param name="base">The base of the exponential. The valid range is [0, 1], where smaller values mean that the final value is achieved more quickly, and values closer to 1 results in slow convergence to the final value.</param>
         /// <param name="exponent">The exponent of the exponential. An exponent of 0 results in the start values, whereas larger exponents make the result converge to the final value.</param>
-        /// <returns></returns>
         public static double Damp(double start, double final, double @base, double exponent)
         {
             if (@base < 0 || @base > 1)

osu.Framework/Utils/PathApproximator.cs

···
         /// Computes various properties that can be used to approximate the circular arc.
         /// </summary>
         /// <param name="controlPoints">Three distinct points on the arc.</param>
-        /// <returns></returns>
         private static CircularArcProperties circularArcProperties(ReadOnlySpan<Vector2> controlPoints)
         {
             Vector2 a = controlPoints[0];

osu.Framework/osu.Framework.csproj

···
          See https://github.com/NuGet/Home/issues/4514 and https://github.com/dotnet/sdk/issues/765 . -->
     <PackageReference Include="ppy.osu.Framework.NativeLibs" Version="2021.115.0" />
     <PackageReference Include="Microsoft.Build.Locator" Version="1.4.1" />
-    <PackageReference Include="OpenTabletDriver" Version="0.5.2.3" />
+    <PackageReference Include="OpenTabletDriver" Version="0.5.3" />
     <PackageReference Include="Microsoft.CodeAnalysis.CSharp.Workspaces" Version="3.9.0" />
     <PackageReference Include="Microsoft.CodeAnalysis.Workspaces.MSBuild" Version="3.9.0">
       <NoWarn>NU1701</NoWarn> <!-- Requires .NETFramework for MSBuild, but we use Microsoft.Build.Locator which allows this package to work in .NETCoreApp. -->