Merge branch 'master' into fix-ruleset-changing

osu-framework

@@ -1 +1 @@
-Subproject commit 2a56eb0619adf654ed4927af1a4b227596c87494
+Subproject commit 5c22092e590d589927962b8d0173dae5f9b1405c

osu.Desktop.Tests/Visual/TestCaseHitObjects.cs

@@ -2,60 +2,38 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
 using System.Collections.Generic;
-using osu.Framework.Configuration;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
-using osu.Framework.Graphics.Sprites;
-using osu.Framework.Graphics.UserInterface;
 using osu.Framework.Timing;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Osu.Judgements;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Osu.Objects.Drawables;
 using OpenTK;
-using OpenTK.Graphics;
+using osu.Game.Rulesets.Osu;
+using osu.Framework.Allocation;
+using osu.Game.Rulesets;
 
 namespace osu.Desktop.Tests.Visual
 {
     internal class TestCaseHitObjects : OsuTestCase
     {
-        private readonly FramedClock framedClock;
+        private FramedClock framedClock;
 
         private bool auto;
 
-        public TestCaseHitObjects()
+        [BackgroundDependencyLoader]
+        private void load(RulesetStore rulesets)
         {
             var rateAdjustClock = new StopwatchClock(true);
             framedClock = new FramedClock(rateAdjustClock);
-            playbackSpeed.ValueChanged += delegate { rateAdjustClock.Rate = playbackSpeed.Value; };
-
-            playbackSpeed.TriggerChange();
 
             AddStep(@"circles", () => loadHitobjects(HitObjectType.Circle));
             AddStep(@"slider", () => loadHitobjects(HitObjectType.Slider));
             AddStep(@"spinner", () => loadHitobjects(HitObjectType.Spinner));
 
-            AddToggleStep(@"auto", state => { auto = state; loadHitobjects(mode); });
+            AddToggleStep("Auto", state => { auto = state; loadHitobjects(mode); });
-
+            AddSliderStep("Playback speed", 0.0, 2.0, 0.5, v => rateAdjustClock.Rate = v);
-            BasicSliderBar<double> sliderBar;
-            Add(new Container
-            {
-                Anchor = Anchor.TopRight,
-                Origin = Anchor.TopRight,
-                AutoSizeAxes = Axes.Both,
-                Children = new Drawable[]
-                {
-                    new SpriteText { Text = "Playback Speed" },
-                    sliderBar = new BasicSliderBar<double>
-                    {
-                        Width = 150,
-                        Height = 10,
-                        SelectionColor = Color4.Orange,
-                    }
-                }
-            });
-
-            sliderBar.Current.BindTo(playbackSpeed);
 
             framedClock.ProcessFrame();
 
@@ -65,7 +43,7 @@ namespace osu.Desktop.Tests.Visual
                 Clock = framedClock,
                 Children = new[]
                 {
-                    playfieldContainer = new Container { RelativeSizeAxes = Axes.Both },
+                    playfieldContainer = new OsuInputManager(rulesets.GetRuleset(0)) { RelativeSizeAxes = Axes.Both },
                     approachContainer = new Container { RelativeSizeAxes = Axes.Both }
                 }
             };
@@ -75,9 +53,8 @@ namespace osu.Desktop.Tests.Visual
 
         private HitObjectType mode = HitObjectType.Slider;
 
-        private readonly BindableNumber<double> playbackSpeed = new BindableDouble(0.5) { MinValue = 0, MaxValue = 1 };
+        private Container playfieldContainer;
-        private readonly Container playfieldContainer;
+        private Container approachContainer;
-        private readonly Container approachContainer;
 
         private void loadHitobjects(HitObjectType mode)
         {

osu.Desktop.Tests/Visual/TestCaseKeyConfiguration.cs

@@ -0,0 +1,25 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Game.Overlays;
+
+namespace osu.Desktop.Tests.Visual
+{
+    public class TestCaseKeyConfiguration : OsuTestCase
+    {
+        private readonly KeyBindingOverlay overlay;
+
+        public override string Description => @"Key configuration";
+
+        public TestCaseKeyConfiguration()
+        {
+            Child = overlay = new KeyBindingOverlay();
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+            overlay.Show();
+        }
+    }
+}

osu.Desktop.Tests/Visual/TestCaseKeyCounter.cs

@@ -1,11 +1,8 @@
 // Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
-using osu.Framework.Configuration;
 using osu.Framework.Graphics;
-using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
-using osu.Framework.Graphics.Sprites;
 using osu.Framework.Graphics.UserInterface;
 using osu.Framework.MathUtils;
 using osu.Game.Screens.Play;
@@ -34,34 +31,13 @@ namespace osu.Desktop.Tests.Visual
                     new KeyCounterMouse(MouseButton.Right),
                 },
             };
-            BindableInt bindable = new BindableInt { MinValue = 0, MaxValue = 200, Default = 50 };
+
-            bindable.ValueChanged += delegate { kc.FadeTime = bindable.Value; };
+            AddStep("Add random", () =>
-            AddStep("Add Random", () =>
             {
                 Key key = (Key)((int)Key.A + RNG.Next(26));
                 kc.Add(new KeyCounterKeyboard(key));
             });
-
+            AddSliderStep("Fade time", 0, 200, 50, v => kc.FadeTime = v);
-            TestSliderBar<int> sliderBar;
-
-            Add(new Container
-            {
-                Anchor = Anchor.TopRight,
-                Origin = Anchor.TopRight,
-                AutoSizeAxes = Axes.Both,
-                Children = new Drawable[]
-                {
-                    new SpriteText { Text = "FadeTime" },
-                    sliderBar = new TestSliderBar<int>
-                    {
-                        Width = 150,
-                        Height = 10,
-                        SelectionColor = Color4.Orange,
-                    }
-                }
-            });
-
-            sliderBar.Current.BindTo(bindable);
 
             Add(kc);
         }

osu.Desktop.Tests/Visual/TestCaseNotificationOverlay.cs

@@ -68,7 +68,7 @@ namespace osu.Desktop.Tests.Visual
 
             while (progressingNotifications.Count(n => n.State == ProgressNotificationState.Active) < 3)
             {
-                var p = progressingNotifications.FirstOrDefault(n => n.IsLoaded && n.State == ProgressNotificationState.Queued);
+                var p = progressingNotifications.FirstOrDefault(n => n.IsAlive && n.State == ProgressNotificationState.Queued);
                 if (p == null)
                     break;
 

osu.Desktop.Tests/Visual/TestCaseSettings.cs

@@ -13,7 +13,7 @@ namespace osu.Desktop.Tests.Visual
 
         public TestCaseSettings()
         {
-            Children = new[] { settings = new SettingsOverlay() };
+            Children = new[] { settings = new MainSettings() };
         }
 
         protected override void LoadComplete()

osu.Desktop.Tests/osu.Desktop.Tests.csproj

@@ -81,6 +81,7 @@
     <Compile Include="Visual\TestCaseGamefield.cs" />
     <Compile Include="Visual\TestCaseGraph.cs" />
     <Compile Include="Visual\TestCaseHitObjects.cs" />
+    <Compile Include="Visual\TestCaseKeyConfiguration.cs" />
     <Compile Include="Visual\TestCaseKeyCounter.cs" />
     <Compile Include="Visual\TestCaseLeaderboard.cs" />
     <Compile Include="Visual\TestCaseManiaHitObjects.cs" />

osu.Desktop/Overlays/VersionManager.cs

@@ -27,8 +27,6 @@ namespace osu.Desktop.Overlays
         private UpdateManager updateManager;
         private NotificationOverlay notificationOverlay;
 
-        protected override bool HideOnEscape => false;
-
         public override bool HandleInput => false;
 
         [BackgroundDependencyLoader]

osu.Game.Rulesets.Catch/CatchInputManager.cs

@@ -1,29 +1,18 @@
 // Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
-using System.Collections.Generic;
 using System.ComponentModel;
 using osu.Framework.Input.Bindings;
 using osu.Game.Input.Bindings;
-using OpenTK.Input;
 
 namespace osu.Game.Rulesets.Catch
 {
     public class CatchInputManager : DatabasedKeyBindingInputManager<CatchAction>
     {
-        public CatchInputManager(RulesetInfo ruleset) : base(ruleset, simultaneousMode: SimultaneousBindingMode.Unique)
+        public CatchInputManager(RulesetInfo ruleset)
+            : base(ruleset, 0, SimultaneousBindingMode.Unique)
         {
         }
-
-        protected override IEnumerable<KeyBinding> CreateDefaultMappings() => new[]
-        {
-            new KeyBinding( Key.Z, CatchAction.MoveLeft),
-            new KeyBinding( Key.Left, CatchAction.MoveLeft),
-            new KeyBinding( Key.X, CatchAction.MoveRight),
-            new KeyBinding( Key.Right, CatchAction.MoveRight),
-            new KeyBinding( Key.LShift, CatchAction.Dash),
-            new KeyBinding( Key.RShift, CatchAction.Dash),
-        };
     }
 
     public enum CatchAction

osu.Game.Rulesets.Catch/CatchRuleset.cs

@@ -13,6 +13,7 @@ using System.Collections.Generic;
 using osu.Framework.Graphics;
 using osu.Game.Rulesets.Catch.Scoring;
 using osu.Game.Rulesets.Scoring;
+using osu.Framework.Input.Bindings;
 
 namespace osu.Game.Rulesets.Catch
 {
@@ -20,6 +21,16 @@ namespace osu.Game.Rulesets.Catch
     {
         public override RulesetContainer CreateRulesetContainerWith(WorkingBeatmap beatmap, bool isForCurrentRuleset) => new CatchRulesetContainer(this, beatmap, isForCurrentRuleset);
 
+        public override IEnumerable<KeyBinding> GetDefaultKeyBindings(int variant = 0) => new[]
+        {
+            new KeyBinding(Key.Z, CatchAction.MoveLeft),
+            new KeyBinding(Key.Left, CatchAction.MoveLeft),
+            new KeyBinding(Key.X, CatchAction.MoveRight),
+            new KeyBinding(Key.Right, CatchAction.MoveRight),
+            new KeyBinding(Key.LShift, CatchAction.Dash),
+            new KeyBinding(Key.RShift, CatchAction.Dash),
+        };
+
         public override IEnumerable<Mod> GetModsFor(ModType type)
         {
             switch (type)

osu.Game.Rulesets.Catch/UI/CatchRulesetContainer.cs

@@ -28,7 +28,7 @@ namespace osu.Game.Rulesets.Catch.UI
 
         protected override Playfield<CatchBaseHit, CatchJudgement> CreatePlayfield() => new CatchPlayfield();
 
-        protected override PassThroughInputManager CreateActionMappingInputManager() => new CatchInputManager(Ruleset?.RulesetInfo);
+        public override PassThroughInputManager CreateKeyBindingInputManager() => new CatchInputManager(Ruleset?.RulesetInfo);
 
         protected override DrawableHitObject<CatchBaseHit, CatchJudgement> GetVisualRepresentation(CatchBaseHit h)
         {

osu.Game.Rulesets.Osu/Objects/Drawables/Pieces/SliderBody.cs

@@ -44,7 +44,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
                     return;
                 accentColour = value;
 
-                if (LoadState == LoadState.Loaded)
+                if (LoadState == LoadState.Ready)
                     Schedule(reloadTexture);
             }
         }

osu.Game.Rulesets.Osu/OsuInputManager.cs

@@ -1,7 +1,7 @@
 // Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
-using System.Collections.Generic;
+using System.ComponentModel;
 using System.Linq;
 using osu.Framework.Input;
 using osu.Framework.Input.Bindings;
@@ -14,7 +14,7 @@ namespace osu.Game.Rulesets.Osu
 {
     public class OsuInputManager : DatabasedKeyBindingInputManager<OsuAction>
     {
-        public OsuInputManager(RulesetInfo ruleset) : base(ruleset, simultaneousMode: SimultaneousBindingMode.Unique)
+        public OsuInputManager(RulesetInfo ruleset) : base(ruleset, 0, SimultaneousBindingMode.Unique)
         {
 
         }
@@ -33,19 +33,13 @@ namespace osu.Game.Rulesets.Osu
                     keyboard.Keys = keyboard.Keys.Concat(new[] { Key.LastKey + 2 });
             }
         }
-
-        protected override IEnumerable<KeyBinding> CreateDefaultMappings() => new[]
-        {
-            new KeyBinding(Key.Z, OsuAction.LeftButton),
-            new KeyBinding(Key.X, OsuAction.RightButton),
-            new KeyBinding(Key.LastKey + 1, OsuAction.LeftButton),
-            new KeyBinding(Key.LastKey + 2, OsuAction.RightButton),
-        };
     }
 
     public enum OsuAction
     {
+        [Description("Left Button")]
         LeftButton,
+        [Description("Right Button")]
         RightButton
     }
 }

osu.Game.Rulesets.Osu/OsuRuleset.cs

@@ -17,6 +17,7 @@ using osu.Framework.Graphics;
 using osu.Game.Rulesets.Osu.Scoring;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Overlays.Settings;
+using osu.Framework.Input.Bindings;
 
 namespace osu.Game.Rulesets.Osu
 {
@@ -24,8 +25,16 @@ namespace osu.Game.Rulesets.Osu
     {
         public override RulesetContainer CreateRulesetContainerWith(WorkingBeatmap beatmap, bool isForCurrentRuleset) => new OsuRulesetContainer(this, beatmap, isForCurrentRuleset);
 
-        public override IEnumerable<BeatmapStatistic> GetBeatmapStatistics(WorkingBeatmap beatmap) => new[]
+        public override IEnumerable<KeyBinding> GetDefaultKeyBindings(int variant = 0) => new[]
         {
+            new KeyBinding(Key.Z, OsuAction.LeftButton),
+            new KeyBinding(Key.X, OsuAction.RightButton),
+            new KeyBinding(Key.LastKey + 1, OsuAction.LeftButton),
+            new KeyBinding(Key.LastKey + 2, OsuAction.RightButton),
+        };
+
+        public override IEnumerable<BeatmapStatistic> GetBeatmapStatistics(WorkingBeatmap beatmap) => new[]
+            {
             new BeatmapStatistic
             {
                 Name = @"Circle count",

osu.Game.Rulesets.Osu/UI/OsuRulesetContainer.cs

@@ -31,7 +31,7 @@ namespace osu.Game.Rulesets.Osu.UI
 
         protected override Playfield<OsuHitObject, OsuJudgement> CreatePlayfield() => new OsuPlayfield();
 
-        protected override PassThroughInputManager CreateActionMappingInputManager() => new OsuInputManager(Ruleset?.RulesetInfo);
+        public override PassThroughInputManager CreateKeyBindingInputManager() => new OsuInputManager(Ruleset?.RulesetInfo);
 
         protected override DrawableHitObject<OsuHitObject, OsuJudgement> GetVisualRepresentation(OsuHitObject h)
         {

osu.Game/Beatmaps/BeatmapManager.cs

@@ -307,6 +307,11 @@ namespace osu.Game.Beatmaps
         /// <returns>The imported beatmap, or an existing instance if it is already present.</returns>
         private BeatmapSetInfo importToStorage(ArchiveReader reader)
         {
+            // let's make sure there are actually .osu files to import.
+            string mapName = reader.Filenames.FirstOrDefault(f => f.EndsWith(".osu"));
+            if (string.IsNullOrEmpty(mapName))
+                throw new InvalidOperationException("No beatmap files found in the map folder.");
+
             // for now, concatenate all .osu files in the set to create a unique hash.
             MemoryStream hashable = new MemoryStream();
             foreach (string file in reader.Filenames.Where(f => f.EndsWith(".osu")))
@@ -339,7 +344,7 @@ namespace osu.Game.Beatmaps
 
             BeatmapMetadata metadata;
 
-            using (var stream = new StreamReader(reader.GetStream(reader.Filenames.First(f => f.EndsWith(".osu")))))
+            using (var stream = new StreamReader(reader.GetStream(mapName)))
                 metadata = BeatmapDecoder.GetDecoder(stream).Decode(stream).Metadata;
 
             beatmapSet = new BeatmapSetInfo

osu.Game/Beatmaps/Formats/BeatmapDecoder.cs

@@ -19,7 +19,9 @@ namespace osu.Game.Beatmaps.Formats
 
         public static BeatmapDecoder GetDecoder(StreamReader stream)
         {
-            string line = stream.ReadLine()?.Trim();
+            string line;
+            do { line = stream.ReadLine()?.Trim(); }
+                while (line != null && line.Length == 0);
 
             if (line == null || !decoders.ContainsKey(line))
                 throw new IOException(@"Unknown file format");

osu.Game/Beatmaps/Formats/OsuLegacyDecoder.cs

@@ -27,7 +27,9 @@ namespace osu.Game.Beatmaps.Formats
             AddDecoder<OsuLegacyDecoder>(@"osu file format v7");
             AddDecoder<OsuLegacyDecoder>(@"osu file format v6");
             AddDecoder<OsuLegacyDecoder>(@"osu file format v5");
-            // TODO: Not sure how far back to go, or differences between versions
+            AddDecoder<OsuLegacyDecoder>(@"osu file format v4");
+            AddDecoder<OsuLegacyDecoder>(@"osu file format v3");
+            // TODO: differences between versions
         }
 
         private ConvertHitObjectParser parser;
@@ -222,6 +224,7 @@ namespace osu.Game.Beatmaps.Formats
         {
             while (line.IndexOf('$') >= 0)
             {
+                string origLine = line;
                 string[] split = line.Split(',');
                 for (int i = 0; i < split.Length; i++)
                 {
@@ -231,6 +234,7 @@ namespace osu.Game.Beatmaps.Formats
                 }
 
                 line = string.Join(",", split);
+                if (line == origLine) break;
             }
         }
 

osu.Game/Graphics/Containers/ParallaxContainer.cs

@@ -34,9 +34,8 @@ namespace osu.Game.Graphics.Containers
         protected override Container<Drawable> Content => content;
 
         [BackgroundDependencyLoader]
-        private void load(UserInputManager input, OsuConfigManager config)
+        private void load(OsuConfigManager config)
         {
-            this.input = input;
             parallaxEnabled = config.GetBindable<bool>(OsuSetting.MenuParallax);
             parallaxEnabled.ValueChanged += delegate
             {
@@ -48,6 +47,12 @@ namespace osu.Game.Graphics.Containers
             };
         }
 
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+            input = GetContainingInputManager();
+        }
+
         private bool firstUpdate = true;
 
         protected override void Update()

osu.Game/Graphics/UserInterface/FocusedTextBox.cs

@@ -3,10 +3,8 @@
 
 using OpenTK.Graphics;
 using OpenTK.Input;
-using osu.Framework.Allocation;
 using osu.Framework.Input;
 using System;
-using System.Linq;
 
 namespace osu.Game.Graphics.UserInterface
 {
@@ -28,34 +26,28 @@ namespace osu.Game.Graphics.UserInterface
             {
                 focus = value;
                 if (!focus && HasFocus)
-                    inputManager.ChangeFocus(null);
+                    GetContainingInputManager().ChangeFocus(null);
             }
         }
 
-        private InputManager inputManager;
-
-        [BackgroundDependencyLoader]
-        private void load(UserInputManager inputManager)
-        {
-            this.inputManager = inputManager;
-        }
-
         protected override void OnFocus(InputState state)
         {
             base.OnFocus(state);
             BorderThickness = 0;
         }
 
-        protected override void OnFocusLost(InputState state)
+        protected override bool OnKeyDown(InputState state, KeyDownEventArgs args)
         {
-            if (state.Keyboard.Keys.Any(key => key == Key.Escape))
+            if (args.Key == Key.Escape)
             {
                 if (Text.Length > 0)
                     Text = string.Empty;
                 else
                     Exit?.Invoke();
+                return true;
             }
-            base.OnFocusLost(state);
+
+            return base.OnKeyDown(state, args);
         }
 
         public override bool RequestsFocus => HoldFocus;

osu.Game/Graphics/UserInterface/OsuButton.cs

@@ -7,6 +7,7 @@ using osu.Framework.Audio;
 using osu.Framework.Audio.Sample;
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Graphics.UserInterface;
@@ -16,7 +17,7 @@ using osu.Game.Graphics.Sprites;
 
 namespace osu.Game.Graphics.UserInterface
 {
-    public class OsuButton : Button
+    public class OsuButton : Button, IFilterable
     {
         private Box hover;
 
@@ -108,5 +109,15 @@ namespace osu.Game.Graphics.UserInterface
             Content.ScaleTo(1, 1000, Easing.OutElastic);
             return base.OnMouseUp(state, args);
         }
+
+        public string[] FilterTerms => new[] { Text };
+
+        public bool MatchingFilter
+        {
+            set
+            {
+                this.FadeTo(value ? 1 : 0);
+            }
+        }
     }
 }

osu.Game/Graphics/UserInterface/Volume/VolumeControl.cs

@@ -15,8 +15,6 @@ namespace osu.Game.Graphics.UserInterface.Volume
     {
         private readonly VolumeMeter volumeMeterMaster;
 
-        protected override bool HideOnEscape => false;
-
         private void volumeChanged(double newVolume)
         {
             Show();

osu.Game/Input/BindingStore.cs

@@ -1,48 +0,0 @@
-// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
-
-using System;
-using osu.Framework.Platform;
-using osu.Game.Database;
-using osu.Game.Input.Bindings;
-using SQLite.Net;
-
-namespace osu.Game.Input
-{
-    public class BindingStore : DatabaseBackedStore
-    {
-        public BindingStore(SQLiteConnection connection, Storage storage = null)
-            : base(connection, storage)
-        {
-        }
-
-        protected override int StoreVersion => 2;
-
-        protected override void PerformMigration(int currentVersion, int targetVersion)
-        {
-            base.PerformMigration(currentVersion, targetVersion);
-
-            while (currentVersion++ < targetVersion)
-            {
-                switch (currentVersion)
-                {
-                    case 1:
-                        // cannot migrate; breaking underlying changes.
-                        Reset();
-                        break;
-                }
-            }
-        }
-
-        protected override void Prepare(bool reset = false)
-        {
-            Connection.CreateTable<DatabasedKeyBinding>();
-        }
-
-        protected override Type[] ValidTypes => new[]
-        {
-            typeof(DatabasedKeyBinding)
-        };
-
-    }
-}

osu.Game/Input/Bindings/DatabasedKeyBinding.cs

@@ -11,6 +11,9 @@ namespace osu.Game.Input.Bindings
     [Table("KeyBinding")]
     public class DatabasedKeyBinding : KeyBinding
     {
+        [PrimaryKey, AutoIncrement]
+        public int ID { get; set; }
+
         [ForeignKey(typeof(RulesetInfo))]
         public int? RulesetID { get; set; }
 
@@ -24,11 +27,12 @@ namespace osu.Game.Input.Bindings
             private set { KeyCombination = value; }
         }
 
+        [Indexed]
         [Column("Action")]
-        public new int Action
+        public int IntAction
         {
-            get { return base.Action; }
+            get { return (int)Action; }
-            private set { base.Action = value; }
+            set { Action = value; }
         }
     }
 }

osu.Game/Input/Bindings/DatabasedKeyBindingInputManager.cs

@@ -1,6 +1,8 @@
 // Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
+using System;
+using System.Collections.Generic;
 using osu.Framework.Allocation;
 using osu.Framework.Input.Bindings;
 using osu.Game.Rulesets;
@@ -18,7 +20,9 @@ namespace osu.Game.Input.Bindings
 
         private readonly int? variant;
 
-        private BindingStore store;
+        private KeyBindingStore store;
+
+        public override IEnumerable<KeyBinding> DefaultKeyBindings => ruleset.CreateInstance().GetDefaultKeyBindings();
 
         /// <summary>
         /// Create a new instance.
@@ -31,27 +35,20 @@ namespace osu.Game.Input.Bindings
         {
             this.ruleset = ruleset;
             this.variant = variant;
+
+            if (ruleset != null && variant == null)
+                throw new InvalidOperationException($"{nameof(variant)} can not be null when a non-null {nameof(ruleset)} is provided.");
         }
 
         [BackgroundDependencyLoader]
-        private void load(BindingStore bindings)
+        private void load(KeyBindingStore keyBindings)
         {
-            store = bindings;
+            store = keyBindings;
         }
 
         protected override void ReloadMappings()
         {
-            // load defaults
+            KeyBindings = store.Query(ruleset?.ID, variant);
-            base.ReloadMappings();
-
-            var rulesetId = ruleset?.ID;
-
-            // load from database if present.
-            if (store != null)
-            {
-                foreach (var b in store.Query<DatabasedKeyBinding>(b => b.RulesetID == rulesetId && b.Variant == variant))
-                    KeyBindings.Add(b);
-            }
         }
     }
 }

osu.Game/Input/Bindings/GlobalKeyBindingInputManager.cs

@@ -6,22 +6,21 @@ using System.Collections.Generic;
 using System.ComponentModel;
 using System.Linq;
 using osu.Framework.Graphics;
-using osu.Framework.Input;
 using osu.Framework.Input.Bindings;
 
 namespace osu.Game.Input.Bindings
 {
-    public class GlobalBindingInputManager : DatabasedKeyBindingInputManager<GlobalAction>
+    public class GlobalKeyBindingInputManager : DatabasedKeyBindingInputManager<GlobalAction>
     {
         private readonly Drawable handler;
 
-        public GlobalBindingInputManager(OsuGameBase game)
+        public GlobalKeyBindingInputManager(OsuGameBase game)
         {
             if (game is IKeyBindingHandler<GlobalAction>)
                 handler = game;
         }
 
-        protected override IEnumerable<KeyBinding> CreateDefaultMappings() => new[]
+        public override IEnumerable<KeyBinding> DefaultKeyBindings => new[]
         {
             new KeyBinding(Key.F8, GlobalAction.ToggleChat),
             new KeyBinding(Key.F9, GlobalAction.ToggleSocial),
@@ -31,23 +30,8 @@ namespace osu.Game.Input.Bindings
             new KeyBinding(new[] { Key.LControl, Key.D }, GlobalAction.ToggleDirect),
         };
 
-        protected override bool PropagateKeyDown(IEnumerable<Drawable> drawables, InputState state, KeyDownEventArgs args)
+        protected override IEnumerable<Drawable> GetKeyboardInputQueue() =>
-        {
+            handler == null ? base.GetKeyboardInputQueue() : new[] { handler }.Concat(base.GetKeyboardInputQueue());
-            if (handler != null)
-                drawables = new[] { handler }.Concat(drawables);
-
-            // always handle ourselves before all children.
-            return base.PropagateKeyDown(drawables, state, args);
-        }
-
-        protected override bool PropagateKeyUp(IEnumerable<Drawable> drawables, InputState state, KeyUpEventArgs args)
-        {
-            if (handler != null)
-                drawables = new[] { handler }.Concat(drawables);
-
-            // always handle ourselves before all children.
-            return base.PropagateKeyUp(drawables, state, args);
-        }
     }
 
     public enum GlobalAction

osu.Game/Input/KeyBindingStore.cs

@@ -0,0 +1,93 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using osu.Framework.Input.Bindings;
+using osu.Framework.Platform;
+using osu.Game.Database;
+using osu.Game.Input.Bindings;
+using osu.Game.Rulesets;
+using SQLite.Net;
+
+namespace osu.Game.Input
+{
+    public class KeyBindingStore : DatabaseBackedStore
+    {
+        public KeyBindingStore(SQLiteConnection connection, RulesetStore rulesets, Storage storage = null)
+            : base(connection, storage)
+        {
+            foreach (var info in rulesets.Query<RulesetInfo>())
+            {
+                var ruleset = info.CreateInstance();
+                foreach (var variant in ruleset.AvailableVariants)
+                    insertDefaults(ruleset.GetDefaultKeyBindings(), info.ID, variant);
+            }
+        }
+
+        public void Register(KeyBindingInputManager manager) => insertDefaults(manager.DefaultKeyBindings);
+
+        protected override int StoreVersion => 3;
+
+        protected override void PerformMigration(int currentVersion, int targetVersion)
+        {
+            base.PerformMigration(currentVersion, targetVersion);
+
+            while (currentVersion++ < targetVersion)
+            {
+                switch (currentVersion)
+                {
+                    case 1:
+                    case 2:
+                    case 3:
+                        // cannot migrate; breaking underlying changes.
+                        Reset();
+                        break;
+                }
+            }
+        }
+
+        protected override void Prepare(bool reset = false)
+        {
+            if (reset)
+                Connection.DropTable<DatabasedKeyBinding>();
+
+            Connection.CreateTable<DatabasedKeyBinding>();
+        }
+
+        private void insertDefaults(IEnumerable<KeyBinding> defaults, int? rulesetId = null, int? variant = null)
+        {
+            var query = Query(rulesetId, variant);
+
+            // compare counts in database vs defaults
+            foreach (var group in defaults.GroupBy(k => k.Action))
+            {
+                int count;
+                while (group.Count() > (count = query.Count(k => (int)k.Action == (int)group.Key)))
+                {
+                    var insertable = group.Skip(count).First();
+
+                    // insert any defaults which are missing.
+                    Connection.Insert(new DatabasedKeyBinding
+                    {
+                        KeyCombination = insertable.KeyCombination,
+                        Action = insertable.Action,
+                        RulesetID = rulesetId,
+                        Variant = variant
+                    });
+                }
+            }
+        }
+
+        protected override Type[] ValidTypes => new[]
+        {
+            typeof(DatabasedKeyBinding)
+        };
+
+        public IEnumerable<KeyBinding> Query(int? rulesetId = null, int? variant = null) =>
+            Query<DatabasedKeyBinding>(b => b.RulesetID == rulesetId && b.Variant == variant);
+
+        public void Update(KeyBinding keyBinding) => Connection.Update(keyBinding);
+    }
+}

osu.Game/OsuGame.cs

@@ -182,7 +182,11 @@ namespace osu.Game
             LoadComponentAsync(direct = new DirectOverlay { Depth = -1 }, mainContent.Add);
             LoadComponentAsync(social = new SocialOverlay { Depth = -1 }, mainContent.Add);
             LoadComponentAsync(chat = new ChatOverlay { Depth = -1 }, mainContent.Add);
-            LoadComponentAsync(settings = new SettingsOverlay { Depth = -1 }, overlayContent.Add);
+            LoadComponentAsync(settings = new MainSettings
+            {
+                GetToolbarHeight = () => ToolbarOffset,
+                Depth = -1
+            }, overlayContent.Add);
             LoadComponentAsync(userProfile = new UserProfileOverlay { Depth = -2 }, mainContent.Add);
             LoadComponentAsync(musicController = new MusicController
             {

osu.Game/OsuGameBase.cs

@@ -39,7 +39,7 @@ namespace osu.Game
 
         protected ScoreStore ScoreStore;
 
-        protected BindingStore BindingStore;
+        protected KeyBindingStore KeyBindingStore;
 
         protected override string MainResourceFile => @"osu.Game.Resources.dll";
 
@@ -108,7 +108,7 @@ namespace osu.Game
             dependencies.Cache(FileStore = new FileStore(connection, Host.Storage));
             dependencies.Cache(BeatmapManager = new BeatmapManager(Host.Storage, FileStore, connection, RulesetStore, Host));
             dependencies.Cache(ScoreStore = new ScoreStore(Host.Storage, connection, Host, BeatmapManager));
-            dependencies.Cache(BindingStore = new BindingStore(connection));
+            dependencies.Cache(KeyBindingStore = new KeyBindingStore(connection, RulesetStore));
             dependencies.Cache(new OsuColour());
 
             //this completely overrides the framework default. will need to change once we make a proper FontStore.
@@ -183,12 +183,14 @@ namespace osu.Game
         {
             base.LoadComplete();
 
+            GlobalKeyBindingInputManager globalBinding;
+
             base.Content.Add(new RatioAdjust
             {
                 Children = new Drawable[]
                 {
                     Cursor = new MenuCursor(),
-                    new GlobalBindingInputManager(this)
+                    globalBinding = new GlobalKeyBindingInputManager(this)
                     {
                         RelativeSizeAxes = Axes.Both,
                         Child = new OsuTooltipContainer(Cursor)
@@ -200,6 +202,9 @@ namespace osu.Game
                 }
             });
 
+            KeyBindingStore.Register(globalBinding);
+            dependencies.Cache(globalBinding);
+
             // TODO: This is temporary until we reimplement the local FPS display.
             // It's just to allow end-users to access the framework FPS display without knowing the shortcut key.
             fpsDisplayVisible = LocalConfig.GetBindable<bool>(OsuSetting.ShowFpsDisplay);

osu.Game/Overlays/Chat/ChannelSelectionOverlay.cs

@@ -152,7 +152,7 @@ namespace osu.Game.Overlays.Chat
 
         protected override void OnFocus(InputState state)
         {
-            InputManager.ChangeFocus(search);
+            GetContainingInputManager().ChangeFocus(search);
             base.OnFocus(state);
         }
 

osu.Game/Overlays/ChatOverlay.cs

@@ -243,7 +243,7 @@ namespace osu.Game.Overlays
         protected override void OnFocus(InputState state)
         {
             //this is necessary as inputTextBox is masked away and therefore can't get focus :(
-            InputManager.ChangeFocus(inputTextBox);
+            GetContainingInputManager().ChangeFocus(inputTextBox);
             base.OnFocus(state);
         }
 

osu.Game/Overlays/KeyBinding/GlobalKeyBindingsSection.cs

@@ -0,0 +1,23 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Framework.Input.Bindings;
+using osu.Game.Graphics;
+
+namespace osu.Game.Overlays.KeyBinding
+{
+    public class GlobalKeyBindingsSection : KeyBindingsSection
+    {
+        private readonly string name;
+
+        public override FontAwesome Icon => FontAwesome.fa_osu_mod_nofail;
+        public override string Header => name;
+
+        public GlobalKeyBindingsSection(KeyBindingInputManager manager, string name)
+        {
+            this.name = name;
+
+            Defaults = manager.DefaultKeyBindings;
+        }
+    }
+}

osu.Game/Overlays/KeyBinding/KeyBindingRow.cs

@@ -0,0 +1,306 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using osu.Framework.Allocation;
+using osu.Framework.Extensions;
+using osu.Framework.Extensions.Color4Extensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Input;
+using osu.Game.Graphics;
+using osu.Game.Graphics.Sprites;
+using osu.Game.Input;
+using OpenTK.Graphics;
+using OpenTK.Input;
+
+namespace osu.Game.Overlays.KeyBinding
+{
+    internal class KeyBindingRow : Container, IFilterable
+    {
+        private readonly Enum action;
+        private readonly IEnumerable<Framework.Input.Bindings.KeyBinding> bindings;
+
+        private const float transition_time = 150;
+
+        private const float height = 20;
+
+        private const float padding = 5;
+
+        private bool matchingFilter;
+
+        public bool MatchingFilter
+        {
+            get { return matchingFilter; }
+            set
+            {
+                matchingFilter = value;
+                this.FadeTo(!matchingFilter ? 0 : 1);
+            }
+        }
+
+        private OsuSpriteText text;
+        private OsuSpriteText pressAKey;
+
+        private FillFlowContainer<KeyButton> buttons;
+
+        public string[] FilterTerms => new[] { text.Text }.Concat(bindings.Select(b => b.KeyCombination.ReadableString())).ToArray();
+
+        public KeyBindingRow(Enum action, IEnumerable<Framework.Input.Bindings.KeyBinding> bindings)
+        {
+            this.action = action;
+            this.bindings = bindings;
+
+            RelativeSizeAxes = Axes.X;
+            AutoSizeAxes = Axes.Y;
+
+            Masking = true;
+            CornerRadius = padding;
+        }
+
+        private KeyBindingStore store;
+
+        [BackgroundDependencyLoader]
+        private void load(OsuColour colours, KeyBindingStore store)
+        {
+            this.store = store;
+
+            EdgeEffect = new EdgeEffectParameters
+            {
+                Radius = 2,
+                Colour = colours.YellowDark.Opacity(0),
+                Type = EdgeEffectType.Shadow,
+                Hollow = true,
+            };
+
+            Children = new Drawable[]
+            {
+                new Box
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Colour = Color4.Black,
+                    Alpha = 0.6f,
+                },
+                text = new OsuSpriteText
+                {
+                    Text = action.GetDescription(),
+                    Margin = new MarginPadding(padding),
+                },
+                buttons = new FillFlowContainer<KeyButton>
+                {
+                    AutoSizeAxes = Axes.Both,
+                    Anchor = Anchor.TopRight,
+                    Origin = Anchor.TopRight
+                },
+                pressAKey = new OsuSpriteText
+                {
+                    Text = "Press a key to change binding, DEL to delete, ESC to cancel.",
+                    Y = height,
+                    Margin = new MarginPadding(padding),
+                    Alpha = 0,
+                    Colour = colours.YellowDark
+                }
+            };
+
+            foreach (var b in bindings)
+                buttons.Add(new KeyButton(b));
+        }
+
+        protected override bool OnHover(InputState state)
+        {
+            this.FadeEdgeEffectTo<Container>(1, transition_time, Easing.OutQuint);
+
+            return base.OnHover(state);
+        }
+
+        protected override void OnHoverLost(InputState state)
+        {
+            this.FadeEdgeEffectTo<Container>(0, transition_time, Easing.OutQuint);
+
+            base.OnHoverLost(state);
+        }
+
+        public override bool AcceptsFocus => true;
+
+        private KeyButton bindTarget;
+
+        protected override void OnFocus(InputState state)
+        {
+            AutoSizeDuration = 500;
+            AutoSizeEasing = Easing.OutQuint;
+
+            pressAKey.FadeIn(300, Easing.OutQuint);
+            pressAKey.Padding = new MarginPadding();
+
+            base.OnFocus(state);
+        }
+
+        private bool isModifier(Key k) => k < Key.F1;
+
+        protected override bool OnKeyDown(InputState state, KeyDownEventArgs args)
+        {
+            switch (args.Key)
+            {
+                case Key.Escape:
+                    GetContainingInputManager().ChangeFocus(null);
+                    return true;
+                case Key.Delete:
+                    bindTarget.UpdateKeyCombination(Key.Unknown);
+                    store.Update(bindTarget.KeyBinding);
+                    GetContainingInputManager().ChangeFocus(null);
+                    return true;
+            }
+
+            if (HasFocus)
+            {
+                bindTarget.UpdateKeyCombination(state.Keyboard.Keys.ToArray());
+                if (!isModifier(args.Key))
+                    finalise();
+                return true;
+            }
+
+            return base.OnKeyDown(state, args);
+        }
+
+        protected override bool OnKeyUp(InputState state, KeyUpEventArgs args)
+        {
+            if (HasFocus)
+            {
+                finalise();
+                return true;
+            }
+
+            return base.OnKeyUp(state, args);
+        }
+
+        private void finalise()
+        {
+            store.Update(bindTarget.KeyBinding);
+            GetContainingInputManager().ChangeFocus(null);
+        }
+
+        protected override void OnFocusLost(InputState state)
+        {
+            bindTarget.IsBinding = false;
+            bindTarget = null;
+
+            pressAKey.FadeOut(300, Easing.OutQuint);
+            pressAKey.Padding = new MarginPadding { Bottom = -pressAKey.DrawHeight };
+            base.OnFocusLost(state);
+        }
+
+        protected override bool OnClick(InputState state)
+        {
+            if (bindTarget != null) bindTarget.IsBinding = false;
+            bindTarget = buttons.FirstOrDefault(b => b.IsHovered) ?? buttons.FirstOrDefault();
+            if (bindTarget != null) bindTarget.IsBinding = true;
+
+            return bindTarget != null;
+        }
+
+        private class KeyButton : Container
+        {
+            public readonly Framework.Input.Bindings.KeyBinding KeyBinding;
+
+            private readonly Box box;
+            public readonly OsuSpriteText Text;
+
+            private Color4 hoverColour;
+
+            private bool isBinding;
+
+            public bool IsBinding
+            {
+                get { return isBinding; }
+                set
+                {
+                    if (value == isBinding) return;
+                    isBinding = value;
+
+                    updateHoverState();
+                }
+            }
+
+            public KeyButton(Framework.Input.Bindings.KeyBinding keyBinding)
+            {
+                KeyBinding = keyBinding;
+
+                Margin = new MarginPadding(padding);
+
+                // todo: use this in a meaningful way
+                // var isDefault = keyBinding.Action is Enum;
+
+                Masking = true;
+                CornerRadius = padding;
+
+                Height = height;
+                AutoSizeAxes = Axes.X;
+
+                Children = new Drawable[]
+                {
+                    new Container
+                    {
+                        AlwaysPresent = true,
+                        Width = 80,
+                        Height = height,
+                    },
+                    box = new Box
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Colour = Color4.Black
+                    },
+                    Text = new OsuSpriteText
+                    {
+                        Font = "Venera",
+                        TextSize = 10,
+                        Margin = new MarginPadding(5),
+                        Anchor = Anchor.Centre,
+                        Origin = Anchor.Centre,
+                        Text = keyBinding.KeyCombination.ReadableString(),
+                    },
+                };
+            }
+
+            [BackgroundDependencyLoader]
+            private void load(OsuColour colours)
+            {
+                hoverColour = colours.YellowDark;
+            }
+
+            protected override bool OnHover(InputState state)
+            {
+                updateHoverState();
+                return base.OnHover(state);
+            }
+
+            protected override void OnHoverLost(InputState state)
+            {
+                updateHoverState();
+                base.OnHoverLost(state);
+            }
+
+            private void updateHoverState()
+            {
+                if (isBinding)
+                {
+                    box.FadeColour(Color4.White, transition_time, Easing.OutQuint);
+                    Text.FadeColour(Color4.Black, transition_time, Easing.OutQuint);
+                }
+                else
+                {
+                    box.FadeColour(IsHovered ? hoverColour : Color4.Black, transition_time, Easing.OutQuint);
+                    Text.FadeColour(IsHovered ? Color4.Black : Color4.White, transition_time, Easing.OutQuint);
+                }
+            }
+
+            public void UpdateKeyCombination(params Key[] newCombination)
+            {
+                KeyBinding.KeyCombination = newCombination;
+                Text.Text = KeyBinding.KeyCombination.ReadableString();
+            }
+        }
+    }
+}

osu.Game/Overlays/KeyBinding/KeyBindingsSection.cs

@@ -0,0 +1,46 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using osu.Framework.Allocation;
+using osu.Game.Input;
+using osu.Game.Overlays.Settings;
+using osu.Game.Rulesets;
+using OpenTK;
+
+namespace osu.Game.Overlays.KeyBinding
+{
+    public abstract class KeyBindingsSection : SettingsSection
+    {
+        protected IEnumerable<Framework.Input.Bindings.KeyBinding> Defaults;
+
+        protected RulesetInfo Ruleset;
+
+        protected KeyBindingsSection()
+        {
+            FlowContent.Spacing = new Vector2(0, 1);
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(KeyBindingStore store)
+        {
+            var enumType = Defaults?.FirstOrDefault()?.Action?.GetType();
+
+            if (enumType == null) return;
+
+            // for now let's just assume a variant of zero.
+            // this will need to be implemented in a better way in the future.
+            int? variant = null;
+            if (Ruleset != null)
+                variant = 0;
+
+            var bindings = store.Query(Ruleset?.ID, variant);
+
+            foreach (Enum v in Enum.GetValues(enumType))
+                // one row per valid action.
+                Add(new KeyBindingRow(v, bindings.Where(b => b.Action.Equals((int)(object)v))));
+        }
+    }
+}

osu.Game/Overlays/KeyBinding/RulesetBindingsSection.cs

@@ -0,0 +1,21 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Game.Graphics;
+using osu.Game.Rulesets;
+
+namespace osu.Game.Overlays.KeyBinding
+{
+    public class RulesetBindingsSection : KeyBindingsSection
+    {
+        public override FontAwesome Icon => FontAwesome.fa_osu_mod_nofail;
+        public override string Header => Ruleset.Name;
+
+        public RulesetBindingsSection(RulesetInfo ruleset)
+        {
+            Ruleset = ruleset;
+
+            Defaults = ruleset.CreateInstance().GetDefaultKeyBindings();
+        }
+    }
+}

osu.Game/Overlays/KeyBindingOverlay.cs

@@ -0,0 +1,31 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Game.Input.Bindings;
+using osu.Game.Overlays.KeyBinding;
+using osu.Game.Overlays.Settings;
+using osu.Game.Rulesets;
+
+namespace osu.Game.Overlays
+{
+    public class KeyBindingOverlay : SettingsOverlay
+    {
+        protected override Drawable CreateHeader() => new SettingsHeader("key configuration", "Customise your keys!");
+
+        [BackgroundDependencyLoader(permitNulls: true)]
+        private void load(RulesetStore rulesets, GlobalKeyBindingInputManager global)
+        {
+            AddSection(new GlobalKeyBindingsSection(global, "Global"));
+
+            foreach (var ruleset in rulesets.Query<RulesetInfo>())
+                AddSection(new RulesetBindingsSection(ruleset));
+        }
+
+        public KeyBindingOverlay()
+            : base(false)
+        {
+        }
+    }
+}

osu.Game/Overlays/LoginOverlay.cs

@@ -69,7 +69,7 @@ namespace osu.Game.Overlays
             settingsSection.Bounding = true;
             this.FadeIn(transition_time, Easing.OutQuint);
 
-            InputManager.ChangeFocus(settingsSection);
+            GetContainingInputManager().ChangeFocus(settingsSection);
         }
 
         protected override void PopOut()

osu.Game/Overlays/MainSettings.cs

@@ -0,0 +1,151 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using System.Collections.Generic;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Input;
+using osu.Game.Graphics;
+using osu.Game.Graphics.Containers;
+using osu.Game.Graphics.Sprites;
+using osu.Game.Overlays.Settings;
+using osu.Game.Overlays.Settings.Sections;
+using osu.Game.Screens.Ranking;
+using OpenTK;
+using OpenTK.Graphics;
+
+namespace osu.Game.Overlays
+{
+    public class MainSettings : SettingsOverlay
+    {
+        private readonly KeyBindingOverlay keyBindingOverlay;
+        private BackButton backButton;
+
+        protected override IEnumerable<SettingsSection> CreateSections() => new SettingsSection[]
+        {
+            new GeneralSection(),
+            new GraphicsSection(),
+            new GameplaySection(),
+            new AudioSection(),
+            new SkinSection(),
+            new InputSection(keyBindingOverlay),
+            new OnlineSection(),
+            new MaintenanceSection(),
+            new DebugSection(),
+        };
+
+        protected override Drawable CreateHeader() => new SettingsHeader("settings", "Change the way osu! behaves");
+        protected override Drawable CreateFooter() => new SettingsFooter();
+
+        public MainSettings()
+            : base(true)
+        {
+            keyBindingOverlay = new KeyBindingOverlay
+            {
+                Depth = 1,
+                Anchor = Anchor.TopRight,
+            };
+            keyBindingOverlay.StateChanged += keyBindingOverlay_StateChanged;
+        }
+
+        public override bool AcceptsFocus => keyBindingOverlay.State != Visibility.Visible;
+
+        private const float hidden_width = 120;
+
+        private void keyBindingOverlay_StateChanged(VisibilityContainer container, Visibility visibility)
+        {
+            switch (visibility)
+            {
+                case Visibility.Visible:
+                    Background.FadeTo(0.9f, 300, Easing.OutQuint);
+                    Sidebar?.FadeColour(Color4.DarkGray, 300, Easing.OutQuint);
+
+                    SectionsContainer.FadeOut(300, Easing.OutQuint);
+                    ContentContainer.MoveToX(hidden_width - WIDTH, 500, Easing.OutQuint);
+
+                    backButton.Delay(100).FadeIn(100);
+                    break;
+                case Visibility.Hidden:
+                    Background.FadeTo(0.6f, 500, Easing.OutQuint);
+                    Sidebar?.FadeColour(Color4.White, 300, Easing.OutQuint);
+
+                    SectionsContainer.FadeIn(500, Easing.OutQuint);
+                    ContentContainer.MoveToX(0, 500, Easing.OutQuint);
+
+                    backButton.FadeOut(100);
+                    break;
+            }
+        }
+
+        protected override float ExpandedPosition => keyBindingOverlay.State == Visibility.Visible ? hidden_width - WIDTH : base.ExpandedPosition;
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            ContentContainer.Add(keyBindingOverlay);
+
+            ContentContainer.Add(backButton = new BackButton
+            {
+                Alpha = 0,
+                Width = hidden_width,
+                RelativeSizeAxes = Axes.Y,
+                Anchor = Anchor.CentreRight,
+                Origin = Anchor.CentreRight,
+                Action = () => keyBindingOverlay.Hide()
+            });
+        }
+
+        private class BackButton : OsuClickableContainer
+        {
+            private AspectContainer aspect;
+
+            [BackgroundDependencyLoader]
+            private void load()
+            {
+                Children = new Drawable[]
+                {
+                    aspect = new AspectContainer
+                    {
+                        Anchor = Anchor.Centre,
+                        Origin = Anchor.Centre,
+                        RelativeSizeAxes = Axes.Y,
+                        Children = new Drawable[]
+                        {
+                            new SpriteIcon
+                            {
+                                Anchor = Anchor.Centre,
+                                Origin = Anchor.Centre,
+                                Y = -15,
+                                Size = new Vector2(15),
+                                Shadow = true,
+                                Icon = FontAwesome.fa_chevron_left
+                            },
+                            new OsuSpriteText
+                            {
+                                Anchor = Anchor.Centre,
+                                Origin = Anchor.Centre,
+                                Y = 15,
+                                TextSize = 12,
+                                Font = @"Exo2.0-Bold",
+                                Text = @"back",
+                            },
+                        }
+                    }
+                };
+            }
+
+            protected override bool OnMouseDown(InputState state, MouseDownEventArgs args)
+            {
+                aspect.ScaleTo(0.75f, 2000, Easing.OutQuint);
+                return base.OnMouseDown(state, args);
+            }
+
+            protected override bool OnMouseUp(InputState state, MouseUpEventArgs args)
+            {
+                aspect.ScaleTo(1, 1000, Easing.OutElastic);
+                return base.OnMouseUp(state, args);
+            }
+        }
+    }
+}

osu.Game/Overlays/Music/PlaylistOverlay.cs

@@ -6,7 +6,6 @@ using System.Linq;
 using osu.Framework.Allocation;
 using osu.Framework.Configuration;
 using osu.Framework.Extensions.Color4Extensions;
-using osu.Framework.Input;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
@@ -31,12 +30,10 @@ namespace osu.Game.Overlays.Music
         private readonly Bindable<WorkingBeatmap> beatmapBacking = new Bindable<WorkingBeatmap>();
 
         public IEnumerable<BeatmapSetInfo> BeatmapSets;
-        private InputManager inputManager;
 
         [BackgroundDependencyLoader]
-        private void load(OsuGameBase game, BeatmapManager beatmaps, OsuColour colours, UserInputManager inputManager)
+        private void load(OsuGameBase game, BeatmapManager beatmaps, OsuColour colours)
         {
-            this.inputManager = inputManager;
             this.beatmaps = beatmaps;
 
             Children = new Drawable[]
@@ -102,7 +99,7 @@ namespace osu.Game.Overlays.Music
         protected override void PopIn()
         {
             filter.Search.HoldFocus = true;
-            Schedule(() => inputManager.ChangeFocus(filter.Search));
+            Schedule(() => GetContainingInputManager().ChangeFocus(filter.Search));
 
             this.ResizeTo(new Vector2(1, playlist_height), transition_duration, Easing.OutQuint);
             this.FadeIn(transition_duration, Easing.OutQuint);

osu.Game/Overlays/OnScreenDisplay.cs

@@ -258,7 +258,10 @@ namespace osu.Game.Overlays
                     Type = EdgeEffectType.Glow,
                     Radius = 8,
                 };
+            }
 
+            protected override void LoadComplete()
+            {
                 updateGlow();
                 FinishTransforms(true);
             }

osu.Game/Overlays/SearchableList/SearchableListOverlay.cs

@@ -103,7 +103,7 @@ namespace osu.Game.Overlays.SearchableList
 
         protected override void OnFocus(InputState state)
         {
-            InputManager.ChangeFocus(Filter.Search);
+            GetContainingInputManager().ChangeFocus(Filter.Search);
         }
 
         protected override void PopIn()

osu.Game/Overlays/Settings/Sections/Audio/AudioDevicesSettings.cs

@@ -26,8 +26,11 @@ namespace osu.Game.Overlays.Settings.Sections.Audio
         {
             base.Dispose(isDisposing);
 
-            audio.OnNewDevice -= onDeviceChanged;
+            if (audio != null)
-            audio.OnLostDevice -= onDeviceChanged;
+            {
+                audio.OnNewDevice -= onDeviceChanged;
+                audio.OnLostDevice -= onDeviceChanged;
+            }
         }
 
         private void updateItems()

osu.Game/Overlays/Settings/Sections/General/LoginSettings.cs

@@ -57,12 +57,9 @@ namespace osu.Game.Overlays.Settings.Sections.General
             Spacing = new Vector2(0f, 5f);
         }
 
-        private InputManager inputManager;
-
         [BackgroundDependencyLoader(permitNulls: true)]
-        private void load(OsuColour colours, APIAccess api, UserInputManager inputManager)
+        private void load(OsuColour colours, APIAccess api)
         {
-            this.inputManager = inputManager;
             this.colours = colours;
 
             api?.Register(this);
@@ -174,7 +171,7 @@ namespace osu.Game.Overlays.Settings.Sections.General
                     break;
             }
 
-            if (form != null) inputManager.ChangeFocus(form);
+            if (form != null) GetContainingInputManager()?.ChangeFocus(form);
         }
 
         public override bool AcceptsFocus => true;
@@ -183,7 +180,7 @@ namespace osu.Game.Overlays.Settings.Sections.General
 
         protected override void OnFocus(InputState state)
         {
-            if (form != null) inputManager.ChangeFocus(form);
+            if (form != null) GetContainingInputManager().ChangeFocus(form);
             base.OnFocus(state);
         }
 
@@ -192,7 +189,6 @@ namespace osu.Game.Overlays.Settings.Sections.General
             private TextBox username;
             private TextBox password;
             private APIAccess api;
-            private InputManager inputManager;
 
             private void performLogin()
             {
@@ -201,9 +197,8 @@ namespace osu.Game.Overlays.Settings.Sections.General
             }
 
             [BackgroundDependencyLoader(permitNulls: true)]
-            private void load(APIAccess api, OsuConfigManager config, UserInputManager inputManager)
+            private void load(APIAccess api, OsuConfigManager config)
             {
-                this.inputManager = inputManager;
                 this.api = api;
                 Direction = FillDirection.Vertical;
                 Spacing = new Vector2(0, 5);
@@ -245,7 +240,7 @@ namespace osu.Game.Overlays.Settings.Sections.General
                     {
                         RelativeSizeAxes = Axes.X,
                         Text = "Register new account",
-                        //Binding = registerLink
+                        //Action = registerLink
                     }
                 };
             }
@@ -256,7 +251,7 @@ namespace osu.Game.Overlays.Settings.Sections.General
 
             protected override void OnFocus(InputState state)
             {
-                Schedule(() => { inputManager.ChangeFocus(string.IsNullOrEmpty(username.Text) ? username : password); });
+                Schedule(() => { GetContainingInputManager().ChangeFocus(string.IsNullOrEmpty(username.Text) ? username : password); });
             }
         }
 

osu.Game/Overlays/Settings/Sections/Input/KeyboardSettings.cs

@@ -10,14 +10,15 @@ namespace osu.Game.Overlays.Settings.Sections.Input
     {
         protected override string Header => "Keyboard";
 
-        public KeyboardSettings()
+        public KeyboardSettings(KeyBindingOverlay keyConfig)
         {
             Children = new Drawable[]
             {
                 new OsuButton
                 {
                     RelativeSizeAxes = Axes.X,
-                    Text = "Key Configuration"
+                    Text = "Key Configuration",
+                    Action = () => keyConfig.ToggleVisibility()
                 },
             };
         }

osu.Game/Overlays/Settings/Sections/InputSection.cs

@@ -12,12 +12,12 @@ namespace osu.Game.Overlays.Settings.Sections
         public override string Header => "Input";
         public override FontAwesome Icon => FontAwesome.fa_keyboard_o;
 
-        public InputSection()
+        public InputSection(KeyBindingOverlay keyConfig)
         {
             Children = new Drawable[]
             {
                 new MouseSettings(),
-                new KeyboardSettings(),
+                new KeyboardSettings(keyConfig),
             };
         }
     }

osu.Game/Overlays/Settings/SettingsHeader.cs

@@ -11,6 +11,15 @@ namespace osu.Game.Overlays.Settings
 {
     public class SettingsHeader : Container
     {
+        private readonly string heading;
+        private readonly string subheading;
+
+        public SettingsHeader(string heading, string subheading)
+        {
+            this.heading = heading;
+            this.subheading = subheading;
+        }
+
         [BackgroundDependencyLoader]
         private void load(OsuColour colours)
         {
@@ -28,7 +37,7 @@ namespace osu.Game.Overlays.Settings
                     {
                         new OsuSpriteText
                         {
-                            Text = "settings",
+                            Text = heading,
                             TextSize = 40,
                             Margin = new MarginPadding
                             {
@@ -39,7 +48,7 @@ namespace osu.Game.Overlays.Settings
                         new OsuSpriteText
                         {
                             Colour = colours.Pink,
-                            Text = "Change the way osu! behaves",
+                            Text = subheading,
                             TextSize = 18,
                             Margin = new MarginPadding
                             {

osu.Game/Overlays/Settings/SettingsSection.cs

@@ -7,7 +7,6 @@ using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
-using osu.Framework.Graphics.Sprites;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Sprites;
 using System.Collections.Generic;
@@ -25,25 +24,38 @@ namespace osu.Game.Overlays.Settings
 
         public IEnumerable<IFilterable> FilterableChildren => Children.OfType<IFilterable>();
         public string[] FilterTerms => new[] { Header };
+
+        private const int header_size = 26;
+        private const int header_margin = 25;
+        private const int border_size = 2;
+
         public bool MatchingFilter
         {
-            set
+            set { this.FadeTo(value ? 1 : 0); }
-            {
-                this.FadeTo(value ? 1 : 0);
-            }
         }
 
-        private readonly SpriteText headerLabel;
-
         protected SettingsSection()
         {
             Margin = new MarginPadding { Top = 20 };
             AutoSizeAxes = Axes.Y;
             RelativeSizeAxes = Axes.X;
 
-            const int header_size = 26;
+            FlowContent = new FillFlowContainer
-            const int header_margin = 25;
+            {
-            const int border_size = 2;
+                Margin = new MarginPadding
+                {
+                    Top = header_size + header_margin
+                },
+                Direction = FillDirection.Vertical,
+                Spacing = new Vector2(0, 30),
+                AutoSizeAxes = Axes.Y,
+                RelativeSizeAxes = Axes.X,
+            };
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(OsuColour colours)
+        {
             AddRangeInternal(new Drawable[]
             {
                 new Box
@@ -65,28 +77,16 @@ namespace osu.Game.Overlays.Settings
                     AutoSizeAxes = Axes.Y,
                     Children = new[]
                     {
-                        headerLabel = new OsuSpriteText
+                        new OsuSpriteText
                         {
                             TextSize = header_size,
                             Text = Header,
+                            Colour = colours.Yellow
                         },
-                        FlowContent = new FillFlowContainer
+                        FlowContent
-                        {
-                            Margin = new MarginPadding { Top = header_size + header_margin },
-                            Direction = FillDirection.Vertical,
-                            Spacing = new Vector2(0, 30),
-                            AutoSizeAxes = Axes.Y,
-                            RelativeSizeAxes = Axes.X,
-                        },
                     }
                 },
             });
         }
-
-        [BackgroundDependencyLoader]
-        private void load(OsuColour colours)
-        {
-            headerLabel.Colour = colours.Yellow;
-        }
     }
-}
+}

osu.Game/Overlays/Settings/Sidebar.cs

@@ -14,12 +14,12 @@ using osu.Game.Overlays.Toolbar;
 
 namespace osu.Game.Overlays.Settings
 {
-    public class Sidebar : Container, IStateful<ExpandedState>
+    public class Sidebar : Container<SidebarButton>, IStateful<ExpandedState>
     {
-        private readonly FillFlowContainer content;
+        private readonly FillFlowContainer<SidebarButton> content;
         internal const float DEFAULT_WIDTH = ToolbarButton.WIDTH;
         internal const int EXPANDED_WIDTH = 200;
-        protected override Container<Drawable> Content => content;
+        protected override Container<SidebarButton> Content => content;
 
         public Sidebar()
         {
@@ -35,7 +35,7 @@ namespace osu.Game.Overlays.Settings
                 {
                     Children = new[]
                     {
-                        content = new FillFlowContainer
+                        content = new FillFlowContainer<SidebarButton>
                         {
                             Origin = Anchor.CentreLeft,
                             Anchor = Anchor.CentreLeft,
@@ -87,6 +87,8 @@ namespace osu.Game.Overlays.Settings
             get { return state; }
             set
             {
+                expandEvent?.Cancel();
+
                 if (state == value) return;
 
                 state = value;

osu.Game/Overlays/SettingsOverlay.cs

@@ -2,9 +2,12 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
 using System;
+using System.Collections.Generic;
 using System.Linq;
+using OpenTK;
 using OpenTK.Graphics;
 using osu.Framework.Allocation;
+using osu.Framework.Extensions.IEnumerableExtensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
@@ -12,11 +15,10 @@ using osu.Framework.Input;
 using osu.Game.Graphics.Containers;
 using osu.Game.Graphics.UserInterface;
 using osu.Game.Overlays.Settings;
-using osu.Game.Overlays.Settings.Sections;
 
 namespace osu.Game.Overlays
 {
-    public class SettingsOverlay : OsuFocusedOverlayContainer
+    public abstract class SettingsOverlay : OsuFocusedOverlayContainer
     {
         internal const float CONTENT_MARGINS = 10;
 
@@ -24,125 +26,152 @@ namespace osu.Game.Overlays
 
         public const float SIDEBAR_WIDTH = Sidebar.DEFAULT_WIDTH;
 
-        private const float width = 400;
+        protected const float WIDTH = 400;
 
         private const float sidebar_padding = 10;
 
-        private Sidebar sidebar;
+        protected Container<Drawable> ContentContainer;
-        private SidebarButton[] sidebarButtons;
+
+        protected override Container<Drawable> Content => ContentContainer;
+
+        protected Sidebar Sidebar;
         private SidebarButton selectedSidebarButton;
 
-        private SettingsSectionsContainer sectionsContainer;
+        protected SettingsSectionsContainer SectionsContainer;
 
         private SearchTextBox searchTextBox;
 
-        private Func<float> getToolbarHeight;
+        /// <summary>
+        /// Provide a source for the toolbar height.
+        /// </summary>
+        public Func<float> GetToolbarHeight;
 
-        public SettingsOverlay()
+        private readonly bool showSidebar;
+
+        protected Box Background;
+
+        protected SettingsOverlay(bool showSidebar)
         {
+            this.showSidebar = showSidebar;
             RelativeSizeAxes = Axes.Y;
             AutoSizeAxes = Axes.X;
         }
 
-        [BackgroundDependencyLoader(permitNulls: true)]
+        protected virtual IEnumerable<SettingsSection> CreateSections() => null;
-        private void load(OsuGame game)
+
+        [BackgroundDependencyLoader]
+        private void load()
         {
-            var sections = new SettingsSection[]
+            InternalChild = ContentContainer = new Container
             {
-                new GeneralSection(),
+                Width = WIDTH,
-                new GraphicsSection(),
+                RelativeSizeAxes = Axes.Y,
-                new GameplaySection(),
+                Children = new Drawable[]
-                new AudioSection(),
-                new SkinSection(),
-                new InputSection(),
-                new OnlineSection(),
-                new MaintenanceSection(),
-                new DebugSection(),
-            };
-            Children = new Drawable[]
-            {
-                new Box
                 {
-                    RelativeSizeAxes = Axes.Both,
+                    Background = new Box
-                    Colour = Color4.Black,
-                    Alpha = 0.6f,
-                },
-                sectionsContainer = new SettingsSectionsContainer
-                {
-                    RelativeSizeAxes = Axes.Y,
-                    Width = width,
-                    Margin = new MarginPadding { Left = SIDEBAR_WIDTH },
-                    ExpandableHeader = new SettingsHeader(),
-                    FixedHeader = searchTextBox = new SearchTextBox
                     {
-                        RelativeSizeAxes = Axes.X,
+                        Anchor = Anchor.TopRight,
-                        Origin = Anchor.TopCentre,
+                        Origin = Anchor.TopRight,
-                        Anchor = Anchor.TopCentre,
+                        Scale = new Vector2(2, 1), // over-extend to the left for transitions
-                        Width = 0.95f,
+                        RelativeSizeAxes = Axes.Both,
-                        Margin = new MarginPadding
+                        Colour = Color4.Black,
-                        {
+                        Alpha = 0.6f,
-                            Top = 20,
-                            Bottom = 20
-                        },
-                        Exit = Hide,
                     },
-                    Children = sections,
+                    SectionsContainer = new SettingsSectionsContainer
-                    Footer = new SettingsFooter()
+                    {
-                },
+                        RelativeSizeAxes = Axes.Both,
-                sidebar = new Sidebar
+                        ExpandableHeader = CreateHeader(),
-                {
+                        FixedHeader = searchTextBox = new SearchTextBox
-                    Width = SIDEBAR_WIDTH,
-                    Children = sidebarButtons = sections.Select(section =>
-                        new SidebarButton
                         {
-                            Section = section,
+                            RelativeSizeAxes = Axes.X,
-                            Action = s =>
+                            Origin = Anchor.TopCentre,
+                            Anchor = Anchor.TopCentre,
+                            Width = 0.95f,
+                            Margin = new MarginPadding
                             {
-                                sectionsContainer.ScrollTo(s);
+                                Top = 20,
-                                sidebar.State = ExpandedState.Contracted;
+                                Bottom = 20
                             },
-                        }
+                            Exit = Hide,
-                    ).ToArray()
+                        },
+                        Footer = CreateFooter()
+                    },
                 }
             };
 
-            selectedSidebarButton = sidebarButtons[0];
+            if (showSidebar)
-            selectedSidebarButton.Selected = true;
-
-            sectionsContainer.SelectedSection.ValueChanged += section =>
             {
-                selectedSidebarButton.Selected = false;
+                AddInternal(Sidebar = new Sidebar { Width = SIDEBAR_WIDTH });
-                selectedSidebarButton = sidebarButtons.Single(b => b.Section == section);
-                selectedSidebarButton.Selected = true;
-            };
 
-            searchTextBox.Current.ValueChanged += newValue => sectionsContainer.SearchContainer.SearchTerm = newValue;
+                SectionsContainer.SelectedSection.ValueChanged += section =>
+                {
+                    selectedSidebarButton.Selected = false;
+                    selectedSidebarButton = Sidebar.Children.Single(b => b.Section == section);
+                    selectedSidebarButton.Selected = true;
+                };
+            }
 
-            getToolbarHeight = () => game?.ToolbarOffset ?? 0;
+            searchTextBox.Current.ValueChanged += newValue => SectionsContainer.SearchContainer.SearchTerm = newValue;
+
+            CreateSections()?.ForEach(AddSection);
         }
 
+        protected void AddSection(SettingsSection section)
+        {
+            SectionsContainer.Add(section);
+
+            if (Sidebar != null)
+            {
+                var button = new SidebarButton
+                {
+                    Section = section,
+                    Action = s =>
+                    {
+                        SectionsContainer.ScrollTo(s);
+                        Sidebar.State = ExpandedState.Contracted;
+                    },
+                };
+
+                Sidebar.Add(button);
+
+                if (selectedSidebarButton == null)
+                {
+                    selectedSidebarButton = Sidebar.Children.First();
+                    selectedSidebarButton.Selected = true;
+                }
+            }
+        }
+
+        protected virtual Drawable CreateHeader() => new Container();
+
+        protected virtual Drawable CreateFooter() => new Container();
+
         protected override void PopIn()
         {
             base.PopIn();
 
-            sectionsContainer.MoveToX(0, TRANSITION_LENGTH, Easing.OutQuint);
+            ContentContainer.MoveToX(ExpandedPosition, TRANSITION_LENGTH, Easing.OutQuint);
-            sidebar.MoveToX(0, TRANSITION_LENGTH, Easing.OutQuint);
+
-            this.FadeTo(1, TRANSITION_LENGTH / 2);
+            Sidebar?.MoveToX(0, TRANSITION_LENGTH, Easing.OutQuint);
+            this.FadeTo(1, TRANSITION_LENGTH, Easing.OutQuint);
 
             searchTextBox.HoldFocus = true;
         }
 
+        protected virtual float ExpandedPosition => 0;
+
         protected override void PopOut()
         {
             base.PopOut();
 
-            sectionsContainer.MoveToX(-width, TRANSITION_LENGTH, Easing.OutQuint);
+            ContentContainer.MoveToX(-WIDTH, TRANSITION_LENGTH, Easing.OutQuint);
-            sidebar.MoveToX(-SIDEBAR_WIDTH, TRANSITION_LENGTH, Easing.OutQuint);
+
-            this.FadeTo(0, TRANSITION_LENGTH / 2);
+            Sidebar?.MoveToX(-SIDEBAR_WIDTH, TRANSITION_LENGTH, Easing.OutQuint);
+            this.FadeTo(0, TRANSITION_LENGTH, Easing.OutQuint);
 
             searchTextBox.HoldFocus = false;
             if (searchTextBox.HasFocus)
-                InputManager.ChangeFocus(null);
+                GetContainingInputManager().ChangeFocus(null);
         }
 
         public override bool AcceptsFocus => true;
@@ -151,7 +180,7 @@ namespace osu.Game.Overlays
 
         protected override void OnFocus(InputState state)
         {
-            InputManager.ChangeFocus(searchTextBox);
+            GetContainingInputManager().ChangeFocus(searchTextBox);
             base.OnFocus(state);
         }
 
@@ -159,11 +188,11 @@ namespace osu.Game.Overlays
         {
             base.UpdateAfterChildren();
 
-            sectionsContainer.Margin = new MarginPadding { Left = sidebar.DrawWidth };
+            ContentContainer.Margin = new MarginPadding { Left = Sidebar?.DrawWidth ?? 0 };
-            sectionsContainer.Padding = new MarginPadding { Top = getToolbarHeight() };
+            ContentContainer.Padding = new MarginPadding { Top = GetToolbarHeight?.Invoke() ?? 0 };
         }
 
-        private class SettingsSectionsContainer : SectionsContainer<SettingsSection>
+        protected class SettingsSectionsContainer : SectionsContainer<SettingsSection>
         {
             public SearchContainer<SettingsSection> SearchContainer;
 

osu.Game/Overlays/Toolbar/Toolbar.cs

@@ -22,8 +22,6 @@ namespace osu.Game.Overlays.Toolbar
 
         private readonly ToolbarUserArea userArea;
 
-        protected override bool HideOnEscape => false;
-
         protected override bool BlockPassThroughMouse => false;
 
         private const double transition_time = 500;
@@ -60,8 +58,8 @@ namespace osu.Game.Overlays.Toolbar
                     AutoSizeAxes = Axes.X,
                     Children = new Drawable[]
                     {
-                        new ToolbarSocialButton(),
                         new ToolbarChatButton(),
+                        new ToolbarSocialButton(),
                         new ToolbarMusicButton(),
                         new ToolbarButton
                         {

osu.Game/Rulesets/Objects/Legacy/ConvertHitObjectParser.cs

@@ -19,147 +19,155 @@ namespace osu.Game.Rulesets.Objects.Legacy
     {
         public override HitObject Parse(string text)
         {
-            string[] split = text.Split(',');
+            try
-            ConvertHitObjectType type = (ConvertHitObjectType)int.Parse(split[3]) & ~ConvertHitObjectType.ColourHax;
-            bool combo = type.HasFlag(ConvertHitObjectType.NewCombo);
-            type &= ~ConvertHitObjectType.NewCombo;
-
-            var soundType = (LegacySoundType)int.Parse(split[4]);
-            var bankInfo = new SampleBankInfo();
-
-            HitObject result = null;
-
-            if ((type & ConvertHitObjectType.Circle) > 0)
             {
-                result = CreateHit(new Vector2(int.Parse(split[0]), int.Parse(split[1])), combo);
+                string[] split = text.Split(',');
 
-                if (split.Length > 5)
+                ConvertHitObjectType type = (ConvertHitObjectType)int.Parse(split[3]) & ~ConvertHitObjectType.ColourHax;
-                    readCustomSampleBanks(split[5], bankInfo);
+                bool combo = type.HasFlag(ConvertHitObjectType.NewCombo);
-            }
+                type &= ~ConvertHitObjectType.NewCombo;
-            else if ((type & ConvertHitObjectType.Slider) > 0)
-            {
-                CurveType curveType = CurveType.Catmull;
-                double length = 0;
-                var points = new List<Vector2> { new Vector2(int.Parse(split[0]), int.Parse(split[1])) };
 
-                string[] pointsplit = split[5].Split('|');
+                var soundType = (LegacySoundType)int.Parse(split[4]);
-                foreach (string t in pointsplit)
+                var bankInfo = new SampleBankInfo();
+
+                HitObject result = null;
+
+                if ((type & ConvertHitObjectType.Circle) > 0)
                 {
-                    if (t.Length == 1)
+                    result = CreateHit(new Vector2(int.Parse(split[0]), int.Parse(split[1])), combo);
+
+                    if (split.Length > 5)
+                        readCustomSampleBanks(split[5], bankInfo);
+                }
+                else if ((type & ConvertHitObjectType.Slider) > 0)
+                {
+                    CurveType curveType = CurveType.Catmull;
+                    double length = 0;
+                    var points = new List<Vector2> { new Vector2(int.Parse(split[0]), int.Parse(split[1])) };
+
+                    string[] pointsplit = split[5].Split('|');
+                    foreach (string t in pointsplit)
                     {
-                        switch (t)
+                        if (t.Length == 1)
                         {
-                            case @"C":
+                            switch (t)
-                                curveType = CurveType.Catmull;
+                            {
-                                break;
+                                case @"C":
-                            case @"B":
+                                    curveType = CurveType.Catmull;
-                                curveType = CurveType.Bezier;
+                                    break;
-                                break;
+                                case @"B":
-                            case @"L":
+                                    curveType = CurveType.Bezier;
-                                curveType = CurveType.Linear;
+                                    break;
-                                break;
+                                case @"L":
-                            case @"P":
+                                    curveType = CurveType.Linear;
-                                curveType = CurveType.PerfectCurve;
+                                    break;
-                                break;
+                                case @"P":
+                                    curveType = CurveType.PerfectCurve;
+                                    break;
+                            }
+                            continue;
                         }
-                        continue;
+
+                        string[] temp = t.Split(':');
+                        points.Add(new Vector2((int)Convert.ToDouble(temp[0], CultureInfo.InvariantCulture), (int)Convert.ToDouble(temp[1], CultureInfo.InvariantCulture)));
                     }
 
-                    string[] temp = t.Split(':');
+                    int repeatCount = Convert.ToInt32(split[6], CultureInfo.InvariantCulture);
-                    points.Add(new Vector2((int)Convert.ToDouble(temp[0], CultureInfo.InvariantCulture), (int)Convert.ToDouble(temp[1], CultureInfo.InvariantCulture)));
-                }
 
-                int repeatCount = Convert.ToInt32(split[6], CultureInfo.InvariantCulture);
+                    if (repeatCount > 9000)
+                        throw new ArgumentOutOfRangeException(nameof(repeatCount), @"Repeat count is way too high");
 
-                if (repeatCount > 9000)
+                    if (split.Length > 7)
-                    throw new ArgumentOutOfRangeException(nameof(repeatCount), @"Repeat count is way too high");
+                        length = Convert.ToDouble(split[7], CultureInfo.InvariantCulture);
 
-                if (split.Length > 7)
+                    if (split.Length > 10)
-                    length = Convert.ToDouble(split[7], CultureInfo.InvariantCulture);
+                        readCustomSampleBanks(split[10], bankInfo);
 
-                if (split.Length > 10)
+                    // One node for each repeat + the start and end nodes
-                    readCustomSampleBanks(split[10], bankInfo);
+                    // Note that the first length of the slider is considered a repeat, but there are no actual repeats happening
+                    int nodes = Math.Max(0, repeatCount - 1) + 2;
 
-                // One node for each repeat + the start and end nodes
+                    // Populate node sample bank infos with the default hit object sample bank
-                // Note that the first length of the slider is considered a repeat, but there are no actual repeats happening
+                    var nodeBankInfos = new List<SampleBankInfo>();
-                int nodes = Math.Max(0, repeatCount - 1) + 2;
-
-                // Populate node sample bank infos with the default hit object sample bank
-                var nodeBankInfos = new List<SampleBankInfo>();
-                for (int i = 0; i < nodes; i++)
-                    nodeBankInfos.Add(bankInfo.Clone());
-
-                // Read any per-node sample banks
-                if (split.Length > 9 && split[9].Length > 0)
-                {
-                    string[] sets = split[9].Split('|');
                     for (int i = 0; i < nodes; i++)
+                        nodeBankInfos.Add(bankInfo.Clone());
+
+                    // Read any per-node sample banks
+                    if (split.Length > 9 && split[9].Length > 0)
                     {
-                        if (i >= sets.Length)
+                        string[] sets = split[9].Split('|');
-                            break;
+                        for (int i = 0; i < nodes; i++)
+                        {
+                            if (i >= sets.Length)
+                                break;
 
-                        SampleBankInfo info = nodeBankInfos[i];
+                            SampleBankInfo info = nodeBankInfos[i];
-                        readCustomSampleBanks(sets[i], info);
+                            readCustomSampleBanks(sets[i], info);
+                        }
                     }
-                }
 
-                // Populate node sound types with the default hit object sound type
+                    // Populate node sound types with the default hit object sound type
-                var nodeSoundTypes = new List<LegacySoundType>();
+                    var nodeSoundTypes = new List<LegacySoundType>();
-                for (int i = 0; i < nodes; i++)
-                    nodeSoundTypes.Add(soundType);
-
-                // Read any per-node sound types
-                if (split.Length > 8 && split[8].Length > 0)
-                {
-                    string[] adds = split[8].Split('|');
                     for (int i = 0; i < nodes; i++)
+                        nodeSoundTypes.Add(soundType);
+
+                    // Read any per-node sound types
+                    if (split.Length > 8 && split[8].Length > 0)
                     {
-                        if (i >= adds.Length)
+                        string[] adds = split[8].Split('|');
-                            break;
+                        for (int i = 0; i < nodes; i++)
+                        {
+                            if (i >= adds.Length)
+                                break;
 
-                        int sound;
+                            int sound;
-                        int.TryParse(adds[i], out sound);
+                            int.TryParse(adds[i], out sound);
-                        nodeSoundTypes[i] = (LegacySoundType)sound;
+                            nodeSoundTypes[i] = (LegacySoundType)sound;
+                        }
                     }
+
+                    // Generate the final per-node samples
+                    var nodeSamples = new List<SampleInfoList>(nodes);
+                    for (int i = 0; i <= repeatCount; i++)
+                        nodeSamples.Add(convertSoundType(nodeSoundTypes[i], nodeBankInfos[i]));
+
+                    result = CreateSlider(new Vector2(int.Parse(split[0]), int.Parse(split[1])), combo, points, length, curveType, repeatCount, nodeSamples);
                 }
-
+                else if ((type & ConvertHitObjectType.Spinner) > 0)
-                // Generate the final per-node samples
-                var nodeSamples = new List<SampleInfoList>(nodes);
-                for (int i = 0; i <= repeatCount; i++)
-                    nodeSamples.Add(convertSoundType(nodeSoundTypes[i], nodeBankInfos[i]));
-
-                result = CreateSlider(new Vector2(int.Parse(split[0]), int.Parse(split[1])), combo, points, length, curveType, repeatCount, nodeSamples);
-            }
-            else if ((type & ConvertHitObjectType.Spinner) > 0)
-            {
-                result = CreateSpinner(new Vector2(512, 384) / 2, Convert.ToDouble(split[5], CultureInfo.InvariantCulture));
-
-                if (split.Length > 6)
-                    readCustomSampleBanks(split[6], bankInfo);
-            }
-            else if ((type & ConvertHitObjectType.Hold) > 0)
-            {
-                // Note: Hold is generated by BMS converts
-
-                double endTime = Convert.ToDouble(split[2], CultureInfo.InvariantCulture);
-
-                if (split.Length > 5 && !string.IsNullOrEmpty(split[5]))
                 {
-                    string[] ss = split[5].Split(':');
+                    result = CreateSpinner(new Vector2(512, 384) / 2, Convert.ToDouble(split[5], CultureInfo.InvariantCulture));
-                    endTime = Convert.ToDouble(ss[0], CultureInfo.InvariantCulture);
+
-                    readCustomSampleBanks(string.Join(":", ss.Skip(1)), bankInfo);
+                    if (split.Length > 6)
+                        readCustomSampleBanks(split[6], bankInfo);
+                }
+                else if ((type & ConvertHitObjectType.Hold) > 0)
+                {
+                    // Note: Hold is generated by BMS converts
+
+                    double endTime = Convert.ToDouble(split[2], CultureInfo.InvariantCulture);
+
+                    if (split.Length > 5 && !string.IsNullOrEmpty(split[5]))
+                    {
+                        string[] ss = split[5].Split(':');
+                        endTime = Convert.ToDouble(ss[0], CultureInfo.InvariantCulture);
+                        readCustomSampleBanks(string.Join(":", ss.Skip(1)), bankInfo);
+                    }
+
+                    result = CreateHold(new Vector2(int.Parse(split[0]), int.Parse(split[1])), combo, endTime);
                 }
 
-                result = CreateHold(new Vector2(int.Parse(split[0]), int.Parse(split[1])), combo, endTime);
+                if (result == null)
+                    throw new InvalidOperationException($@"Unknown hit object type {type}.");
+
+                result.StartTime = Convert.ToDouble(split[2], CultureInfo.InvariantCulture);
+                result.Samples = convertSoundType(soundType, bankInfo);
+
+                return result;
+            }
+            catch (FormatException)
+            {
+                throw new FormatException("One or more hit objects were malformed.");
             }
-
-            if (result == null)
-                throw new InvalidOperationException($@"Unknown hit object type {type}.");
-
-            result.StartTime = Convert.ToDouble(split[2], CultureInfo.InvariantCulture);
-            result.Samples = convertSoundType(soundType, bankInfo);
-
-            return result;
         }
 
         private void readCustomSampleBanks(string str, SampleBankInfo bankInfo)

osu.Game/Rulesets/Ruleset.cs

@@ -8,6 +8,7 @@ using osu.Game.Rulesets.UI;
 using osu.Game.Screens.Play;
 using System.Collections.Generic;
 using osu.Framework.Graphics;
+using osu.Framework.Input.Bindings;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Overlays.Settings;
 
@@ -53,5 +54,17 @@ namespace osu.Game.Rulesets
         /// Do not override this unless you are a legacy mode.
         /// </summary>
         public virtual int LegacyID => -1;
+
+        /// <summary>
+        /// A list of available variant ids.
+        /// </summary>
+        public virtual IEnumerable<int> AvailableVariants => new[] { 0 };
+
+        /// <summary>
+        /// Get a list of default keys for the specified variant.
+        /// </summary>
+        /// <param name="variant">A variant.</param>
+        /// <returns>A list of valid <see cref="KeyBinding"/>s.</returns>
+        public virtual IEnumerable<KeyBinding> GetDefaultKeyBindings(int variant = 0) => new KeyBinding[] { };
     }
 }

osu.Game/Rulesets/UI/RulesetContainer.cs

@@ -76,7 +76,7 @@ namespace osu.Game.Rulesets.UI
         internal RulesetContainer(Ruleset ruleset)
         {
             Ruleset = ruleset;
-            KeyConversionInputManager = CreateActionMappingInputManager();
+            KeyConversionInputManager = CreateKeyBindingInputManager();
             KeyConversionInputManager.RelativeSizeAxes = Axes.Both;
         }
 
@@ -95,7 +95,7 @@ namespace osu.Game.Rulesets.UI
         /// Creates a key conversion input manager.
         /// </summary>
         /// <returns>The input manager.</returns>
-        protected virtual PassThroughInputManager CreateActionMappingInputManager() => new PassThroughInputManager();
+        public virtual PassThroughInputManager CreateKeyBindingInputManager() => new PassThroughInputManager();
 
         protected virtual FramedReplayInputHandler CreateReplayInputHandler(Replay replay) => new FramedReplayInputHandler(replay);
 

osu.Game/Screens/BackgroundScreen.cs

@@ -37,7 +37,7 @@ namespace osu.Game.Screens
             }
 
             // Make sure the in-progress loading is complete before pushing the screen.
-            while (screen.LoadState < LoadState.Loaded)
+            while (screen.LoadState < LoadState.Ready)
                 Thread.Sleep(1);
 
             base.Push(screen);

osu.Game/Screens/Play/KeyCounterCollection.cs

@@ -108,7 +108,7 @@ namespace osu.Game.Screens.Play
             }
         }
 
-        public override bool HandleInput => receptor?.IsAlive != true;
+        public override bool HandleInput => receptor == null;
 
         private Receptor receptor;
 

osu.Game/Screens/Play/MenuOverlay.cs

@@ -22,8 +22,6 @@ namespace osu.Game.Screens.Play
         private const int button_height = 70;
         private const float background_alpha = 0.75f;
 
-        protected override bool HideOnEscape => false;
-
         protected override bool BlockPassThroughKeyboard => true;
 
         public Action OnRetry;
@@ -95,7 +93,8 @@ namespace osu.Game.Screens.Play
                 Origin = Anchor.TopCentre,
                 Anchor = Anchor.TopCentre,
                 Height = button_height,
-                Action = delegate {
+                Action = delegate
+                {
                     action?.Invoke();
                     Hide();
                 }

osu.Game/Screens/Play/SkipButton.cs

@@ -227,9 +227,9 @@ namespace osu.Game.Screens.Play
                                 Direction = FillDirection.Horizontal,
                                 Children = new[]
                                 {
-                                    new SpriteIcon { Icon = FontAwesome.fa_chevron_right },
+                                    new SpriteIcon { Size = new Vector2(15), Shadow = true, Icon = FontAwesome.fa_chevron_right },
-                                    new SpriteIcon { Icon = FontAwesome.fa_chevron_right },
+                                    new SpriteIcon { Size = new Vector2(15), Shadow = true, Icon = FontAwesome.fa_chevron_right },
-                                    new SpriteIcon { Icon = FontAwesome.fa_chevron_right },
+                                    new SpriteIcon { Size = new Vector2(15), Shadow = true, Icon = FontAwesome.fa_chevron_right },
                                 }
                             },
                             new OsuSpriteText

osu.Game/Screens/Play/SongProgress.cs

@@ -18,8 +18,6 @@ namespace osu.Game.Screens.Play
     {
         private const int bottom_bar_height = 5;
 
-        protected override bool HideOnEscape => false;
-
         private static readonly Vector2 handle_size = new Vector2(14, 25);
 
         private const float transition_duration = 200;

osu.Game/Screens/Select/BeatmapInfoWedge.cs

@@ -50,8 +50,6 @@ namespace osu.Game.Screens.Select
             AlwaysPresent = true;
         }
 
-        protected override bool HideOnEscape => false;
-
         protected override bool BlockPassThroughMouse => false;
 
         protected override void PopIn()

osu.Game/Screens/Select/FilterControl.cs

@@ -153,7 +153,7 @@ namespace osu.Game.Screens.Select
         {
             searchTextBox.HoldFocus = false;
             if (searchTextBox.HasFocus)
-                inputManager.ChangeFocus(searchTextBox);
+                GetContainingInputManager().ChangeFocus(searchTextBox);
         }
 
         public void Activate()
@@ -163,13 +163,9 @@ namespace osu.Game.Screens.Select
 
         private readonly Bindable<RulesetInfo> ruleset = new Bindable<RulesetInfo>();
 
-        private InputManager inputManager;
-
         [BackgroundDependencyLoader(permitNulls: true)]
-        private void load(OsuColour colours, OsuGame osu, UserInputManager inputManager)
+        private void load(OsuColour colours, OsuGame osu)
         {
-            this.inputManager = inputManager;
-
             sortTabs.AccentColour = colours.GreenLight;
 
             if (osu != null)

osu.Game/Screens/Select/Footer.cs

@@ -39,7 +39,7 @@ namespace osu.Game.Screens.Select
         /// <param name="text">Text on the button.</param>
         /// <param name="colour">Colour of the button.</param>
         /// <param name="hotkey">Hotkey of the button.</param>
-        /// <param name="action">Binding the button does.</param>
+        /// <param name="action">Action the button does.</param>
         /// <param name="depth">
         /// <para>Higher depth to be put on the left, and lower to be put on the right.</para>
         /// <para>Notice this is different to <see cref="Options.BeatmapOptionsOverlay"/>!</para>

osu.Game/Screens/Select/Leaderboards/LeaderboardScore.cs

@@ -373,6 +373,7 @@ namespace osu.Game.Screens.Select.Leaderboards
                         Icon = FontAwesome.fa_square,
                         Colour = OsuColour.FromHex(@"3087ac"),
                         Rotation = 45,
+                        Size = new Vector2(20),
                         Shadow = true,
                     },
                     new SpriteIcon
@@ -380,7 +381,7 @@ namespace osu.Game.Screens.Select.Leaderboards
                         Origin = Anchor.Centre,
                         Icon = icon,
                         Colour = OsuColour.FromHex(@"a4edff"),
-                        Scale = new Vector2(0.8f),
+                        Size = new Vector2(14),
                     },
                     new GlowingSpriteText(value, @"Exo2.0-Bold", 17, Color4.White, OsuColour.FromHex(@"83ccfa"))
                     {

osu.Game/Screens/Select/SongSelect.cs

@@ -156,11 +156,11 @@ namespace osu.Game.Screens.Select
         }
 
         [BackgroundDependencyLoader(permitNulls: true)]
-        private void load(BeatmapManager beatmaps, AudioManager audio, DialogOverlay dialog, OsuGame osu, OsuColour colours, UserInputManager input)
+        private void load(BeatmapManager beatmaps, AudioManager audio, DialogOverlay dialog, OsuGame osu, OsuColour colours)
         {
             if (Footer != null)
             {
-                Footer.AddButton(@"random", colours.Green, () => triggerRandom(input), Key.F2);
+                Footer.AddButton(@"random", colours.Green, triggerRandom, Key.F2);
                 Footer.AddButton(@"options", colours.Blue, BeatmapOptions.ToggleVisibility, Key.F3);
 
                 BeatmapOptions.AddButton(@"Delete", @"Beatmap", FontAwesome.fa_trash, colours.Pink, promptDelete, Key.Number4, float.MaxValue);
@@ -265,9 +265,9 @@ namespace osu.Game.Screens.Select
             }
         }
 
-        private void triggerRandom(UserInputManager input)
+        private void triggerRandom()
         {
-            if (input.CurrentState.Keyboard.ShiftPressed)
+            if (GetContainingInputManager().CurrentState.Keyboard.ShiftPressed)
                 carousel.SelectPreviousRandom();
             else
                 carousel.SelectNextRandom();

osu.Game/osu.Game.csproj

@@ -94,14 +94,20 @@
     <Compile Include="Graphics\UserInterface\OsuContextMenuItem.cs" />
     <Compile Include="Input\Bindings\DatabasedKeyBinding.cs" />
     <Compile Include="Input\Bindings\DatabasedKeyBindingInputManager.cs" />
-    <Compile Include="Input\BindingStore.cs" />
+    <Compile Include="Input\KeyBindingStore.cs" />
-    <Compile Include="Input\Bindings\GlobalBindingInputManager.cs" />
+    <Compile Include="Input\Bindings\GlobalKeyBindingInputManager.cs" />
     <Compile Include="IO\FileStore.cs" />
     <Compile Include="IO\FileInfo.cs" />
     <Compile Include="Online\API\Requests\GetUsersRequest.cs" />
     <Compile Include="Online\API\Requests\PostMessageRequest.cs" />
     <Compile Include="Online\Chat\ErrorMessage.cs" />
     <Compile Include="Overlays\Chat\ChatTabControl.cs" />
+    <Compile Include="Overlays\KeyBinding\GlobalKeyBindingsSection.cs" />
+    <Compile Include="Overlays\KeyBinding\KeyBindingRow.cs" />
+    <Compile Include="Overlays\KeyBinding\KeyBindingsSection.cs" />
+    <Compile Include="Overlays\KeyBindingOverlay.cs" />
+    <Compile Include="Overlays\KeyBinding\RulesetBindingsSection.cs" />
+    <Compile Include="Overlays\MainSettings.cs" />
     <Compile Include="Overlays\Music\CollectionsDropdown.cs" />
     <Compile Include="Overlays\Music\FilterControl.cs" />
     <Compile Include="Overlays\Music\PlaylistItem.cs" />