Merge branch 'master' into fix-sv

osu.Desktop/Overlays/VersionManager.cs

@@ -27,9 +27,6 @@ namespace osu.Desktop.Overlays
         private NotificationOverlay notificationOverlay;
         private GameHost host;
 
-        public override bool HandleNonPositionalInput => false;
-        public override bool HandlePositionalInput => false;
-
         [BackgroundDependencyLoader]
         private void load(NotificationOverlay notification, OsuColour colours, TextureStore textures, OsuGameBase game, OsuConfigManager config, GameHost host)
         {

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

@@ -5,6 +5,7 @@ using System;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Game.Beatmaps;
+using osu.Game.Configuration;
 using osu.Game.Rulesets.Catch.Objects;
 using osu.Game.Rulesets.Catch.Objects.Drawable;
 using osu.Game.Rulesets.Judgements;
@@ -24,6 +25,8 @@ namespace osu.Game.Rulesets.Catch.UI
 
         protected override bool UserScrollSpeedAdjustment => false;
 
+        protected override SpeedChangeVisualisationMethod VisualisationMethod => SpeedChangeVisualisationMethod.Constant;
+
         public CatchPlayfield(BeatmapDifficulty difficulty, Func<CatchHitObject, DrawableHitObject<CatchHitObject>> getVisualRepresentation)
             : base(BASE_WIDTH)
         {
@@ -55,6 +58,8 @@ namespace osu.Game.Rulesets.Catch.UI
                     RelativeSizeAxes = Axes.Both,
                 },
             });
+
+            VisibleTimeRange.Value = BeatmapDifficulty.DifficultyRange(difficulty.ApproachRate, 1800, 1200, 450);
         }
 
         public bool CheckIfWeCanCatch(CatchHitObject obj) => catcherArea.AttemptCatch(obj);

osu.Game.Rulesets.Mania/UI/DrawableManiaJudgement.cs

@@ -30,10 +30,11 @@ namespace osu.Game.Rulesets.Mania.UI
 
             if (Result.IsHit)
             {
-                this.ScaleTo(0.8f);
+                JudgementBody.ScaleTo(0.8f);
-                this.ScaleTo(1, 250, Easing.OutElastic);
+                JudgementBody.ScaleTo(1, 250, Easing.OutElastic);
 
-                this.Delay(50).FadeOut(200).ScaleTo(0.75f, 250);
+                JudgementBody.Delay(50).ScaleTo(0.75f, 250);
+                this.Delay(50).FadeOut(200);
             }
 
             Expire();

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

@@ -12,6 +12,9 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
 {
     public class CirclePiece : Container, IKeyBindingHandler<OsuAction>
     {
+        // IsHovered is used
+        public override bool HandlePositionalInput => true;
+
         public Func<bool> Hit;
 
         public CirclePiece()

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

@@ -5,11 +5,11 @@ using System.Linq;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
-using osu.Framework.Input.EventArgs;
+using osu.Framework.Input.Events;
-using osu.Framework.Input.States;
 using osu.Game.Rulesets.Objects.Types;
 using OpenTK.Graphics;
 using osu.Game.Skinning;
+using OpenTK;
 
 namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
 {
@@ -102,24 +102,24 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
             };
         }
 
-        private InputState lastState;
+        private Vector2? lastScreenSpaceMousePosition;
 
-        protected override bool OnMouseDown(InputState state, MouseDownEventArgs args)
+        protected override bool OnMouseDown(MouseDownEvent e)
         {
-            lastState = state;
+            lastScreenSpaceMousePosition = e.ScreenSpaceMousePosition;
-            return base.OnMouseDown(state, args);
+            return base.OnMouseDown(e);
         }
 
-        protected override bool OnMouseUp(InputState state, MouseUpEventArgs args)
+        protected override bool OnMouseUp(MouseUpEvent e)
         {
-            lastState = state;
+            lastScreenSpaceMousePosition = e.ScreenSpaceMousePosition;
-            return base.OnMouseUp(state, args);
+            return base.OnMouseUp(e);
         }
 
-        protected override bool OnMouseMove(InputState state)
+        protected override bool OnMouseMove(MouseMoveEvent e)
         {
-            lastState = state;
+            lastScreenSpaceMousePosition = e.ScreenSpaceMousePosition;
-            return base.OnMouseMove(state);
+            return base.OnMouseMove(e);
         }
 
         public override void ClearTransformsAfter(double time, bool propagateChildren = false, string targetMember = null)
@@ -155,8 +155,8 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
             {
                 // Make sure to use the base version of ReceivePositionalInputAt so that we correctly check the position.
                 Tracking = canCurrentlyTrack
-                           && lastState != null
+                           && lastScreenSpaceMousePosition.HasValue
-                           && ReceivePositionalInputAt(lastState.Mouse.NativeState.Position)
+                           && ReceivePositionalInputAt(lastScreenSpaceMousePosition.Value)
                            && (drawableSlider?.OsuActionInputManager?.PressedActions.Any(x => x == OsuAction.LeftButton || x == OsuAction.RightButton) ?? false);
             }
         }

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

@@ -11,9 +11,6 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
 {
     public class SpinnerBackground : CircularContainer, IHasAccentColour
     {
-        public override bool HandleNonPositionalInput => false;
-        public override bool HandlePositionalInput => false;
-
         protected Box Disc;
 
         public Color4 AccentColour

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

@@ -4,7 +4,7 @@
 using System;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
-using osu.Framework.Input.States;
+using osu.Framework.Input.Events;
 using osu.Game.Graphics;
 using OpenTK;
 using OpenTK.Graphics;
@@ -68,10 +68,10 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
             }
         }
 
-        protected override bool OnMouseMove(InputState state)
+        protected override bool OnMouseMove(MouseMoveEvent e)
         {
-            mousePosition = Parent.ToLocalSpace(state.Mouse.NativeState.Position);
+            mousePosition = Parent.ToLocalSpace(e.ScreenSpaceMousePosition);
-            return base.OnMouseMove(state);
+            return base.OnMouseMove(e);
         }
 
         private Vector2 mousePosition;

osu.Game.Rulesets.Osu/OsuInputManager.cs

@@ -4,8 +4,7 @@
 using System.Collections.Generic;
 using System.ComponentModel;
 using osu.Framework.Input.Bindings;
-using osu.Framework.Input.EventArgs;
+using osu.Framework.Input.Events;
-using osu.Framework.Input.States;
 using osu.Game.Rulesets.UI;
 
 namespace osu.Game.Rulesets.Osu
@@ -36,13 +35,11 @@ namespace osu.Game.Rulesets.Osu
             {
             }
 
-            protected override bool OnKeyDown(InputState state, KeyDownEventArgs args) => AllowUserPresses && base.OnKeyDown(state, args);
+            protected override bool Handle(UIEvent e)
-            protected override bool OnKeyUp(InputState state, KeyUpEventArgs args) => AllowUserPresses && base.OnKeyUp(state, args);
+            {
-            protected override bool OnJoystickPress(InputState state, JoystickEventArgs args) => AllowUserPresses && base.OnJoystickPress(state, args);
+                if (!AllowUserPresses) return false;
-            protected override bool OnJoystickRelease(InputState state, JoystickEventArgs args) => AllowUserPresses && base.OnJoystickRelease(state, args);
+                return base.Handle(e);
-            protected override bool OnMouseDown(InputState state, MouseDownEventArgs args) => AllowUserPresses && base.OnMouseDown(state, args);
+            }
-            protected override bool OnMouseUp(InputState state, MouseUpEventArgs args) => AllowUserPresses && base.OnMouseUp(state, args);
-            protected override bool OnScroll(InputState state) => AllowUserPresses && base.OnScroll(state);
         }
     }
 

osu.Game.Rulesets.Osu/UI/Cursor/CursorTrail.cs

@@ -12,7 +12,7 @@ using osu.Framework.Graphics.Primitives;
 using osu.Framework.Graphics.Shaders;
 using osu.Framework.Graphics.Textures;
 using osu.Framework.Input;
-using osu.Framework.Input.States;
+using osu.Framework.Input.Events;
 using osu.Framework.Timing;
 using OpenTK;
 using OpenTK.Graphics;
@@ -117,15 +117,15 @@ namespace osu.Game.Rulesets.Osu.UI.Cursor
             timeOffset = Time.Current;
         }
 
-        protected override bool OnMouseMove(InputState state)
+        protected override bool OnMouseMove(MouseMoveEvent e)
         {
-            Vector2 pos = state.Mouse.NativeState.Position;
+            Vector2 pos = e.ScreenSpaceMousePosition;
 
             if (lastPosition == null)
             {
                 lastPosition = pos;
                 resampler.AddPosition(lastPosition.Value);
-                return base.OnMouseMove(state);
+                return base.OnMouseMove(e);
             }
 
             foreach (Vector2 pos2 in resampler.AddPosition(pos))
@@ -147,7 +147,7 @@ namespace osu.Game.Rulesets.Osu.UI.Cursor
                 }
             }
 
-            return base.OnMouseMove(state);
+            return base.OnMouseMove(e);
         }
 
         private void addPosition(Vector2 pos)

osu.Game.Rulesets.Taiko/UI/DrawableTaikoJudgement.cs

@@ -31,10 +31,10 @@ namespace osu.Game.Rulesets.Taiko.UI
             switch (Result.Type)
             {
                 case HitResult.Good:
-                    Colour = colours.GreenLight;
+                    JudgementBody.Colour = colours.GreenLight;
                     break;
                 case HitResult.Great:
-                    Colour = colours.BlueLight;
+                    JudgementBody.Colour = colours.BlueLight;
                     break;
             }
         }

osu.Game.Rulesets.Taiko/UI/TaikoPlayfield.cs

@@ -1,23 +1,24 @@
 // Copyright (c) 2007-2018 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.Framework.Graphics.Shapes;
-using osu.Game.Rulesets.Taiko.Objects;
-using OpenTK;
-using OpenTK.Graphics;
-using osu.Game.Rulesets.Taiko.Judgements;
-using osu.Game.Rulesets.Objects.Drawables;
-using osu.Game.Graphics;
-using osu.Framework.Graphics.Containers;
-using osu.Framework.Extensions.Color4Extensions;
 using System.Linq;
-using osu.Game.Rulesets.Judgements;
+using osu.Framework.Allocation;
-using osu.Game.Rulesets.Taiko.Objects.Drawables;
+using osu.Framework.Extensions.Color4Extensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
 using osu.Game.Beatmaps.ControlPoints;
+using osu.Game.Configuration;
+using osu.Game.Graphics;
+using osu.Game.Rulesets.Objects.Drawables;
+using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.UI;
 using osu.Game.Rulesets.UI.Scrolling;
+using osu.Game.Rulesets.Taiko.Objects;
+using osu.Game.Rulesets.Taiko.Objects.Drawables;
+using osu.Game.Rulesets.Taiko.Judgements;
+using OpenTK;
+using OpenTK.Graphics;
 
 namespace osu.Game.Rulesets.Taiko.UI
 {
@@ -40,6 +41,8 @@ namespace osu.Game.Rulesets.Taiko.UI
 
         protected override bool UserScrollSpeedAdjustment => false;
 
+        protected override SpeedChangeVisualisationMethod VisualisationMethod => SpeedChangeVisualisationMethod.Overlapping;
+
         private readonly Container<HitExplosion> hitExplosionContainer;
         private readonly Container<KiaiHitExplosion> kiaiExplosionContainer;
         private readonly JudgementContainer<DrawableTaikoJudgement> judgementContainer;

osu.Game.Tests/Beatmaps/Formats/LegacyBeatmapDecoderTest.cs

@@ -165,7 +165,7 @@ namespace osu.Game.Tests.Beatmaps.Formats
         }
 
         [Test]
-        public void TestDecodeBeatmapColors()
+        public void TestDecodeBeatmapColours()
         {
             var decoder = new LegacySkinDecoder();
             using (var resStream = Resource.OpenResource("Soleily - Renatus (Gamu) [Insane].osu"))
@@ -181,6 +181,7 @@ namespace osu.Game.Tests.Beatmaps.Formats
                     new Color4(128, 255, 128, 255),
                     new Color4(255, 187, 255, 255),
                     new Color4(255, 177, 140, 255),
+                    new Color4(100, 100, 100, 100),
                 };
                 Assert.AreEqual(expectedColors.Length, comboColors.Count);
                 for (int i = 0; i < expectedColors.Length; i++)

osu.Game.Tests/Resources/Soleily - Renatus (Gamu) [Insane].osu

@@ -101,6 +101,7 @@ Combo3 : 128,255,255
 Combo4 : 128,255,128
 Combo5 : 255,187,255
 Combo6 : 255,177,140
+Combo7 : 100,100,100,100
 
 [HitObjects]
 192,168,956,6,0,P|184:128|200:80,1,90,4|0,1:2|0:0,0:0:0:0:

osu.Game.Tests/Visual/TestCaseCursors.cs

@@ -7,7 +7,7 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Cursor;
 using osu.Framework.Graphics.Shapes;
-using osu.Framework.Input.States;
+using osu.Framework.Input.Events;
 using osu.Framework.MathUtils;
 using osu.Game.Graphics.Cursor;
 using osu.Game.Graphics.Sprites;
@@ -184,7 +184,7 @@ namespace osu.Game.Tests.Visual
         /// </summary>
         /// <param name="cursorContainer">The cursor to check.</param>
         private bool checkAtMouse(CursorContainer cursorContainer)
-            => Precision.AlmostEquals(InputManager.CurrentState.Mouse.NativeState.Position, cursorContainer.ToScreenSpace(cursorContainer.ActiveCursor.DrawPosition));
+            => Precision.AlmostEquals(InputManager.CurrentState.Mouse.Position, cursorContainer.ToScreenSpace(cursorContainer.ActiveCursor.DrawPosition));
 
         private class CustomCursorBox : Container, IProvideCursor
         {
@@ -224,16 +224,16 @@ namespace osu.Game.Tests.Visual
                 };
             }
 
-            protected override bool OnHover(InputState state)
+            protected override bool OnHover(HoverEvent e)
             {
                 background.FadeTo(0.4f, 250, Easing.OutQuint);
                 return false;
             }
 
-            protected override void OnHoverLost(InputState state)
+            protected override void OnHoverLost(HoverLostEvent e)
             {
                 background.FadeTo(0.1f, 250);
-                base.OnHoverLost(state);
+                base.OnHoverLost(e);
             }
         }
 

osu.Game/Beatmaps/Formats/LegacyDecoder.cs

@@ -85,13 +85,19 @@ namespace osu.Game.Beatmaps.Formats
 
             string[] split = pair.Value.Split(',');
 
-            if (split.Length != 3)
+            if (split.Length != 3 && split.Length != 4)
-                throw new InvalidOperationException($@"Color specified in incorrect format (should be R,G,B): {pair.Value}");
+                throw new InvalidOperationException($@"Color specified in incorrect format (should be R,G,B or R,G,B,A): {pair.Value}");
 
-            if (!byte.TryParse(split[0], out var r) || !byte.TryParse(split[1], out var g) || !byte.TryParse(split[2], out var b))
+            Color4 colour;
+
+            try
+            {
+                colour = new Color4(byte.Parse(split[0]), byte.Parse(split[1]), byte.Parse(split[2]), split.Length == 4 ? byte.Parse(split[3]) : (byte)255);
+            }
+            catch (Exception e)
+            {
                 throw new InvalidOperationException(@"Color must be specified with 8-bit integer components");
-
+            }
-            Color4 colour = new Color4(r, g, b, 255);
 
             if (isCombo)
             {

osu.Game/Configuration/OsuConfigManager.cs

@@ -83,8 +83,6 @@ namespace osu.Game.Configuration
 
             Set(OsuSetting.ScoreDisplayMode, ScoringMode.Standardised);
 
-            Set(OsuSetting.SpeedChangeVisualisation, SpeedChangeVisualisationMethod.Sequential);
-
             Set(OsuSetting.IncreaseFirstObjectVisibility, true);
 
             // Update
@@ -143,7 +141,6 @@ namespace osu.Game.Configuration
         ChatDisplayHeight,
         Version,
         ShowConvertedBeatmaps,
-        SpeedChangeVisualisation,
         Skin,
         ScreenshotFormat,
         ScreenshotCaptureMenuCursor,

osu.Game/Configuration/SpeedChangeVisualisationMethod.cs

@@ -10,6 +10,8 @@ namespace osu.Game.Configuration
         [Description("Sequential")]
         Sequential,
         [Description("Overlapping")]
-        Overlapping
+        Overlapping,
+        [Description("Constant")]
+        Constant
     }
 }

osu.Game/Graphics/Backgrounds/Triangles.cs

@@ -30,10 +30,6 @@ namespace osu.Game.Graphics.Backgrounds
         /// </summary>
         private const float edge_smoothness = 1;
 
-        public override bool HandleNonPositionalInput => false;
-        public override bool HandlePositionalInput => false;
-
-
         public Color4 ColourLight = Color4.White;
         public Color4 ColourDark = Color4.Black;
 

osu.Game/Graphics/Containers/LinkFlowContainer.cs

@@ -20,8 +20,6 @@ namespace osu.Game.Graphics.Containers
         {
         }
 
-        public override bool HandlePositionalInput => true;
-
         private OsuGame game;
 
         private Action showNotImplementedError;

osu.Game/Graphics/Containers/OsuFocusedOverlayContainer.cs

@@ -8,7 +8,7 @@ using osu.Framework.Graphics.Containers;
 using OpenTK;
 using osu.Framework.Configuration;
 using osu.Framework.Input.Bindings;
-using osu.Framework.Input.States;
+using osu.Framework.Input.Events;
 using osu.Game.Audio;
 using osu.Game.Input.Bindings;
 using osu.Game.Overlays;
@@ -59,15 +59,15 @@ namespace osu.Game.Graphics.Containers
         // receive input outside our bounds so we can trigger a close event on ourselves.
         public override bool ReceivePositionalInputAt(Vector2 screenSpacePos) => BlockScreenWideMouse || base.ReceivePositionalInputAt(screenSpacePos);
 
-        protected override bool OnClick(InputState state)
+        protected override bool OnClick(ClickEvent e)
         {
-            if (!base.ReceivePositionalInputAt(state.Mouse.NativeState.Position))
+            if (!base.ReceivePositionalInputAt(e.ScreenSpaceMousePosition))
             {
                 State = Visibility.Hidden;
                 return true;
             }
 
-            return base.OnClick(state);
+            return base.OnClick(e);
         }
 
         public virtual bool OnPressed(GlobalAction action)

osu.Game/Graphics/Containers/OsuHoverContainer.cs

@@ -6,7 +6,7 @@ using OpenTK.Graphics;
 using osu.Framework.Allocation;
 using osu.Framework.Extensions.IEnumerableExtensions;
 using osu.Framework.Graphics;
-using osu.Framework.Input.States;
+using osu.Framework.Input.Events;
 
 namespace osu.Game.Graphics.Containers
 {
@@ -18,16 +18,16 @@ namespace osu.Game.Graphics.Containers
 
         protected virtual IEnumerable<Drawable> EffectTargets => new[] { Content };
 
-        protected override bool OnHover(InputState state)
+        protected override bool OnHover(HoverEvent e)
         {
             EffectTargets.ForEach(d => d.FadeColour(HoverColour, 500, Easing.OutQuint));
-            return base.OnHover(state);
+            return base.OnHover(e);
         }
 
-        protected override void OnHoverLost(InputState state)
+        protected override void OnHoverLost(HoverLostEvent e)
         {
             EffectTargets.ForEach(d => d.FadeColour(IdleColour, 500, Easing.OutQuint));
-            base.OnHoverLost(state);
+            base.OnHoverLost(e);
         }
 
         [BackgroundDependencyLoader]

osu.Game/Graphics/Containers/OsuScrollContainer.cs

@@ -2,8 +2,7 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
 using osu.Framework.Graphics.Containers;
-using osu.Framework.Input.EventArgs;
+using osu.Framework.Input.Events;
-using osu.Framework.Input.States;
 using OpenTK.Input;
 
 namespace osu.Game.Graphics.Containers
@@ -21,7 +20,7 @@ namespace osu.Game.Graphics.Containers
         /// </summary>
         public double DistanceDecayOnRightMouseScrollbar = 0.02;
 
-        private bool shouldPerformRightMouseScroll(InputState state) => RightMouseScrollbar && state.Mouse.IsPressed(MouseButton.Right);
+        private bool shouldPerformRightMouseScroll(MouseButtonEvent e) => RightMouseScrollbar && e.Button == MouseButton.Right;
 
         private void scrollToRelative(float value) => ScrollTo(Clamp((value - Scrollbar.DrawSize[ScrollDim] / 2) / Scrollbar.Size[ScrollDim]), true, DistanceDecayOnRightMouseScrollbar);
 
@@ -29,40 +28,40 @@ namespace osu.Game.Graphics.Containers
 
         protected override bool IsDragging => base.IsDragging || mouseScrollBarDragging;
 
-        protected override bool OnMouseDown(InputState state, MouseDownEventArgs args)
+        protected override bool OnMouseDown(MouseDownEvent e)
         {
-            if (shouldPerformRightMouseScroll(state))
+            if (shouldPerformRightMouseScroll(e))
             {
-                scrollToRelative(state.Mouse.Position[ScrollDim]);
+                scrollToRelative(e.MousePosition[ScrollDim]);
                 return true;
             }
 
-            return base.OnMouseDown(state, args);
+            return base.OnMouseDown(e);
         }
 
-        protected override bool OnDrag(InputState state)
+        protected override bool OnDrag(DragEvent e)
         {
             if (mouseScrollBarDragging)
             {
-                scrollToRelative(state.Mouse.Position[ScrollDim]);
+                scrollToRelative(e.MousePosition[ScrollDim]);
                 return true;
             }
 
-            return base.OnDrag(state);
+            return base.OnDrag(e);
         }
 
-        protected override bool OnDragStart(InputState state)
+        protected override bool OnDragStart(DragStartEvent e)
         {
-            if (shouldPerformRightMouseScroll(state))
+            if (shouldPerformRightMouseScroll(e))
             {
                 mouseScrollBarDragging = true;
                 return true;
             }
 
-            return base.OnDragStart(state);
+            return base.OnDragStart(e);
         }
 
-        protected override bool OnDragEnd(InputState state)
+        protected override bool OnDragEnd(DragEndEvent e)
         {
             if (mouseScrollBarDragging)
             {
@@ -70,7 +69,7 @@ namespace osu.Game.Graphics.Containers
                 return true;
             }
 
-            return base.OnDragEnd(state);
+            return base.OnDragEnd(e);
         }
     }
 }

osu.Game/Graphics/Containers/ParallaxContainer.cs

@@ -67,7 +67,7 @@ namespace osu.Game.Graphics.Containers
 
             if (parallaxEnabled)
             {
-                Vector2 offset = (input.CurrentState.Mouse == null ? Vector2.Zero : ToLocalSpace(input.CurrentState.Mouse.NativeState.Position) - DrawSize / 2) * ParallaxAmount;
+                Vector2 offset = (input.CurrentState.Mouse == null ? Vector2.Zero : ToLocalSpace(input.CurrentState.Mouse.Position) - DrawSize / 2) * ParallaxAmount;
 
                 double elapsed = MathHelper.Clamp(Clock.ElapsedFrameTime, 0, 1000);
 

osu.Game/Graphics/Cursor/MenuCursor.cs

@@ -12,8 +12,7 @@ using osu.Game.Configuration;
 using System;
 using JetBrains.Annotations;
 using osu.Framework.Graphics.Textures;
-using osu.Framework.Input.EventArgs;
+using osu.Framework.Input.Events;
-using osu.Framework.Input.States;
 using OpenTK.Input;
 
 namespace osu.Game.Graphics.Cursor
@@ -40,11 +39,11 @@ namespace osu.Game.Graphics.Cursor
                 screenshotCursorVisibility.BindTo(screenshotManager.CursorVisibility);
         }
 
-        protected override bool OnMouseMove(InputState state)
+        protected override bool OnMouseMove(MouseMoveEvent e)
         {
             if (dragRotationState != DragRotationState.NotDragging)
             {
-                var position = state.Mouse.Position;
+                var position = e.MousePosition;
                 var distance = Vector2Extensions.Distance(position, positionMouseDown);
                 // don't start rotating until we're moved a minimum distance away from the mouse down location,
                 // else it can have an annoying effect.
@@ -53,7 +52,7 @@ namespace osu.Game.Graphics.Cursor
                 // don't rotate when distance is zero to avoid NaN
                 if (dragRotationState == DragRotationState.Rotating && distance > 0)
                 {
-                    Vector2 offset = state.Mouse.Position - positionMouseDown;
+                    Vector2 offset = e.MousePosition - positionMouseDown;
                     float degrees = (float)MathHelper.RadiansToDegrees(Math.Atan2(-offset.X, offset.Y)) + 24.3f;
 
                     // Always rotate in the direction of least distance
@@ -66,13 +65,13 @@ namespace osu.Game.Graphics.Cursor
                 }
             }
 
-            return base.OnMouseMove(state);
+            return base.OnMouseMove(e);
         }
 
-        protected override bool OnMouseDown(InputState state, MouseDownEventArgs args)
+        protected override bool OnMouseDown(MouseDownEvent e)
         {
             // only trigger animation for main mouse buttons
-            if (args.Button <= MouseButton.Right)
+            if (e.Button <= MouseButton.Right)
             {
                 activeCursor.Scale = new Vector2(1);
                 activeCursor.ScaleTo(0.90f, 800, Easing.OutQuint);
@@ -81,29 +80,29 @@ namespace osu.Game.Graphics.Cursor
                 activeCursor.AdditiveLayer.FadeInFromZero(800, Easing.OutQuint);
             }
 
-            if (args.Button == MouseButton.Left && cursorRotate)
+            if (e.Button == MouseButton.Left && cursorRotate)
             {
                 dragRotationState = DragRotationState.DragStarted;
-                positionMouseDown = state.Mouse.Position;
+                positionMouseDown = e.MousePosition;
             }
-            return base.OnMouseDown(state, args);
+            return base.OnMouseDown(e);
         }
 
-        protected override bool OnMouseUp(InputState state, MouseUpEventArgs args)
+        protected override bool OnMouseUp(MouseUpEvent e)
         {
-            if (!state.Mouse.HasMainButtonPressed)
+            if (!e.IsPressed(MouseButton.Left) && !e.IsPressed(MouseButton.Right))
             {
                 activeCursor.AdditiveLayer.FadeOutFromOne(500, Easing.OutQuint);
                 activeCursor.ScaleTo(1, 500, Easing.OutElastic);
             }
 
-            if (args.Button == MouseButton.Left)
+            if (e.Button == MouseButton.Left)
             {
                 if (dragRotationState == DragRotationState.Rotating)
                     activeCursor.RotateTo(0, 600 * (1 + Math.Abs(activeCursor.Rotation / 720)), Easing.OutElasticHalf);
                 dragRotationState = DragRotationState.NotDragging;
             }
-            return base.OnMouseUp(state, args);
+            return base.OnMouseUp(e);
         }
 
         protected override void PopIn()

osu.Game/Graphics/DrawableDate.cs

@@ -54,8 +54,6 @@ namespace osu.Game.Graphics
             Scheduler.AddDelayed(updateTimeWithReschedule, timeUntilNextUpdate);
         }
 
-        public override bool HandlePositionalInput => true;
-
         protected virtual string Format() => Date.Humanize();
 
         private void updateTime() => Text = Format();

osu.Game/Graphics/UserInterface/DialogButton.cs

@@ -13,7 +13,7 @@ using osu.Game.Graphics.Sprites;
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Game.Graphics.Containers;
 using osu.Framework.Configuration;
-using osu.Framework.Input.States;
+using osu.Framework.Input.Events;
 
 namespace osu.Game.Graphics.UserInterface
 {
@@ -213,7 +213,7 @@ namespace osu.Game.Graphics.UserInterface
 
         public override bool ReceivePositionalInputAt(Vector2 screenSpacePos) => backgroundContainer.ReceivePositionalInputAt(screenSpacePos);
 
-        protected override bool OnClick(InputState state)
+        protected override bool OnClick(ClickEvent e)
         {
             colourContainer.ResizeTo(new Vector2(1.5f, 1f), click_duration, Easing.In);
             flash();
@@ -225,20 +225,20 @@ namespace osu.Game.Graphics.UserInterface
                 glowContainer.FadeOut();
             });
 
-            return base.OnClick(state);
+            return base.OnClick(e);
         }
 
-        protected override bool OnHover(InputState state)
+        protected override bool OnHover(HoverEvent e)
         {
-            base.OnHover(state);
+            base.OnHover(e);
 
             Selected.Value = true;
             return true;
         }
 
-        protected override void OnHoverLost(InputState state)
+        protected override void OnHoverLost(HoverLostEvent e)
         {
-            base.OnHoverLost(state);
+            base.OnHoverLost(e);
             Selected.Value = false;
         }
 

osu.Game/Graphics/UserInterface/ExternalLinkButton.cs

@@ -5,7 +5,7 @@ using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Cursor;
-using osu.Framework.Input.States;
+using osu.Framework.Input.Events;
 using osu.Framework.Platform;
 using OpenTK;
 using OpenTK.Graphics;
@@ -37,19 +37,19 @@ namespace osu.Game.Graphics.UserInterface
             this.host = host;
         }
 
-        protected override bool OnHover(InputState state)
+        protected override bool OnHover(HoverEvent e)
         {
             InternalChild.FadeColour(hoverColour, 500, Easing.OutQuint);
-            return base.OnHover(state);
+            return base.OnHover(e);
         }
 
-        protected override void OnHoverLost(InputState state)
+        protected override void OnHoverLost(HoverLostEvent e)
         {
             InternalChild.FadeColour(Color4.White, 500, Easing.OutQuint);
-            base.OnHoverLost(state);
+            base.OnHoverLost(e);
         }
 
-        protected override bool OnClick(InputState state)
+        protected override bool OnClick(ClickEvent e)
         {
             if(Link != null)
                 host.OpenUrlExternally(Link);

osu.Game/Graphics/UserInterface/FocusedTextBox.cs

@@ -3,8 +3,7 @@
 
 using OpenTK.Graphics;
 using System;
-using osu.Framework.Input.EventArgs;
+using osu.Framework.Input.Events;
-using osu.Framework.Input.States;
 using osu.Game.Input.Bindings;
 using OpenTK.Input;
 
@@ -36,20 +35,20 @@ namespace osu.Game.Graphics.UserInterface
         // We may not be focused yet, but we need to handle keyboard input to be able to request focus
         public override bool HandleNonPositionalInput => HoldFocus || base.HandleNonPositionalInput;
 
-        protected override void OnFocus(InputState state)
+        protected override void OnFocus(FocusEvent e)
         {
-            base.OnFocus(state);
+            base.OnFocus(e);
             BorderThickness = 0;
         }
 
-        protected override bool OnKeyDown(InputState state, KeyDownEventArgs args)
+        protected override bool OnKeyDown(KeyDownEvent e)
         {
             if (!HasFocus) return false;
 
-            if (args.Key == Key.Escape)
+            if (e.Key == Key.Escape)
                 return false; // disable the framework-level handling of escape key for confority (we use GlobalAction.Back).
 
-            return base.OnKeyDown(state, args);
+            return base.OnKeyDown(e);
         }
 
         public override bool OnPressed(GlobalAction action)

osu.Game/Graphics/UserInterface/HoverClickSounds.cs

@@ -5,7 +5,7 @@ using osu.Framework.Allocation;
 using osu.Framework.Audio;
 using osu.Framework.Audio.Sample;
 using osu.Framework.Extensions;
-using osu.Framework.Input.States;
+using osu.Framework.Input.Events;
 
 namespace osu.Game.Graphics.UserInterface
 {
@@ -21,10 +21,10 @@ namespace osu.Game.Graphics.UserInterface
         {
         }
 
-        protected override bool OnClick(InputState state)
+        protected override bool OnClick(ClickEvent e)
         {
             sampleClick?.Play();
-            return base.OnClick(state);
+            return base.OnClick(e);
         }
 
         [BackgroundDependencyLoader]

osu.Game/Graphics/UserInterface/HoverSounds.cs

@@ -8,7 +8,7 @@ using osu.Framework.Audio.Sample;
 using osu.Framework.Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
-using osu.Framework.Input.States;
+using osu.Framework.Input.Events;
 
 namespace osu.Game.Graphics.UserInterface
 {
@@ -28,10 +28,10 @@ namespace osu.Game.Graphics.UserInterface
             RelativeSizeAxes = Axes.Both;
         }
 
-        protected override bool OnHover(InputState state)
+        protected override bool OnHover(HoverEvent e)
         {
             sampleHover?.Play();
-            return base.OnHover(state);
+            return base.OnHover(e);
         }
 
         [BackgroundDependencyLoader]

osu.Game/Graphics/UserInterface/IconButton.cs

@@ -4,7 +4,7 @@
 using OpenTK;
 using OpenTK.Graphics;
 using osu.Framework.Graphics;
-using osu.Framework.Input.States;
+using osu.Framework.Input.Events;
 
 namespace osu.Game.Graphics.UserInterface
 {
@@ -84,16 +84,16 @@ namespace osu.Game.Graphics.UserInterface
             });
         }
 
-        protected override bool OnHover(InputState state)
+        protected override bool OnHover(HoverEvent e)
         {
             icon.FadeColour(IconHoverColour, 500, Easing.OutQuint);
-            return base.OnHover(state);
+            return base.OnHover(e);
         }
 
-        protected override void OnHoverLost(InputState state)
+        protected override void OnHoverLost(HoverLostEvent e)
         {
             icon.FadeColour(IconColour, 500, Easing.OutQuint);
-            base.OnHoverLost(state);
+            base.OnHoverLost(e);
         }
     }
 }

osu.Game/Graphics/UserInterface/OsuAnimatedButton.cs

@@ -6,8 +6,7 @@ using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
-using osu.Framework.Input.EventArgs;
+using osu.Framework.Input.Events;
-using osu.Framework.Input.States;
 using osu.Game.Graphics.Containers;
 using OpenTK.Graphics;
 
@@ -77,34 +76,34 @@ namespace osu.Game.Graphics.UserInterface
             Enabled.BindValueChanged(enabled => this.FadeColour(enabled ? Color4.White : colours.Gray9, 200, Easing.OutQuint), true);
         }
 
-        protected override bool OnHover(InputState state)
+        protected override bool OnHover(HoverEvent e)
         {
             hover.FadeIn(500, Easing.OutQuint);
-            return base.OnHover(state);
+            return base.OnHover(e);
         }
 
-        protected override void OnHoverLost(InputState state)
+        protected override void OnHoverLost(HoverLostEvent e)
         {
             hover.FadeOut(500, Easing.OutQuint);
-            base.OnHoverLost(state);
+            base.OnHoverLost(e);
         }
 
-        protected override bool OnClick(InputState state)
+        protected override bool OnClick(ClickEvent e)
         {
             hover.FlashColour(FlashColour, 800, Easing.OutQuint);
-            return base.OnClick(state);
+            return base.OnClick(e);
         }
 
-        protected override bool OnMouseDown(InputState state, MouseDownEventArgs args)
+        protected override bool OnMouseDown(MouseDownEvent e)
         {
             Content.ScaleTo(0.75f, 2000, Easing.OutQuint);
-            return base.OnMouseDown(state, args);
+            return base.OnMouseDown(e);
         }
 
-        protected override bool OnMouseUp(InputState state, MouseUpEventArgs args)
+        protected override bool OnMouseUp(MouseUpEvent e)
         {
             Content.ScaleTo(1, 1000, Easing.OutElastic);
-            return base.OnMouseUp(state, args);
+            return base.OnMouseUp(e);
         }
     }
 }

osu.Game/Graphics/UserInterface/OsuButton.cs

@@ -7,8 +7,7 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Graphics.UserInterface;
-using osu.Framework.Input.EventArgs;
+using osu.Framework.Input.Events;
-using osu.Framework.Input.States;
 using osu.Game.Graphics.Sprites;
 using OpenTK.Graphics;
 
@@ -56,28 +55,28 @@ namespace osu.Game.Graphics.UserInterface
             this.FadeColour(enabled ? Color4.White : Color4.Gray, 200, Easing.OutQuint);
         }
 
-        protected override bool OnHover(InputState state)
+        protected override bool OnHover(HoverEvent e)
         {
             hover.FadeIn(200);
-            return base.OnHover(state);
+            return base.OnHover(e);
         }
 
-        protected override void OnHoverLost(InputState state)
+        protected override void OnHoverLost(HoverLostEvent e)
         {
             hover.FadeOut(200);
-            base.OnHoverLost(state);
+            base.OnHoverLost(e);
         }
 
-        protected override bool OnMouseDown(InputState state, MouseDownEventArgs args)
+        protected override bool OnMouseDown(MouseDownEvent e)
         {
             Content.ScaleTo(0.9f, 4000, Easing.OutQuint);
-            return base.OnMouseDown(state, args);
+            return base.OnMouseDown(e);
         }
 
-        protected override bool OnMouseUp(InputState state, MouseUpEventArgs args)
+        protected override bool OnMouseUp(MouseUpEvent e)
         {
             Content.ScaleTo(1, 1000, Easing.OutElastic);
-            return base.OnMouseUp(state, args);
+            return base.OnMouseUp(e);
         }
 
         protected override SpriteText CreateText() => new OsuSpriteText

osu.Game/Graphics/UserInterface/OsuCheckbox.cs

@@ -8,7 +8,7 @@ using osu.Framework.Configuration;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Graphics.UserInterface;
-using osu.Framework.Input.States;
+using osu.Framework.Input.Events;
 using osu.Game.Graphics.Sprites;
 using OpenTK.Graphics;
 
@@ -95,18 +95,18 @@ namespace osu.Game.Graphics.UserInterface
             };
         }
 
-        protected override bool OnHover(InputState state)
+        protected override bool OnHover(HoverEvent e)
         {
             Nub.Glowing = true;
             Nub.Expanded = true;
-            return base.OnHover(state);
+            return base.OnHover(e);
         }
 
-        protected override void OnHoverLost(InputState state)
+        protected override void OnHoverLost(HoverLostEvent e)
         {
             Nub.Glowing = false;
             Nub.Expanded = false;
-            base.OnHoverLost(state);
+            base.OnHoverLost(e);
         }
 
         [BackgroundDependencyLoader]

osu.Game/Graphics/UserInterface/OsuDropdown.cs

@@ -51,6 +51,8 @@ namespace osu.Game.Graphics.UserInterface
         #region OsuDropdownMenu
         protected class OsuDropdownMenu : DropdownMenu, IHasAccentColour
         {
+            public override bool HandleNonPositionalInput => State == MenuState.Open;
+
             // todo: this uses the same styling as OsuMenu. hopefully we can just use OsuMenu in the future with some refactoring
             public OsuDropdownMenu()
             {
@@ -97,6 +99,9 @@ namespace osu.Game.Graphics.UserInterface
             #region DrawableOsuDropdownMenuItem
             public class DrawableOsuDropdownMenuItem : DrawableDropdownMenuItem, IHasAccentColour
             {
+                // IsHovered is used
+                public override bool HandlePositionalInput => true;
+
                 private Color4? accentColour;
                 public Color4 AccentColour
                 {

osu.Game/Graphics/UserInterface/OsuMenu.cs

@@ -10,7 +10,7 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Graphics.UserInterface;
-using osu.Framework.Input.States;
+using osu.Framework.Input.Events;
 using osu.Game.Graphics.Sprites;
 using OpenTK;
 
@@ -97,25 +97,25 @@ namespace osu.Game.Graphics.UserInterface
                 }
             }
 
-            protected override bool OnHover(InputState state)
+            protected override bool OnHover(HoverEvent e)
             {
                 sampleHover.Play();
                 text.BoldText.FadeIn(transition_length, Easing.OutQuint);
                 text.NormalText.FadeOut(transition_length, Easing.OutQuint);
-                return base.OnHover(state);
+                return base.OnHover(e);
             }
 
-            protected override void OnHoverLost(InputState state)
+            protected override void OnHoverLost(HoverLostEvent e)
             {
                 text.BoldText.FadeOut(transition_length, Easing.OutQuint);
                 text.NormalText.FadeIn(transition_length, Easing.OutQuint);
-                base.OnHoverLost(state);
+                base.OnHoverLost(e);
             }
 
-            protected override bool OnClick(InputState state)
+            protected override bool OnClick(ClickEvent e)
             {
                 sampleClick.Play();
-                return base.OnClick(state);
+                return base.OnClick(e);
             }
 
             protected sealed override Drawable CreateContent() => text = CreateTextContainer();

osu.Game/Graphics/UserInterface/OsuPasswordTextBox.cs

@@ -9,8 +9,7 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Cursor;
 using osu.Framework.Graphics.Shapes;
-using osu.Framework.Input.EventArgs;
+using osu.Framework.Input.Events;
-using osu.Framework.Input.States;
 using osu.Framework.Platform;
 
 namespace osu.Game.Graphics.UserInterface
@@ -43,23 +42,23 @@ namespace osu.Game.Graphics.UserInterface
             this.host = host;
         }
 
-        protected override bool OnKeyDown(InputState state, KeyDownEventArgs args)
+        protected override bool OnKeyDown(KeyDownEvent e)
         {
-            if (args.Key == Key.CapsLock)
+            if (e.Key == Key.CapsLock)
                 updateCapsWarning(host.CapsLockEnabled);
-            return base.OnKeyDown(state, args);
+            return base.OnKeyDown(e);
         }
 
-        protected override void OnFocus(InputState state)
+        protected override void OnFocus(FocusEvent e)
         {
             updateCapsWarning(host.CapsLockEnabled);
-            base.OnFocus(state);
+            base.OnFocus(e);
         }
 
-        protected override void OnFocusLost(InputState state)
+        protected override void OnFocusLost(FocusLostEvent e)
         {
             updateCapsWarning(false);
-            base.OnFocusLost(state);
+            base.OnFocusLost(e);
         }
 
         private void updateCapsWarning(bool visible) => warning.FadeTo(visible ? 1 : 0, 250, Easing.OutQuint);

osu.Game/Graphics/UserInterface/OsuSliderBar.cs

@@ -13,8 +13,7 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.UserInterface;
 using osu.Framework.Graphics.Cursor;
 using osu.Framework.Graphics.Shapes;
-using osu.Framework.Input.EventArgs;
+using osu.Framework.Input.Events;
-using osu.Framework.Input.States;
 
 namespace osu.Game.Graphics.UserInterface
 {
@@ -125,16 +124,16 @@ namespace osu.Game.Graphics.UserInterface
             AccentColour = colours.Pink;
         }
 
-        protected override bool OnHover(InputState state)
+        protected override bool OnHover(HoverEvent e)
         {
             Nub.Glowing = true;
-            return base.OnHover(state);
+            return base.OnHover(e);
         }
 
-        protected override void OnHoverLost(InputState state)
+        protected override void OnHoverLost(HoverLostEvent e)
         {
             Nub.Glowing = false;
-            base.OnHoverLost(state);
+            base.OnHoverLost(e);
         }
 
         protected override void OnUserChange()
@@ -164,16 +163,16 @@ namespace osu.Game.Graphics.UserInterface
             sample.Play();
         }
 
-        protected override bool OnMouseDown(InputState state, MouseDownEventArgs args)
+        protected override bool OnMouseDown(MouseDownEvent e)
         {
             Nub.Current.Value = true;
-            return base.OnMouseDown(state, args);
+            return base.OnMouseDown(e);
         }
 
-        protected override bool OnMouseUp(InputState state, MouseUpEventArgs args)
+        protected override bool OnMouseUp(MouseUpEvent e)
         {
             Nub.Current.Value = false;
-            return base.OnMouseUp(state, args);
+            return base.OnMouseUp(e);
         }
 
         protected override void UpdateAfterChildren()

osu.Game/Graphics/UserInterface/OsuTabControl.cs

@@ -14,7 +14,7 @@ using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Graphics.UserInterface;
-using osu.Framework.Input.States;
+using osu.Framework.Input.Events;
 using osu.Framework.MathUtils;
 using osu.Game.Graphics.Sprites;
 
@@ -126,14 +126,14 @@ namespace osu.Game.Graphics.UserInterface
                 Text.FadeColour(AccentColour, transition_length, Easing.OutQuint);
             }
 
-            protected override bool OnHover(InputState state)
+            protected override bool OnHover(HoverEvent e)
             {
                 if (!Active)
                     fadeActive();
                 return true;
             }
 
-            protected override void OnHoverLost(InputState state)
+            protected override void OnHoverLost(HoverLostEvent e)
             {
                 if (!Active)
                     fadeInactive();
@@ -265,16 +265,16 @@ namespace osu.Game.Graphics.UserInterface
                     Padding = new MarginPadding { Left = 5, Right = 5 };
                 }
 
-                protected override bool OnHover(InputState state)
+                protected override bool OnHover(HoverEvent e)
                 {
                     Foreground.Colour = BackgroundColour;
-                    return base.OnHover(state);
+                    return base.OnHover(e);
                 }
 
-                protected override void OnHoverLost(InputState state)
+                protected override void OnHoverLost(HoverLostEvent e)
                 {
                     Foreground.Colour = BackgroundColourHover;
-                    base.OnHoverLost(state);
+                    base.OnHoverLost(e);
                 }
             }
         }

osu.Game/Graphics/UserInterface/OsuTabControlCheckbox.cs

@@ -10,7 +10,7 @@ using osu.Framework.Graphics.Shapes;
 using osu.Game.Graphics.Sprites;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Graphics.UserInterface;
-using osu.Framework.Input.States;
+using osu.Framework.Input.Events;
 
 namespace osu.Game.Graphics.UserInterface
 {
@@ -59,18 +59,18 @@ namespace osu.Game.Graphics.UserInterface
             text.FadeColour(AccentColour, transition_length, Easing.OutQuint);
         }
 
-        protected override bool OnHover(InputState state)
+        protected override bool OnHover(HoverEvent e)
         {
             fadeIn();
-            return base.OnHover(state);
+            return base.OnHover(e);
         }
 
-        protected override void OnHoverLost(InputState state)
+        protected override void OnHoverLost(HoverLostEvent e)
         {
             if (!Current)
                 fadeOut();
 
-            base.OnHoverLost(state);
+            base.OnHoverLost(e);
         }
 
         [BackgroundDependencyLoader]

osu.Game/Graphics/UserInterface/OsuTextBox.cs

@@ -9,7 +9,7 @@ using osu.Game.Graphics.Sprites;
 using OpenTK.Graphics;
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Input.Bindings;
-using osu.Framework.Input.States;
+using osu.Framework.Input.Events;
 using osu.Game.Input.Bindings;
 
 namespace osu.Game.Graphics.UserInterface
@@ -44,17 +44,17 @@ namespace osu.Game.Graphics.UserInterface
             BorderColour = colour.Yellow;
         }
 
-        protected override void OnFocus(InputState state)
+        protected override void OnFocus(FocusEvent e)
         {
             BorderThickness = 3;
-            base.OnFocus(state);
+            base.OnFocus(e);
         }
 
-        protected override void OnFocusLost(InputState state)
+        protected override void OnFocusLost(FocusLostEvent e)
         {
             BorderThickness = 0;
 
-            base.OnFocusLost(state);
+            base.OnFocusLost(e);
         }
 
         protected override Drawable GetDrawableCharacter(char c) => new OsuSpriteText { Text = c.ToString(), TextSize = CalculatedTextSize };

osu.Game/Graphics/UserInterface/PageTabControl.cs

@@ -10,7 +10,7 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Graphics.UserInterface;
-using osu.Framework.Input.States;
+using osu.Framework.Input.Events;
 using osu.Game.Graphics.Sprites;
 
 namespace osu.Game.Graphics.UserInterface
@@ -67,14 +67,14 @@ namespace osu.Game.Graphics.UserInterface
                 box.Colour = colours.Yellow;
             }
 
-            protected override bool OnHover(InputState state)
+            protected override bool OnHover(HoverEvent e)
             {
                 if (!Active)
                     slideActive();
                 return true;
             }
 
-            protected override void OnHoverLost(InputState state)
+            protected override void OnHoverLost(HoverLostEvent e)
             {
                 if (!Active)
                     slideInactive();

osu.Game/Graphics/UserInterface/SearchTextBox.cs

@@ -2,8 +2,7 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
 using osu.Framework.Graphics;
-using osu.Framework.Input.EventArgs;
+using osu.Framework.Input.Events;
-using osu.Framework.Input.States;
 using OpenTK;
 using OpenTK.Input;
 
@@ -33,11 +32,11 @@ namespace osu.Game.Graphics.UserInterface
             PlaceholderText = "type to search";
         }
 
-        protected override bool OnKeyDown(InputState state, KeyDownEventArgs args)
+        protected override bool OnKeyDown(KeyDownEvent e)
         {
-            if (!state.Keyboard.ControlPressed && !state.Keyboard.ShiftPressed)
+            if (!e.ControlPressed && !e.ShiftPressed)
             {
-                switch (args.Key)
+                switch (e.Key)
                 {
                     case Key.Left:
                     case Key.Right:
@@ -49,7 +48,7 @@ namespace osu.Game.Graphics.UserInterface
 
             if (!AllowCommit)
             {
-                switch (args.Key)
+                switch (e.Key)
                 {
                     case Key.KeypadEnter:
                     case Key.Enter:
@@ -57,16 +56,16 @@ namespace osu.Game.Graphics.UserInterface
                 }
             }
 
-            if (state.Keyboard.ShiftPressed)
+            if (e.ShiftPressed)
             {
-                switch (args.Key)
+                switch (e.Key)
                 {
                     case Key.Delete:
                         return false;
                 }
             }
 
-            return base.OnKeyDown(state, args);
+            return base.OnKeyDown(e);
         }
     }
 }

osu.Game/Graphics/UserInterface/TwoLayerButton.cs

@@ -13,8 +13,7 @@ using osu.Game.Beatmaps.ControlPoints;
 using osu.Framework.Audio.Track;
 using System;
 using osu.Framework.Graphics.Shapes;
-using osu.Framework.Input.EventArgs;
+using osu.Framework.Input.Events;
-using osu.Framework.Input.States;
 
 namespace osu.Game.Graphics.UserInterface
 {
@@ -172,7 +171,7 @@ namespace osu.Game.Graphics.UserInterface
 
         public override bool ReceivePositionalInputAt(Vector2 screenSpacePos) => IconLayer.ReceivePositionalInputAt(screenSpacePos) || TextLayer.ReceivePositionalInputAt(screenSpacePos);
 
-        protected override bool OnHover(InputState state)
+        protected override bool OnHover(HoverEvent e)
         {
             this.ResizeTo(SIZE_EXTENDED, transform_time, Easing.OutElastic);
             IconLayer.FadeColour(HoverColour, transform_time, Easing.OutElastic);
@@ -182,7 +181,7 @@ namespace osu.Game.Graphics.UserInterface
             return true;
         }
 
-        protected override void OnHoverLost(InputState state)
+        protected override void OnHoverLost(HoverLostEvent e)
         {
             this.ResizeTo(SIZE_RETRACTED, transform_time, Easing.OutElastic);
             IconLayer.FadeColour(TextLayer.Colour, transform_time, Easing.OutElastic);
@@ -190,12 +189,12 @@ namespace osu.Game.Graphics.UserInterface
             bouncingIcon.ScaleTo(1, transform_time, Easing.OutElastic);
         }
 
-        protected override bool OnMouseDown(InputState state, MouseDownEventArgs args)
+        protected override bool OnMouseDown(MouseDownEvent e)
         {
             return true;
         }
 
-        protected override bool OnClick(InputState state)
+        protected override bool OnClick(ClickEvent e)
         {
             var flash = new Box
             {
@@ -209,7 +208,7 @@ namespace osu.Game.Graphics.UserInterface
             flash.FadeOut(500, Easing.OutQuint);
             flash.Expire();
 
-            return base.OnClick(state);
+            return base.OnClick(e);
         }
 
         private class BouncingIcon : BeatSyncedContainer

osu.Game/OsuGame.cs

@@ -65,7 +65,8 @@ namespace osu.Game
 
         private BeatmapSetOverlay beatmapSetOverlay;
 
-        private ScreenshotManager screenshotManager;
+        [Cached]
+        private readonly ScreenshotManager screenshotManager = new ScreenshotManager();
 
         protected RavenLogger RavenLogger;
 
@@ -289,9 +290,6 @@ namespace osu.Game
 
         protected override void LoadComplete()
         {
-            // this needs to be cached before base.LoadComplete as it is used by MenuCursorContainer.
-            dependencies.Cache(screenshotManager = new ScreenshotManager());
-
             base.LoadComplete();
 
             // The next time this is updated is in UpdateAfterChildren, which occurs too late and results

osu.Game/Overlays/BeatmapSet/BeatmapPicker.cs

@@ -10,7 +10,7 @@ using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
-using osu.Framework.Input.States;
+using osu.Framework.Input.Events;
 using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.Drawables;
 using osu.Game.Graphics;
@@ -174,9 +174,9 @@ namespace osu.Game.Overlays.BeatmapSet
         {
             public Action OnLostHover;
 
-            protected override void OnHoverLost(InputState state)
+            protected override void OnHoverLost(HoverLostEvent e)
             {
-                base.OnHoverLost(state);
+                base.OnHoverLost(e);
                 OnLostHover?.Invoke();
             }
         }
@@ -241,24 +241,24 @@ namespace osu.Game.Overlays.BeatmapSet
                 };
             }
 
-            protected override bool OnHover(InputState state)
+            protected override bool OnHover(HoverEvent e)
             {
                 fadeIn();
                 OnHovered?.Invoke(Beatmap);
-                return base.OnHover(state);
+                return base.OnHover(e);
             }
 
-            protected override void OnHoverLost(InputState state)
+            protected override void OnHoverLost(HoverLostEvent e)
             {
                 if (State == DifficultySelectorState.NotSelected)
                     fadeOut();
-                base.OnHoverLost(state);
+                base.OnHoverLost(e);
             }
 
-            protected override bool OnClick(InputState state)
+            protected override bool OnClick(ClickEvent e)
             {
                 OnClicked?.Invoke(Beatmap);
-                return base.OnClick(state);
+                return base.OnClick(e);
             }
 
             private void fadeIn()

osu.Game/Overlays/BeatmapSet/Buttons/PreviewButton.cs

@@ -7,7 +7,7 @@ using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
-using osu.Framework.Input.States;
+using osu.Framework.Input.Events;
 using osu.Game.Audio;
 using osu.Game.Beatmaps;
 using osu.Game.Graphics;
@@ -89,16 +89,16 @@ namespace osu.Game.Overlays.BeatmapSet.Buttons
                 progress.Width = 0;
         }
 
-        protected override bool OnHover(InputState state)
+        protected override bool OnHover(HoverEvent e)
         {
             bg.FadeColour(Color4.Black.Opacity(0.5f), 100);
-            return base.OnHover(state);
+            return base.OnHover(e);
         }
 
-        protected override void OnHoverLost(InputState state)
+        protected override void OnHoverLost(HoverLostEvent e)
         {
             bg.FadeColour(Color4.Black.Opacity(0.25f), 100);
-            base.OnHoverLost(state);
+            base.OnHoverLost(e);
         }
     }
 }

osu.Game/Overlays/BeatmapSet/Scores/ClickableUsername.cs

@@ -3,7 +3,7 @@
 
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
-using osu.Framework.Input.States;
+using osu.Framework.Input.Events;
 using osu.Game.Graphics.Containers;
 using osu.Game.Graphics.Sprites;
 using osu.Game.Users;
@@ -53,7 +53,7 @@ namespace osu.Game.Overlays.BeatmapSet.Scores
             this.profile = profile;
         }
 
-        protected override bool OnClick(InputState state)
+        protected override bool OnClick(ClickEvent e)
         {
             profile?.ShowUser(user);
             return true;

osu.Game/Overlays/BeatmapSet/Scores/DrawableScore.cs

@@ -6,7 +6,7 @@ using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
-using osu.Framework.Input.States;
+using osu.Framework.Input.Events;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Sprites;
 using osu.Game.Online.API.Requests.Responses;
@@ -125,18 +125,18 @@ namespace osu.Game.Overlays.BeatmapSet.Scores
             background.Colour = colours.Gray4;
         }
 
-        protected override bool OnHover(InputState state)
+        protected override bool OnHover(HoverEvent e)
         {
             background.FadeIn(fade_duration, Easing.OutQuint);
-            return base.OnHover(state);
+            return base.OnHover(e);
         }
 
-        protected override void OnHoverLost(InputState state)
+        protected override void OnHoverLost(HoverLostEvent e)
         {
             background.FadeOut(fade_duration, Easing.OutQuint);
-            base.OnHoverLost(state);
+            base.OnHoverLost(e);
         }
 
-        protected override bool OnClick(InputState state) => true;
+        protected override bool OnClick(ClickEvent e) => true;
     }
 }

osu.Game/Overlays/BeatmapSet/Scores/DrawableTopScore.cs

@@ -8,7 +8,7 @@ using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
-using osu.Framework.Input.States;
+using osu.Framework.Input.Events;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Sprites;
 using osu.Game.Online.API.Requests.Responses;
@@ -184,16 +184,16 @@ namespace osu.Game.Overlays.BeatmapSet.Scores
             BorderColour = rankText.Colour = colours.Yellow;
         }
 
-        protected override bool OnHover(InputState state)
+        protected override bool OnHover(HoverEvent e)
         {
             background.FadeIn(fade_duration, Easing.OutQuint);
-            return base.OnHover(state);
+            return base.OnHover(e);
         }
 
-        protected override void OnHoverLost(InputState state)
+        protected override void OnHoverLost(HoverLostEvent e)
         {
             background.FadeOut(fade_duration, Easing.OutQuint);
-            base.OnHoverLost(state);
+            base.OnHoverLost(e);
         }
 
         private class InfoColumn : FillFlowContainer

osu.Game/Overlays/BeatmapSetOverlay.cs

@@ -7,7 +7,7 @@ using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
-using osu.Framework.Input.States;
+using osu.Framework.Input.Events;
 using osu.Game.Beatmaps;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Containers;
@@ -127,7 +127,7 @@ namespace osu.Game.Overlays
             FadeEdgeEffectTo(0, WaveContainer.DISAPPEAR_DURATION, Easing.Out).OnComplete(_ => BeatmapSet = null);
         }
 
-        protected override bool OnClick(InputState state)
+        protected override bool OnClick(ClickEvent e)
         {
             State = Visibility.Hidden;
             return true;

osu.Game/Overlays/Chat/ChannelListItem.cs

@@ -9,7 +9,7 @@ using osu.Framework.Allocation;
 using osu.Framework.Configuration;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
-using osu.Framework.Input.States;
+using osu.Framework.Input.Events;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Sprites;
 using osu.Game.Online.Chat;
@@ -155,15 +155,15 @@ namespace osu.Game.Overlays.Chat
             FinishTransforms(true);
         }
 
-        protected override bool OnHover(InputState state)
+        protected override bool OnHover(HoverEvent e)
         {
             if (!channel.Joined.Value)
                 name.FadeColour(hoverColour, 50, Easing.OutQuint);
 
-            return base.OnHover(state);
+            return base.OnHover(e);
         }
 
-        protected override void OnHoverLost(InputState state)
+        protected override void OnHoverLost(HoverLostEvent e)
         {
             if (!channel.Joined.Value)
                 name.FadeColour(Color4.White, transition_duration);

osu.Game/Overlays/Chat/ChannelSelectionOverlay.cs

@@ -10,7 +10,7 @@ using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
-using osu.Framework.Input.States;
+using osu.Framework.Input.Events;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Backgrounds;
 using osu.Game.Graphics.Sprites;
@@ -150,10 +150,10 @@ namespace osu.Game.Overlays.Chat
             headerBg.Colour = colours.Gray2.Opacity(0.75f);
         }
 
-        protected override void OnFocus(InputState state)
+        protected override void OnFocus(FocusEvent e)
         {
             GetContainingInputManager().ChangeFocus(search);
-            base.OnFocus(state);
+            base.OnFocus(e);
         }
 
         protected override void PopIn()

osu.Game/Overlays/Chat/ChatTabControl.cs

@@ -17,8 +17,7 @@ using OpenTK.Input;
 using OpenTK.Graphics;
 using osu.Framework.Configuration;
 using System;
-using osu.Framework.Input.EventArgs;
+using osu.Framework.Input.Events;
-using osu.Framework.Input.States;
 using osu.Game.Graphics.Containers;
 
 namespace osu.Game.Overlays.Chat
@@ -144,9 +143,9 @@ namespace osu.Game.Overlays.Chat
                 textBold.FadeOut(transition_length, Easing.OutQuint);
             }
 
-            protected override bool OnMouseUp(InputState state, MouseUpEventArgs args)
+            protected override bool OnMouseUp(MouseUpEvent e)
             {
-                if (args.Button == MouseButton.Middle)
+                if (e.Button == MouseButton.Middle)
                 {
                     closeButton.Action();
                     return true;
@@ -155,7 +154,7 @@ namespace osu.Game.Overlays.Chat
                 return false;
             }
 
-            protected override bool OnHover(InputState state)
+            protected override bool OnHover(HoverEvent e)
             {
                 if (IsRemovable)
                     closeButton.FadeIn(200, Easing.OutQuint);
@@ -165,7 +164,7 @@ namespace osu.Game.Overlays.Chat
                 return true;
             }
 
-            protected override void OnHoverLost(InputState state)
+            protected override void OnHoverLost(HoverLostEvent e)
             {
                 closeButton.FadeOut(200, Easing.OutQuint);
                 updateState();
@@ -291,28 +290,28 @@ namespace osu.Game.Overlays.Chat
                     };
                 }
 
-                protected override bool OnMouseDown(InputState state, MouseDownEventArgs args)
+                protected override bool OnMouseDown(MouseDownEvent e)
                 {
                     icon.ScaleTo(0.5f, 1000, Easing.OutQuint);
-                    return base.OnMouseDown(state, args);
+                    return base.OnMouseDown(e);
                 }
 
-                protected override bool OnMouseUp(InputState state, MouseUpEventArgs args)
+                protected override bool OnMouseUp(MouseUpEvent e)
                 {
                     icon.ScaleTo(0.75f, 1000, Easing.OutElastic);
-                    return base.OnMouseUp(state, args);
+                    return base.OnMouseUp(e);
                 }
 
-                protected override bool OnHover(InputState state)
+                protected override bool OnHover(HoverEvent e)
                 {
                     icon.FadeColour(Color4.Red, 200, Easing.OutQuint);
-                    return base.OnHover(state);
+                    return base.OnHover(e);
                 }
 
-                protected override void OnHoverLost(InputState state)
+                protected override void OnHoverLost(HoverLostEvent e)
                 {
                     icon.FadeColour(Color4.White, 200, Easing.OutQuint);
-                    base.OnHoverLost(state);
+                    base.OnHoverLost(e);
                 }
             }
 

osu.Game/Overlays/ChatOverlay.cs

@@ -3,7 +3,6 @@
 
 using System;
 using System.Collections.Generic;
-using System.Diagnostics;
 using System.Linq;
 using OpenTK;
 using OpenTK.Graphics;
@@ -13,7 +12,7 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Graphics.UserInterface;
-using osu.Framework.Input.States;
+using osu.Framework.Input.Events;
 using osu.Framework.Threading;
 using osu.Game.Configuration;
 using osu.Game.Graphics;
@@ -52,7 +51,7 @@ namespace osu.Game.Overlays
         private readonly ChatTabControl channelTabs;
 
         private readonly Container chatContainer;
-        private readonly Container tabsArea;
+        private readonly TabsArea tabsArea;
         private readonly Box chatBackground;
         private readonly Box tabBackground;
 
@@ -146,11 +145,8 @@ namespace osu.Game.Overlays
                                 loading = new LoadingAnimation(),
                             }
                         },
-                        tabsArea = new Container
+                        tabsArea = new TabsArea
                         {
-                            Name = @"tabs area",
-                            RelativeSizeAxes = Axes.X,
-                            Height = TAB_AREA_HEIGHT,
                             Children = new Drawable[]
                             {
                                 tabBackground = new Box
@@ -191,25 +187,22 @@ namespace osu.Game.Overlays
 
         public void OpenChannel(Channel channel) => addChannel(channel);
 
-        protected override bool OnDragStart(InputState state)
+        protected override bool OnDragStart(DragStartEvent e)
         {
             isDragging = tabsArea.IsHovered;
 
             if (!isDragging)
-                return base.OnDragStart(state);
+                return base.OnDragStart(e);
 
             startDragChatHeight = ChatHeight.Value;
             return true;
         }
 
-        protected override bool OnDrag(InputState state)
+        protected override bool OnDrag(DragEvent e)
         {
             if (isDragging)
             {
-                Trace.Assert(state.Mouse.PositionMouseDown != null);
+                double targetChatHeight = startDragChatHeight - (e.MousePosition.Y - e.MouseDownPosition.Y) / Parent.DrawSize.Y;
-
-                // ReSharper disable once PossibleInvalidOperationException
-                double targetChatHeight = startDragChatHeight - (state.Mouse.Position.Y - state.Mouse.PositionMouseDown.Value.Y) / Parent.DrawSize.Y;
 
                 // If the channel selection screen is shown, mind its minimum height
                 if (channelSelection.State == Visibility.Visible && targetChatHeight > 1f - channel_selection_min_height)
@@ -221,10 +214,10 @@ namespace osu.Game.Overlays
             return true;
         }
 
-        protected override bool OnDragEnd(InputState state)
+        protected override bool OnDragEnd(DragEndEvent e)
         {
             isDragging = false;
-            return base.OnDragEnd(state);
+            return base.OnDragEnd(e);
         }
 
         public void APIStateChanged(APIAccess api, APIState state)
@@ -242,11 +235,11 @@ namespace osu.Game.Overlays
 
         public override bool AcceptsFocus => true;
 
-        protected override void OnFocus(InputState state)
+        protected override void OnFocus(FocusEvent e)
         {
             //this is necessary as textbox is masked away and therefore can't get focus :(
             GetContainingInputManager().ChangeFocus(textbox);
-            base.OnFocus(state);
+            base.OnFocus(e);
         }
 
         protected override void PopIn()
@@ -298,7 +291,7 @@ namespace osu.Game.Overlays
             messageRequest?.Cancel();
 
             ListChannelsRequest req = new ListChannelsRequest();
-            req.Success += delegate (List<Channel> channels)
+            req.Success += delegate(List<Channel> channels)
             {
                 AvailableChannels = channels;
 
@@ -330,10 +323,7 @@ namespace osu.Game.Overlays
 
         protected Channel CurrentChannel
         {
-            get
+            get { return currentChannel; }
-            {
-                return currentChannel;
-            }
 
             set
             {
@@ -452,13 +442,7 @@ namespace osu.Game.Overlays
                 if (updates?.Presence != null)
                 {
                     foreach (var channel in updates.Presence)
-                    {
+                        addChannel(AvailableChannels.Find(c => c.Id == channel.Id));
-                        if (careChannels.Find(c => c.Id == channel.Id) == null)
-                        {
-                            channel.Joined.Value = true;
-                            addChannel(channel);
-                        }
-                    }
 
                     foreach (var group in updates.Messages.GroupBy(m => m.ChannelId))
                         careChannels.Find(c => c.Id == group.Key)?.AddNewMessages(group.ToArray());
@@ -469,10 +453,7 @@ namespace osu.Game.Overlays
                 fetchReq = null;
             };
 
-            fetchReq.Failure += delegate
+            fetchReq.Failure += delegate { fetchReq = null; };
-            {
-                fetchReq = null;
-            };
 
             api.Queue(fetchReq);
         }
@@ -545,5 +526,18 @@ namespace osu.Game.Overlays
 
             api.Queue(req);
         }
+
+        private class TabsArea : Container
+        {
+            // IsHovered is used
+            public override bool HandlePositionalInput => true;
+
+            public TabsArea()
+            {
+                Name = @"tabs area";
+                RelativeSizeAxes = Axes.X;
+                Height = TAB_AREA_HEIGHT;
+            }
+        }
     }
 }

osu.Game/Overlays/Dialog/PopupDialog.cs

@@ -8,8 +8,7 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Graphics.Sprites;
-using osu.Framework.Input.EventArgs;
+using osu.Framework.Input.Events;
-using osu.Framework.Input.States;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Backgrounds;
 using osu.Game.Graphics.Containers;
@@ -206,12 +205,12 @@ namespace osu.Game.Overlays.Dialog
             return base.OnPressed(action);
         }
 
-        protected override bool OnKeyDown(InputState state, KeyDownEventArgs args)
+        protected override bool OnKeyDown(KeyDownEvent e)
         {
-            if (args.Repeat) return false;
+            if (e.Repeat) return false;
 
             // press button at number if 1-9 on number row or keypad are pressed
-            var k = args.Key;
+            var k = e.Key;
             if (k >= Key.Number1 && k <= Key.Number9)
             {
                 pressButtonAtIndex(k - Key.Number1);
@@ -224,7 +223,7 @@ namespace osu.Game.Overlays.Dialog
                 return true;
             }
 
-            return base.OnKeyDown(state, args);
+            return base.OnKeyDown(e);
         }
 
         protected override void PopIn()

osu.Game/Overlays/Direct/DirectGridPanel.cs

@@ -10,7 +10,7 @@ using osu.Framework.Graphics.Containers;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Sprites;
 using osu.Framework.Graphics.Shapes;
-using osu.Framework.Input.States;
+using osu.Framework.Input.Events;
 using osu.Framework.Localisation;
 using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.Drawables;
@@ -227,15 +227,15 @@ namespace osu.Game.Overlays.Direct
             PreviewPlaying.ValueChanged += _ => updateStatusContainer();
         }
 
-        protected override bool OnHover(InputState state)
+        protected override bool OnHover(HoverEvent e)
         {
             updateStatusContainer();
-            return base.OnHover(state);
+            return base.OnHover(e);
         }
 
-        protected override void OnHoverLost(InputState state)
+        protected override void OnHoverLost(HoverLostEvent e)
         {
-            base.OnHoverLost(state);
+            base.OnHoverLost(e);
             updateStatusContainer();
         }
 

osu.Game/Overlays/Direct/DirectPanel.cs

@@ -10,7 +10,7 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Graphics.Sprites;
-using osu.Framework.Input.States;
+using osu.Framework.Input.Events;
 using osu.Game.Audio;
 using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.Drawables;
@@ -121,27 +121,27 @@ namespace osu.Game.Overlays.Direct
             }
         }
 
-        protected override bool OnHover(InputState state)
+        protected override bool OnHover(HoverEvent e)
         {
             content.TweenEdgeEffectTo(edgeEffectHovered, hover_transition_time, Easing.OutQuint);
             content.MoveToY(-4, hover_transition_time, Easing.OutQuint);
             if (FadePlayButton)
                 PlayButton.FadeIn(120, Easing.InOutQuint);
 
-            return base.OnHover(state);
+            return base.OnHover(e);
         }
 
-        protected override void OnHoverLost(InputState state)
+        protected override void OnHoverLost(HoverLostEvent e)
         {
             content.TweenEdgeEffectTo(edgeEffectNormal, hover_transition_time, Easing.OutQuint);
             content.MoveToY(0, hover_transition_time, Easing.OutQuint);
             if (FadePlayButton && !PreviewPlaying)
                 PlayButton.FadeOut(120, Easing.InOutQuint);
 
-            base.OnHoverLost(state);
+            base.OnHoverLost(e);
         }
 
-        protected override bool OnClick(InputState state)
+        protected override bool OnClick(ClickEvent e)
         {
             ShowInformation();
             return true;

osu.Game/Overlays/Direct/PlayButton.cs

@@ -5,7 +5,7 @@ using osu.Framework.Allocation;
 using osu.Framework.Configuration;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
-using osu.Framework.Input.States;
+using osu.Framework.Input.Events;
 using osu.Game.Audio;
 using osu.Game.Beatmaps;
 using osu.Game.Graphics;
@@ -93,23 +93,23 @@ namespace osu.Game.Overlays.Direct
             hoverColour = colour.Yellow;
         }
 
-        protected override bool OnClick(InputState state)
+        protected override bool OnClick(ClickEvent e)
         {
             Playing.Toggle();
             return true;
         }
 
-        protected override bool OnHover(InputState state)
+        protected override bool OnHover(HoverEvent e)
         {
             icon.FadeColour(hoverColour, 120, Easing.InOutQuint);
-            return base.OnHover(state);
+            return base.OnHover(e);
         }
 
-        protected override void OnHoverLost(InputState state)
+        protected override void OnHoverLost(HoverLostEvent e)
         {
             if (!Playing.Value)
                 icon.FadeColour(Color4.White, 120, Easing.InOutQuint);
-            base.OnHoverLost(state);
+            base.OnHoverLost(e);
         }
 
         private void playingStateChanged(bool playing)

osu.Game/Overlays/KeyBinding/KeyBindingRow.cs

@@ -10,15 +10,13 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Input.Bindings;
-using osu.Framework.Input.EventArgs;
+using osu.Framework.Input.Events;
-using osu.Framework.Input.States;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Containers;
 using osu.Game.Graphics.Sprites;
 using osu.Game.Input;
 using OpenTK.Graphics;
 using OpenTK.Input;
-using JoystickEventArgs = osu.Framework.Input.EventArgs.JoystickEventArgs;
 
 namespace osu.Game.Overlays.KeyBinding
 {
@@ -125,18 +123,18 @@ namespace osu.Game.Overlays.KeyBinding
             }
         }
 
-        protected override bool OnHover(InputState state)
+        protected override bool OnHover(HoverEvent e)
         {
             FadeEdgeEffectTo(1, transition_time, Easing.OutQuint);
 
-            return base.OnHover(state);
+            return base.OnHover(e);
         }
 
-        protected override void OnHoverLost(InputState state)
+        protected override void OnHoverLost(HoverLostEvent e)
         {
             FadeEdgeEffectTo(0, transition_time, Easing.OutQuint);
 
-            base.OnHoverLost(state);
+            base.OnHoverLost(e);
         }
 
         public override bool AcceptsFocus => bindTarget == null;
@@ -149,16 +147,16 @@ namespace osu.Game.Overlays.KeyBinding
 
         private bool isModifier(Key k) => k < Key.F1;
 
-        protected override bool OnClick(InputState state) => true;
+        protected override bool OnClick(ClickEvent e) => true;
 
-        protected override bool OnMouseDown(InputState state, MouseDownEventArgs args)
+        protected override bool OnMouseDown(MouseDownEvent e)
         {
             if (!HasFocus || !bindTarget.IsHovered)
-                return base.OnMouseDown(state, args);
+                return base.OnMouseDown(e);
 
             if (!AllowMainMouseButtons)
             {
-                switch (args.Button)
+                switch (e.Button)
                 {
                     case MouseButton.Left:
                     case MouseButton.Right:
@@ -166,15 +164,15 @@ namespace osu.Game.Overlays.KeyBinding
                 }
             }
 
-            bindTarget.UpdateKeyCombination(KeyCombination.FromInputState(state));
+            bindTarget.UpdateKeyCombination(KeyCombination.FromInputState(e.CurrentState));
             return true;
         }
 
-        protected override bool OnMouseUp(InputState state, MouseUpEventArgs args)
+        protected override bool OnMouseUp(MouseUpEvent e)
         {
             // don't do anything until the last button is released.
-            if (!HasFocus || state.Mouse.Buttons.Any())
+            if (!HasFocus || e.HasAnyButtonPressed)
-                return base.OnMouseUp(state, args);
+                return base.OnMouseUp(e);
 
             if (bindTarget.IsHovered)
                 finalise();
@@ -183,31 +181,31 @@ namespace osu.Game.Overlays.KeyBinding
             return true;
         }
 
-        protected override bool OnScroll(InputState state)
+        protected override bool OnScroll(ScrollEvent e)
         {
             if (HasFocus)
             {
                 if (bindTarget.IsHovered)
                 {
-                    bindTarget.UpdateKeyCombination(KeyCombination.FromInputState(state, state.Mouse.ScrollDelta));
+                    bindTarget.UpdateKeyCombination(KeyCombination.FromInputState(e.CurrentState, e.ScrollDelta));
                     finalise();
                     return true;
                 }
             }
 
-            return base.OnScroll(state);
+            return base.OnScroll(e);
         }
 
-        protected override bool OnKeyDown(InputState state, KeyDownEventArgs args)
+        protected override bool OnKeyDown(KeyDownEvent e)
         {
             if (!HasFocus)
                 return false;
 
-            switch (args.Key)
+            switch (e.Key)
             {
                 case Key.Delete:
                 {
-                    if (state.Keyboard.ShiftPressed)
+                    if (e.ShiftPressed)
                     {
                         bindTarget.UpdateKeyCombination(InputKey.None);
                         finalise();
@@ -218,35 +216,35 @@ namespace osu.Game.Overlays.KeyBinding
                 }
             }
 
-            bindTarget.UpdateKeyCombination(KeyCombination.FromInputState(state));
+            bindTarget.UpdateKeyCombination(KeyCombination.FromInputState(e.CurrentState));
-            if (!isModifier(args.Key)) finalise();
+            if (!isModifier(e.Key)) finalise();
 
             return true;
         }
 
-        protected override bool OnKeyUp(InputState state, KeyUpEventArgs args)
+        protected override bool OnKeyUp(KeyUpEvent e)
         {
-            if (!HasFocus) return base.OnKeyUp(state, args);
+            if (!HasFocus) return base.OnKeyUp(e);
 
             finalise();
             return true;
         }
 
-        protected override bool OnJoystickPress(InputState state, JoystickEventArgs args)
+        protected override bool OnJoystickPress(JoystickPressEvent e)
         {
             if (!HasFocus)
                 return false;
 
-            bindTarget.UpdateKeyCombination(KeyCombination.FromInputState(state));
+            bindTarget.UpdateKeyCombination(KeyCombination.FromInputState(e.CurrentState));
             finalise();
 
             return true;
         }
 
-        protected override bool OnJoystickRelease(InputState state, JoystickEventArgs args)
+        protected override bool OnJoystickRelease(JoystickReleaseEvent e)
         {
             if (!HasFocus)
-                return base.OnJoystickRelease(state, args);
+                return base.OnJoystickRelease(e);
 
             finalise();
             return true;
@@ -273,7 +271,7 @@ namespace osu.Game.Overlays.KeyBinding
             pressAKey.BypassAutoSizeAxes |= Axes.Y;
         }
 
-        protected override void OnFocus(InputState state)
+        protected override void OnFocus(FocusEvent e)
         {
             AutoSizeDuration = 500;
             AutoSizeEasing = Easing.OutQuint;
@@ -282,13 +280,13 @@ namespace osu.Game.Overlays.KeyBinding
             pressAKey.BypassAutoSizeAxes &= ~Axes.Y;
 
             updateBindTarget();
-            base.OnFocus(state);
+            base.OnFocus(e);
         }
 
-        protected override void OnFocusLost(InputState state)
+        protected override void OnFocusLost(FocusLostEvent e)
         {
             finalise();
-            base.OnFocusLost(state);
+            base.OnFocusLost(e);
         }
 
         private void updateBindTarget()
@@ -367,16 +365,16 @@ namespace osu.Game.Overlays.KeyBinding
                 hoverColour = colours.YellowDark;
             }
 
-            protected override bool OnHover(InputState state)
+            protected override bool OnHover(HoverEvent e)
             {
                 updateHoverState();
-                return base.OnHover(state);
+                return base.OnHover(e);
             }
 
-            protected override void OnHoverLost(InputState state)
+            protected override void OnHoverLost(HoverLostEvent e)
             {
                 updateHoverState();
-                base.OnHoverLost(state);
+                base.OnHoverLost(e);
             }
 
             private void updateHoverState()

osu.Game/Overlays/MainSettings.cs

@@ -6,8 +6,7 @@ using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Input.Bindings;
-using osu.Framework.Input.EventArgs;
+using osu.Framework.Input.Events;
-using osu.Framework.Input.States;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Containers;
 using osu.Game.Graphics.Sprites;
@@ -138,16 +137,16 @@ namespace osu.Game.Overlays
                 };
             }
 
-            protected override bool OnMouseDown(InputState state, MouseDownEventArgs args)
+            protected override bool OnMouseDown(MouseDownEvent e)
             {
                 aspect.ScaleTo(0.75f, 2000, Easing.OutQuint);
-                return base.OnMouseDown(state, args);
+                return base.OnMouseDown(e);
             }
 
-            protected override bool OnMouseUp(InputState state, MouseUpEventArgs args)
+            protected override bool OnMouseUp(MouseUpEvent e)
             {
                 aspect.ScaleTo(1, 1000, Easing.OutElastic);
-                return base.OnMouseUp(state, args);
+                return base.OnMouseUp(e);
             }
 
             public bool OnPressed(GlobalAction action)

osu.Game/Overlays/MedalOverlay.cs

@@ -19,8 +19,7 @@ using osu.Framework.Graphics.Textures;
 using OpenTK.Input;
 using osu.Framework.Graphics.Shapes;
 using System;
-using System.Linq;
+using osu.Framework.Input.Events;
-using osu.Framework.Input.States;
 using osu.Framework.MathUtils;
 
 namespace osu.Game.Overlays
@@ -176,15 +175,15 @@ namespace osu.Game.Overlays
             particleContainer.Add(new MedalParticle(RNG.Next(0, 359)));
         }
 
-        protected override bool OnClick(InputState state)
+        protected override bool OnClick(ClickEvent e)
         {
             dismiss();
             return true;
         }
 
-        protected override void OnFocusLost(InputState state)
+        protected override void OnFocusLost(FocusLostEvent e)
         {
-            if (state.Keyboard.Keys.Contains(Key.Escape)) dismiss();
+            if (e.CurrentState.Keyboard.Keys.IsPressed(Key.Escape)) dismiss();
         }
 
         private const double initial_duration = 400;

osu.Game/Overlays/Mods/ModButton.cs

@@ -13,8 +13,7 @@ using osu.Game.Rulesets.UI;
 using System;
 using System.Linq;
 using osu.Framework.Graphics.Cursor;
-using osu.Framework.Input.EventArgs;
+using osu.Framework.Input.Events;
-using osu.Framework.Input.States;
 using osu.Game.Graphics.UserInterface;
 
 namespace osu.Game.Overlays.Mods
@@ -149,20 +148,20 @@ namespace osu.Game.Overlays.Mods
 
         public virtual Mod SelectedMod => Mods.ElementAtOrDefault(selectedIndex);
 
-        protected override bool OnMouseDown(InputState state, MouseDownEventArgs args)
+        protected override bool OnMouseDown(MouseDownEvent e)
         {
             scaleContainer.ScaleTo(0.9f, 800, Easing.Out);
-            return base.OnMouseDown(state, args);
+            return base.OnMouseDown(e);
         }
 
-        protected override bool OnMouseUp(InputState state, MouseUpEventArgs args)
+        protected override bool OnMouseUp(MouseUpEvent e)
         {
             scaleContainer.ScaleTo(1, 500, Easing.OutElastic);
 
             // only trigger the event if we are inside the area of the button
-            if (Contains(ToScreenSpace(state.Mouse.Position - Position)))
+            if (Contains(e.ScreenSpaceMousePosition))
             {
-                switch (args.Button)
+                switch (e.Button)
                 {
                     case MouseButton.Left:
                         SelectNext(1);

osu.Game/Overlays/Mods/ModSection.cs

@@ -10,8 +10,7 @@ using osu.Game.Rulesets.Mods;
 using System;
 using System.Linq;
 using System.Collections.Generic;
-using osu.Framework.Input.EventArgs;
+using osu.Framework.Input.Events;
-using osu.Framework.Input.States;
 
 namespace osu.Game.Overlays.Mods
 {
@@ -55,16 +54,16 @@ namespace osu.Game.Overlays.Mods
 
         private ModButton[] buttons = { };
 
-        protected override bool OnKeyDown(InputState state, KeyDownEventArgs args)
+        protected override bool OnKeyDown(KeyDownEvent e)
         {
             if (ToggleKeys != null)
             {
-                var index = Array.IndexOf(ToggleKeys, args.Key);
+                var index = Array.IndexOf(ToggleKeys, e.Key);
                 if (index > -1 && index < buttons.Length)
-                    buttons[index].SelectNext(state.Keyboard.ShiftPressed ? -1 : 1);
+                    buttons[index].SelectNext(e.ShiftPressed ? -1 : 1);
             }
 
-            return base.OnKeyDown(state, args);
+            return base.OnKeyDown(e);
         }
 
         public void DeselectAll() => DeselectTypes(buttons.Select(b => b.SelectedMod?.GetType()).Where(t => t != null));

osu.Game/Overlays/Music/PlaylistItem.cs

@@ -8,8 +8,7 @@ using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Sprites;
-using osu.Framework.Input.EventArgs;
+using osu.Framework.Input.Events;
-using osu.Framework.Input.States;
 using osu.Framework.Localisation;
 using osu.Game.Beatmaps;
 using osu.Game.Graphics;
@@ -37,16 +36,16 @@ namespace osu.Game.Overlays.Music
 
         public bool IsDraggable { get; private set; }
 
-        protected override bool OnMouseDown(InputState state, MouseDownEventArgs args)
+        protected override bool OnMouseDown(MouseDownEvent e)
         {
             IsDraggable = handle.IsHovered;
-            return base.OnMouseDown(state, args);
+            return base.OnMouseDown(e);
         }
 
-        protected override bool OnMouseUp(InputState state, MouseUpEventArgs args)
+        protected override bool OnMouseUp(MouseUpEvent e)
         {
             IsDraggable = false;
-            return base.OnMouseUp(state, args);
+            return base.OnMouseUp(e);
         }
 
         private bool selected;
@@ -123,19 +122,19 @@ namespace osu.Game.Overlays.Music
             });
         }
 
-        protected override bool OnHover(InputState state)
+        protected override bool OnHover(HoverEvent e)
         {
             handle.FadeIn(fade_duration);
 
-            return base.OnHover(state);
+            return base.OnHover(e);
         }
 
-        protected override void OnHoverLost(InputState state)
+        protected override void OnHoverLost(HoverLostEvent e)
         {
             handle.FadeOut(fade_duration);
         }
 
-        protected override bool OnClick(InputState state)
+        protected override bool OnClick(ClickEvent e)
         {
             OnSelect?.Invoke(BeatmapSetInfo);
             return true;

osu.Game/Overlays/Music/PlaylistList.cs

@@ -8,7 +8,7 @@ using osu.Framework.Allocation;
 using osu.Framework.Configuration;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
-using osu.Framework.Input.States;
+using osu.Framework.Input.Events;
 using osu.Game.Beatmaps;
 using osu.Game.Graphics.Containers;
 using OpenTK;
@@ -115,25 +115,25 @@ namespace osu.Game.Overlays.Music
             private Vector2 nativeDragPosition;
             private PlaylistItem draggedItem;
 
-            protected override bool OnDragStart(InputState state)
+            protected override bool OnDragStart(DragStartEvent e)
             {
-                nativeDragPosition = state.Mouse.NativeState.Position;
+                nativeDragPosition = e.ScreenSpaceMousePosition;
                 draggedItem = items.FirstOrDefault(d => d.IsDraggable);
-                return draggedItem != null || base.OnDragStart(state);
+                return draggedItem != null || base.OnDragStart(e);
             }
 
-            protected override bool OnDrag(InputState state)
+            protected override bool OnDrag(DragEvent e)
             {
-                nativeDragPosition = state.Mouse.NativeState.Position;
+                nativeDragPosition = e.ScreenSpaceMousePosition;
                 if (draggedItem == null)
-                    return base.OnDrag(state);
+                    return base.OnDrag(e);
                 return true;
             }
 
-            protected override bool OnDragEnd(InputState state)
+            protected override bool OnDragEnd(DragEndEvent e)
             {
-                nativeDragPosition = state.Mouse.NativeState.Position;
+                nativeDragPosition = e.ScreenSpaceMousePosition;
-                var handled = draggedItem != null || base.OnDragEnd(state);
+                var handled = draggedItem != null || base.OnDragEnd(e);
                 draggedItem = null;
 
                 return handled;

osu.Game/Overlays/MusicController.cs

@@ -13,7 +13,7 @@ using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Graphics.Textures;
-using osu.Framework.Input.States;
+using osu.Framework.Input.Events;
 using osu.Framework.Localisation;
 using osu.Framework.Threading;
 using osu.Game.Beatmaps;
@@ -457,20 +457,14 @@ namespace osu.Game.Overlays
 
         private class DragContainer : Container
         {
-            private Vector2 dragStart;
+            protected override bool OnDragStart(DragStartEvent e)
-
-            protected override bool OnDragStart(InputState state)
             {
-                base.OnDragStart(state);
-                dragStart = state.Mouse.Position;
                 return true;
             }
 
-            protected override bool OnDrag(InputState state)
+            protected override bool OnDrag(DragEvent e)
             {
-                if (base.OnDrag(state)) return true;
+                Vector2 change = e.MousePosition - e.MouseDownPosition;
-
-                Vector2 change = state.Mouse.Position - dragStart;
 
                 // Diminish the drag distance as we go further to simulate "rubber band" feeling.
                 change *= change.Length <= 0 ? 0 : (float)Math.Pow(change.Length, 0.7f) / change.Length;
@@ -479,10 +473,10 @@ namespace osu.Game.Overlays
                 return true;
             }
 
-            protected override bool OnDragEnd(InputState state)
+            protected override bool OnDragEnd(DragEndEvent e)
             {
                 this.MoveTo(Vector2.Zero, 800, Easing.OutElastic);
-                return base.OnDragEnd(state);
+                return base.OnDragEnd(e);
             }
         }
     }

osu.Game/Overlays/Notifications/Notification.cs

@@ -11,7 +11,7 @@ using osu.Game.Graphics;
 using OpenTK;
 using OpenTK.Graphics;
 using osu.Framework.Graphics.Shapes;
-using osu.Framework.Input.States;
+using osu.Framework.Input.Events;
 using osu.Game.Graphics.Containers;
 
 namespace osu.Game.Overlays.Notifications
@@ -118,19 +118,19 @@ namespace osu.Game.Overlays.Notifications
             });
         }
 
-        protected override bool OnHover(InputState state)
+        protected override bool OnHover(HoverEvent e)
         {
             closeButton.FadeIn(75);
-            return base.OnHover(state);
+            return base.OnHover(e);
         }
 
-        protected override void OnHoverLost(InputState state)
+        protected override void OnHoverLost(HoverLostEvent e)
         {
             closeButton.FadeOut(75);
-            base.OnHoverLost(state);
+            base.OnHoverLost(e);
         }
 
-        protected override bool OnClick(InputState state)
+        protected override bool OnClick(ClickEvent e)
         {
             if (Activated?.Invoke() ?? true)
                 Close();
@@ -185,16 +185,16 @@ namespace osu.Game.Overlays.Notifications
                 hoverColour = colours.Yellow;
             }
 
-            protected override bool OnHover(InputState state)
+            protected override bool OnHover(HoverEvent e)
             {
                 this.FadeColour(hoverColour, 200);
-                return base.OnHover(state);
+                return base.OnHover(e);
             }
 
-            protected override void OnHoverLost(InputState state)
+            protected override void OnHoverLost(HoverLostEvent e)
             {
                 this.FadeColour(OsuColour.Gray(0.2f), 200);
-                base.OnHoverLost(state);
+                base.OnHoverLost(e);
             }
         }
 

osu.Game/Overlays/OnScreenDisplay.cs

@@ -25,9 +25,6 @@ namespace osu.Game.Overlays
     {
         private readonly Container box;
 
-        public override bool HandleNonPositionalInput => false;
-        public override bool HandlePositionalInput => false;
-
         private readonly SpriteText textLine1;
         private readonly SpriteText textLine2;
         private readonly SpriteText textLine3;

osu.Game/Overlays/Profile/Header/BadgeContainer.cs

@@ -9,7 +9,7 @@ using osu.Framework.Graphics.Cursor;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Graphics.Textures;
-using osu.Framework.Input.States;
+using osu.Framework.Input.Events;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Sprites;
 using osu.Game.Users;
@@ -153,13 +153,13 @@ namespace osu.Game.Overlays.Profile.Header
                 this.hoverLostAction = hoverLostAction;
             }
 
-            protected override bool OnHover(InputState state)
+            protected override bool OnHover(HoverEvent e)
             {
                 hoverAction();
                 return true;
             }
 
-            protected override void OnHoverLost(InputState state) => hoverLostAction();
+            protected override void OnHoverLost(HoverLostEvent e) => hoverLostAction();
         }
 
         private class DrawableBadge : Container, IHasTooltip

osu.Game/Overlays/Profile/Header/RankGraph.cs

@@ -10,7 +10,7 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Graphics.Sprites;
-using osu.Framework.Input.States;
+using osu.Framework.Input.Events;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Sprites;
 using osu.Game.Graphics.UserInterface;
@@ -137,25 +137,25 @@ namespace osu.Game.Overlays.Profile.Header
             relativeText.Text = dayIndex + 1 == ranks.Length ? "Now" : $"{ranked_days - ranks[dayIndex].Key} days ago";
         }
 
-        protected override bool OnHover(InputState state)
+        protected override bool OnHover(HoverEvent e)
         {
             if (ranks?.Length > 1)
             {
-                graph.UpdateBallPosition(state.Mouse.Position.X);
+                graph.UpdateBallPosition(e.MousePosition.X);
                 graph.ShowBall();
             }
-            return base.OnHover(state);
+            return base.OnHover(e);
         }
 
-        protected override bool OnMouseMove(InputState state)
+        protected override bool OnMouseMove(MouseMoveEvent e)
         {
             if (ranks?.Length > 1)
-                graph.UpdateBallPosition(state.Mouse.Position.X);
+                graph.UpdateBallPosition(e.MousePosition.X);
 
-            return base.OnMouseMove(state);
+            return base.OnMouseMove(e);
         }
 
-        protected override void OnHoverLost(InputState state)
+        protected override void OnHoverLost(HoverLostEvent e)
         {
             if (ranks?.Length > 1)
             {
@@ -163,7 +163,7 @@ namespace osu.Game.Overlays.Profile.Header
                 updateRankTexts();
             }
 
-            base.OnHoverLost(state);
+            base.OnHoverLost(e);
         }
 
         private class RankChartLineGraph : LineGraph

osu.Game/Overlays/Profile/ProfileHeader.cs

@@ -386,10 +386,13 @@ namespace osu.Game.Overlays.Profile
                 infoTextLeft.AddText(new DrawableJoinDate(user.JoinDate), boldItalic);
             }
 
-            infoTextLeft.NewLine();
+            if (user.LastVisit.HasValue)
-            infoTextLeft.AddText("Last seen ", lightText);
+            {
-            infoTextLeft.AddText(new DrawableDate(user.LastVisit), boldItalic);
+                infoTextLeft.NewLine();
-            infoTextLeft.NewParagraph();
+                infoTextLeft.AddText("Last seen ", lightText);
+                infoTextLeft.AddText(new DrawableDate(user.LastVisit.Value), boldItalic);
+                infoTextLeft.NewParagraph();
+            }
 
             if (user.PlayStyle?.Length > 0)
             {

osu.Game/Overlays/Profile/Sections/DrawableProfileRow.cs

@@ -6,7 +6,7 @@ using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
-using osu.Framework.Input.States;
+using osu.Framework.Input.Events;
 using osu.Game.Graphics;
 using OpenTK;
 using OpenTK.Graphics;
@@ -105,20 +105,20 @@ namespace osu.Game.Overlays.Profile.Sections
             coloredBackground.Colour = underscoreLine.Colour = colour.Gray4;
         }
 
-        protected override bool OnClick(InputState state) => true;
+        protected override bool OnClick(ClickEvent e) => true;
 
-        protected override bool OnHover(InputState state)
+        protected override bool OnHover(HoverEvent e)
         {
             background.FadeIn(fade_duration, Easing.OutQuint);
             underscoreLine.FadeOut(fade_duration, Easing.OutQuint);
             return true;
         }
 
-        protected override void OnHoverLost(InputState state)
+        protected override void OnHoverLost(HoverLostEvent e)
         {
             background.FadeOut(fade_duration, Easing.OutQuint);
             underscoreLine.FadeIn(fade_duration, Easing.OutQuint);
-            base.OnHoverLost(state);
+            base.OnHoverLost(e);
         }
     }
 }

osu.Game/Overlays/Profile/Sections/Kudosu/KudosuInfo.cs

@@ -8,7 +8,7 @@ using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
-using osu.Framework.Input.States;
+using osu.Framework.Input.Events;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Containers;
 using osu.Game.Graphics.Sprites;
@@ -70,7 +70,7 @@ namespace osu.Game.Overlays.Profile.Sections.Kudosu
             };
         }
 
-        protected override bool OnClick(InputState state) => true;
+        protected override bool OnClick(ClickEvent e) => true;
 
         private class CountSection : Container
         {

osu.Game/Overlays/SearchableList/SearchableListOverlay.cs

@@ -5,7 +5,7 @@ using OpenTK.Graphics;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
-using osu.Framework.Input.States;
+using osu.Framework.Input.Events;
 using osu.Game.Graphics.Backgrounds;
 using osu.Game.Graphics.Containers;
 
@@ -101,7 +101,7 @@ namespace osu.Game.Overlays.SearchableList
             scrollContainer.Padding = new MarginPadding { Top = Header.Height + Filter.Height };
         }
 
-        protected override void OnFocus(InputState state)
+        protected override void OnFocus(FocusEvent e)
         {
             GetContainingInputManager().ChangeFocus(Filter.Search);
         }

osu.Game/Overlays/Settings/Sections/Gameplay/ScrollingSettings.cs

@@ -1,26 +0,0 @@
-// Copyright (c) 2007-2018 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.Game.Configuration;
-
-namespace osu.Game.Overlays.Settings.Sections.Gameplay
-{
-    public class ScrollingSettings : SettingsSubsection
-    {
-        protected override string Header => "Scrolling";
-
-        [BackgroundDependencyLoader]
-        private void load(OsuConfigManager config)
-        {
-            Children = new[]
-            {
-                new SettingsEnumDropdown<SpeedChangeVisualisationMethod>
-                {
-                    LabelText = "Visualise speed changes as",
-                    Bindable = config.GetBindable<SpeedChangeVisualisationMethod>(OsuSetting.SpeedChangeVisualisation),
-                }
-            };
-        }
-    }
-}

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

@@ -21,7 +21,6 @@ namespace osu.Game.Overlays.Settings.Sections
             {
                 new GeneralSettings(),
                 new SongSelectSettings(),
-                new ScrollingSettings(),
                 new ModsSettings(),
             };
         }
@@ -29,7 +28,7 @@ namespace osu.Game.Overlays.Settings.Sections
         [BackgroundDependencyLoader]
         private void load(RulesetStore rulesets)
         {
-            foreach(Ruleset ruleset in rulesets.AvailableRulesets.Select(info => info.CreateInstance()))
+            foreach (Ruleset ruleset in rulesets.AvailableRulesets.Select(info => info.CreateInstance()))
             {
                 SettingsSubsection section = ruleset.CreateSettings();
                 if (section != null)

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

@@ -16,7 +16,7 @@ using System.ComponentModel;
 using osu.Game.Graphics;
 using OpenTK.Graphics;
 using osu.Framework.Extensions.Color4Extensions;
-using osu.Framework.Input.States;
+using osu.Framework.Input.Events;
 using RectangleF = osu.Framework.Graphics.Primitives.RectangleF;
 using Container = osu.Framework.Graphics.Containers.Container;
 
@@ -175,12 +175,12 @@ namespace osu.Game.Overlays.Settings.Sections.General
 
         public override bool AcceptsFocus => true;
 
-        protected override bool OnClick(InputState state) => true;
+        protected override bool OnClick(ClickEvent e) => true;
 
-        protected override void OnFocus(InputState state)
+        protected override void OnFocus(FocusEvent e)
         {
             if (form != null) GetContainingInputManager().ChangeFocus(form);
-            base.OnFocus(state);
+            base.OnFocus(e);
         }
 
         private class LoginForm : FillFlowContainer
@@ -244,9 +244,9 @@ namespace osu.Game.Overlays.Settings.Sections.General
 
             public override bool AcceptsFocus => true;
 
-            protected override bool OnClick(InputState state) => true;
+            protected override bool OnClick(ClickEvent e) => true;
 
-            protected override void OnFocus(InputState state)
+            protected override void OnFocus(FocusEvent e)
             {
                 Schedule(() => { GetContainingInputManager().ChangeFocus(string.IsNullOrEmpty(username.Text) ? username : password); });
             }

osu.Game/Overlays/Settings/Sections/Graphics/LayoutSettings.cs

@@ -102,7 +102,7 @@ namespace osu.Game.Overlays.Settings.Sections.Graphics
                     }
                     else
                         resolutionDropdown.Hide();
-                });
+                }, true);
             }
 
             letterboxing.BindValueChanged(isVisible =>

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

@@ -5,7 +5,7 @@ using osu.Framework.Allocation;
 using osu.Framework.Configuration;
 using osu.Framework.Graphics;
 using osu.Framework.Input;
-using osu.Framework.Input.States;
+using osu.Framework.Input.Events;
 using osu.Game.Configuration;
 using osu.Game.Graphics.UserInterface;
 
@@ -124,18 +124,18 @@ namespace osu.Game.Overlays.Settings.Sections.Input
 
             private bool isDragging;
 
-            protected override bool OnDragStart(InputState state)
+            protected override bool OnDragStart(DragStartEvent e)
             {
                 isDragging = true;
-                return base.OnDragStart(state);
+                return base.OnDragStart(e);
             }
 
-            protected override bool OnDragEnd(InputState state)
+            protected override bool OnDragEnd(DragEndEvent e)
             {
                 isDragging = false;
                 Current.TriggerChange();
 
-                return base.OnDragEnd(state);
+                return base.OnDragEnd(e);
             }
 
             public override string TooltipText => Current.Disabled ? "Enable raw input to adjust sensitivity" : Current.Value.ToString(@"0.##x");

osu.Game/Overlays/Settings/SettingsItem.cs

@@ -12,8 +12,7 @@ using osu.Framework.Graphics.Cursor;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Graphics.UserInterface;
-using osu.Framework.Input.EventArgs;
+using osu.Framework.Input.Events;
-using osu.Framework.Input.States;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Sprites;
 using OpenTK;
@@ -168,25 +167,25 @@ namespace osu.Game.Overlays.Settings
 
             public string TooltipText => "Revert to default";
 
-            protected override bool OnMouseDown(InputState state, MouseDownEventArgs args) => true;
+            protected override bool OnMouseDown(MouseDownEvent e) => true;
 
-            protected override bool OnMouseUp(InputState state, MouseUpEventArgs args) => true;
+            protected override bool OnMouseUp(MouseUpEvent e) => true;
 
-            protected override bool OnClick(InputState state)
+            protected override bool OnClick(ClickEvent e)
             {
                 if (bindable != null && !bindable.Disabled)
                     bindable.SetDefault();
                 return true;
             }
 
-            protected override bool OnHover(InputState state)
+            protected override bool OnHover(HoverEvent e)
             {
                 hovering = true;
                 UpdateState();
                 return false;
             }
 
-            protected override void OnHoverLost(InputState state)
+            protected override void OnHoverLost(HoverLostEvent e)
             {
                 hovering = false;
                 UpdateState();

osu.Game/Overlays/Settings/Sidebar.cs

@@ -9,7 +9,7 @@ using OpenTK.Graphics;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
-using osu.Framework.Input.States;
+using osu.Framework.Input.Events;
 using osu.Framework.Threading;
 using osu.Game.Overlays.Toolbar;
 
@@ -55,25 +55,25 @@ namespace osu.Game.Overlays.Settings
         private ScheduledDelegate expandEvent;
         private ExpandedState state;
 
-        protected override bool OnHover(InputState state)
+        protected override bool OnHover(HoverEvent e)
         {
             queueExpandIfHovering();
             return true;
         }
 
-        protected override void OnHoverLost(InputState state)
+        protected override void OnHoverLost(HoverLostEvent e)
         {
             expandEvent?.Cancel();
             lastHoveredButton = null;
             State = ExpandedState.Contracted;
 
-            base.OnHoverLost(state);
+            base.OnHoverLost(e);
         }
 
-        protected override bool OnMouseMove(InputState state)
+        protected override bool OnMouseMove(MouseMoveEvent e)
         {
             queueExpandIfHovering();
-            return base.OnMouseMove(state);
+            return base.OnMouseMove(e);
         }
 
         private class SidebarScrollContainer : ScrollContainer

osu.Game/Overlays/Settings/SidebarButton.cs

@@ -10,7 +10,7 @@ using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Graphics.UserInterface;
-using osu.Framework.Input.States;
+using osu.Framework.Input.Events;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Sprites;
 using osu.Game.Graphics.UserInterface;
@@ -109,22 +109,22 @@ namespace osu.Game.Overlays.Settings
             selectionIndicator.Colour = colours.Yellow;
         }
 
-        protected override bool OnClick(InputState state)
+        protected override bool OnClick(ClickEvent e)
         {
             Action?.Invoke(section);
-            return base.OnClick(state);
+            return base.OnClick(e);
         }
 
-        protected override bool OnHover(InputState state)
+        protected override bool OnHover(HoverEvent e)
         {
             Background.FadeTo(0.4f, 200);
-            return base.OnHover(state);
+            return base.OnHover(e);
         }
 
-        protected override void OnHoverLost(InputState state)
+        protected override void OnHoverLost(HoverLostEvent e)
         {
             Background.FadeTo(0, 200);
-            base.OnHoverLost(state);
+            base.OnHoverLost(e);
         }
     }
 }

osu.Game/Overlays/SettingsOverlay.cs

@@ -11,7 +11,7 @@ using osu.Framework.Extensions.IEnumerableExtensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
-using osu.Framework.Input.States;
+using osu.Framework.Input.Events;
 using osu.Game.Graphics.Containers;
 using osu.Game.Graphics.UserInterface;
 using osu.Game.Overlays.Settings;
@@ -177,10 +177,10 @@ namespace osu.Game.Overlays
 
         public override bool AcceptsFocus => true;
 
-        protected override void OnFocus(InputState state)
+        protected override void OnFocus(FocusEvent e)
         {
             GetContainingInputManager().ChangeFocus(searchTextBox);
-            base.OnFocus(state);
+            base.OnFocus(e);
         }
 
         protected override void UpdateAfterChildren()

osu.Game/Overlays/Social/SocialPanel.cs

@@ -6,7 +6,7 @@ using OpenTK.Graphics;
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
-using osu.Framework.Input.States;
+using osu.Framework.Input.Events;
 using osu.Game.Users;
 
 namespace osu.Game.Overlays.Social
@@ -35,20 +35,20 @@ namespace osu.Game.Overlays.Social
             Colour = Color4.Black.Opacity(0.3f),
         };
 
-        protected override bool OnHover(InputState state)
+        protected override bool OnHover(HoverEvent e)
         {
             Content.TweenEdgeEffectTo(edgeEffectHovered, hover_transition_time, Easing.OutQuint);
             Content.MoveToY(-4, hover_transition_time, Easing.OutQuint);
 
-            return base.OnHover(state);
+            return base.OnHover(e);
         }
 
-        protected override void OnHoverLost(InputState state)
+        protected override void OnHoverLost(HoverLostEvent e)
         {
             Content.TweenEdgeEffectTo(edgeEffectNormal, hover_transition_time, Easing.OutQuint);
             Content.MoveToY(0, hover_transition_time, Easing.OutQuint);
 
-            base.OnHoverLost(state);
+            base.OnHoverLost(e);
         }
 
         protected override void LoadComplete()

osu.Game/Overlays/Toolbar/Toolbar.cs

@@ -11,7 +11,7 @@ using OpenTK;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Allocation;
 using osu.Framework.Configuration;
-using osu.Framework.Input.States;
+using osu.Framework.Input.Events;
 
 namespace osu.Game.Overlays.Toolbar
 {
@@ -121,14 +121,14 @@ namespace osu.Game.Overlays.Toolbar
                 };
             }
 
-            protected override bool OnHover(InputState state)
+            protected override bool OnHover(HoverEvent e)
             {
                 solidBackground.FadeTo(alpha_hovering, transition_time, Easing.OutQuint);
                 gradientBackground.FadeIn(transition_time, Easing.OutQuint);
                 return true;
             }
 
-            protected override void OnHoverLost(InputState state)
+            protected override void OnHoverLost(HoverLostEvent e)
             {
                 solidBackground.FadeTo(alpha_normal, transition_time, Easing.OutQuint);
                 gradientBackground.FadeOut(transition_time, Easing.OutQuint);

osu.Game/Overlays/Toolbar/ToolbarButton.cs

@@ -11,8 +11,7 @@ using osu.Game.Graphics.Sprites;
 using OpenTK;
 using OpenTK.Graphics;
 using osu.Framework.Graphics.Shapes;
-using osu.Framework.Input.EventArgs;
+using osu.Framework.Input.Events;
-using osu.Framework.Input.States;
 using osu.Game.Graphics.Containers;
 using osu.Game.Graphics.UserInterface;
 
@@ -145,22 +144,22 @@ namespace osu.Game.Overlays.Toolbar
             };
         }
 
-        protected override bool OnMouseDown(InputState state, MouseDownEventArgs args) => true;
+        protected override bool OnMouseDown(MouseDownEvent e) => true;
 
-        protected override bool OnClick(InputState state)
+        protected override bool OnClick(ClickEvent e)
         {
             HoverBackground.FlashColour(Color4.White.Opacity(100), 500, Easing.OutQuint);
-            return base.OnClick(state);
+            return base.OnClick(e);
         }
 
-        protected override bool OnHover(InputState state)
+        protected override bool OnHover(HoverEvent e)
         {
             HoverBackground.FadeIn(200);
             tooltipContainer.FadeIn(100);
-            return base.OnHover(state);
+            return base.OnHover(e);
         }
 
-        protected override void OnHoverLost(InputState state)
+        protected override void OnHoverLost(HoverLostEvent e)
         {
             HoverBackground.FadeOut(200);
             tooltipContainer.FadeOut(100);

osu.Game/Overlays/Toolbar/ToolbarRulesetSelector.cs

@@ -11,8 +11,7 @@ using OpenTK.Input;
 using OpenTK.Graphics;
 using osu.Framework.Configuration;
 using osu.Framework.Graphics.Shapes;
-using osu.Framework.Input.EventArgs;
+using osu.Framework.Input.Events;
-using osu.Framework.Input.States;
 using osu.Game.Rulesets;
 
 namespace osu.Game.Overlays.Toolbar
@@ -86,13 +85,13 @@ namespace osu.Game.Overlays.Toolbar
             ruleset.BindTo(parentRuleset);
         }
 
-        protected override bool OnKeyDown(InputState state, KeyDownEventArgs args)
+        protected override bool OnKeyDown(KeyDownEvent e)
         {
-            base.OnKeyDown(state, args);
+            base.OnKeyDown(e);
 
-            if (state.Keyboard.ControlPressed && !args.Repeat && args.Key >= Key.Number1 && args.Key <= Key.Number9)
+            if (e.ControlPressed && !e.Repeat && e.Key >= Key.Number1 && e.Key <= Key.Number9)
             {
-                int requested = args.Key - Key.Number1;
+                int requested = e.Key - Key.Number1;
 
                 RulesetInfo found = rulesets.AvailableRulesets.Skip(requested).FirstOrDefault();
                 if (found != null)

osu.Game/Overlays/Volume/MuteButton.cs

@@ -9,7 +9,7 @@ using osu.Framework.Graphics.Colour;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Graphics.UserInterface;
-using osu.Framework.Input.States;
+using osu.Framework.Input.Events;
 using osu.Game.Graphics;
 using OpenTK;
 using OpenTK.Graphics;
@@ -63,18 +63,18 @@ namespace osu.Game.Overlays.Volume
             Current.TriggerChange();
         }
 
-        protected override bool OnHover(InputState state)
+        protected override bool OnHover(HoverEvent e)
         {
             this.TransformTo<MuteButton, SRGBColour>("BorderColour", hoveredColour, 500, Easing.OutQuint);
             return false;
         }
 
-        protected override void OnHoverLost(InputState state)
+        protected override void OnHoverLost(HoverLostEvent e)
         {
             this.TransformTo<MuteButton, SRGBColour>("BorderColour", unhoveredColour, 500, Easing.OutQuint);
         }
 
-        protected override bool OnClick(InputState state)
+        protected override bool OnClick(ClickEvent e)
         {
             Current.Value = !Current.Value;
             return true;

osu.Game/Overlays/Volume/VolumeMeter.cs

@@ -11,7 +11,7 @@ using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Effects;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Graphics.UserInterface;
-using osu.Framework.Input.States;
+using osu.Framework.Input.Events;
 using osu.Framework.MathUtils;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Sprites;
@@ -239,21 +239,21 @@ namespace osu.Game.Overlays.Volume
             adjustAccumulator = 0;
         }
 
-        protected override bool OnScroll(InputState state)
+        protected override bool OnScroll(ScrollEvent e)
         {
-            adjust(state.Mouse.ScrollDelta.Y, state.Mouse.HasPreciseScroll);
+            adjust(e.ScrollDelta.Y, e.IsPrecise);
             return true;
         }
 
         private const float transition_length = 500;
 
-        protected override bool OnHover(InputState state)
+        protected override bool OnHover(HoverEvent e)
         {
             this.ScaleTo(1.04f, transition_length, Easing.OutExpo);
             return false;
         }
 
-        protected override void OnHoverLost(InputState state)
+        protected override void OnHoverLost(HoverLostEvent e)
         {
             this.ScaleTo(1f, transition_length, Easing.OutExpo);
         }

osu.Game/Overlays/VolumeOverlay.cs

@@ -9,7 +9,7 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Colour;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
-using osu.Framework.Input.States;
+using osu.Framework.Input.Events;
 using osu.Framework.Threading;
 using osu.Game.Graphics;
 using osu.Game.Input.Bindings;
@@ -143,23 +143,23 @@ namespace osu.Game.Overlays
             this.FadeOut(100);
         }
 
-        protected override bool OnMouseMove(InputState state)
+        protected override bool OnMouseMove(MouseMoveEvent e)
         {
             // keep the scheduled event correctly timed as long as we have movement.
             schedulePopOut();
-            return base.OnMouseMove(state);
+            return base.OnMouseMove(e);
         }
 
-        protected override bool OnHover(InputState state)
+        protected override bool OnHover(HoverEvent e)
         {
             schedulePopOut();
             return true;
         }
 
-        protected override void OnHoverLost(InputState state)
+        protected override void OnHoverLost(HoverLostEvent e)
         {
             schedulePopOut();
-            base.OnHoverLost(state);
+            base.OnHoverLost(e);
         }
 
         private void schedulePopOut()

osu.Game/Rulesets/Edit/HitObjectMask.cs

@@ -5,7 +5,7 @@ using System;
 using osu.Framework;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Primitives;
-using osu.Framework.Input.EventArgs;
+using osu.Framework.Input.Events;
 using osu.Framework.Input.States;
 using osu.Game.Graphics.UserInterface;
 using osu.Game.Rulesets.Objects.Drawables;
@@ -37,7 +37,7 @@ namespace osu.Game.Rulesets.Edit
         /// <summary>
         /// Invoked when this <see cref="HitObjectMask"/> has requested drag.
         /// </summary>
-        public event Action<HitObjectMask, InputState> DragRequested;
+        public event Action<HitObjectMask, Vector2, InputState> DragRequested;
 
         /// <summary>
         /// The <see cref="DrawableHitObject"/> which this <see cref="HitObjectMask"/> applies to.
@@ -96,36 +96,36 @@ namespace osu.Game.Rulesets.Edit
 
         private bool selectionRequested;
 
-        protected override bool OnMouseDown(InputState state, MouseDownEventArgs args)
+        protected override bool OnMouseDown(MouseDownEvent e)
         {
             selectionRequested = false;
 
             if (State == SelectionState.NotSelected)
             {
-                SelectionRequested?.Invoke(this, state);
+                SelectionRequested?.Invoke(this, e.CurrentState);
                 selectionRequested = true;
             }
 
             return IsSelected;
         }
 
-        protected override bool OnClick(InputState state)
+        protected override bool OnClick(ClickEvent e)
         {
             if (State == SelectionState.Selected && !selectionRequested)
             {
                 selectionRequested = true;
-                SelectionRequested?.Invoke(this, state);
+                SelectionRequested?.Invoke(this, e.CurrentState);
                 return true;
             }
 
-            return base.OnClick(state);
+            return base.OnClick(e);
         }
 
-        protected override bool OnDragStart(InputState state) => true;
+        protected override bool OnDragStart(DragStartEvent e) => true;
 
-        protected override bool OnDrag(InputState state)
+        protected override bool OnDrag(DragEvent e)
         {
-            DragRequested?.Invoke(this, state);
+            DragRequested?.Invoke(this, e.Delta, e.CurrentState);
             return true;
         }
 

osu.Game/Rulesets/Judgements/DrawableJudgement.cs

@@ -19,7 +19,7 @@ namespace osu.Game.Rulesets.Judgements
     /// <summary>
     /// A drawable object which visualises the hit result of a <see cref="Judgements.Judgement"/>.
     /// </summary>
-    public class DrawableJudgement : Container
+    public class DrawableJudgement : CompositeDrawable
     {
         private const float judgement_size = 80;
 
@@ -29,6 +29,7 @@ namespace osu.Game.Rulesets.Judgements
 
         public readonly DrawableHitObject JudgedObject;
 
+        protected Container JudgementBody;
         protected SpriteText JudgementText;
 
         /// <summary>
@@ -49,14 +50,20 @@ namespace osu.Game.Rulesets.Judgements
         {
             this.colours = colours;
 
-            Child = new SkinnableDrawable($"Play/{Result.Type}", _ => JudgementText = new OsuSpriteText
+            InternalChild = JudgementBody = new Container
             {
-                Text = Result.Type.GetDescription().ToUpperInvariant(),
+                Anchor = Anchor.Centre,
-                Font = @"Venera",
+                Origin = Anchor.Centre,
-                Colour = judgementColour(Result.Type),
+                RelativeSizeAxes = Axes.Both,
-                Scale = new Vector2(0.85f, 1),
+                Child = new SkinnableDrawable($"Play/{Result.Type}", _ => JudgementText = new OsuSpriteText
-                TextSize = 12
+                {
-            }, restrictSize: false);
+                    Text = Result.Type.GetDescription().ToUpperInvariant(),
+                    Font = @"Venera",
+                    Colour = judgementColour(Result.Type),
+                    Scale = new Vector2(0.85f, 1),
+                    TextSize = 12
+                }, restrictSize: false)
+            };
         }
 
         protected override void LoadComplete()
@@ -65,24 +72,22 @@ namespace osu.Game.Rulesets.Judgements
 
             this.FadeInFromZero(100, Easing.OutQuint);
 
-            var origScale = Scale;
-
             switch (Result.Type)
             {
                 case HitResult.None:
                     break;
                 case HitResult.Miss:
-                    this.ScaleTo(origScale * 1.6f);
+                    JudgementBody.ScaleTo(1.6f);
-                    this.ScaleTo(origScale, 100, Easing.In);
+                    JudgementBody.ScaleTo(1, 100, Easing.In);
 
-                    this.MoveToOffset(new Vector2(0, 100), 800, Easing.InQuint);
+                    JudgementBody.MoveToOffset(new Vector2(0, 100), 800, Easing.InQuint);
-                    this.RotateTo(40, 800, Easing.InQuint);
+                    JudgementBody.RotateTo(40, 800, Easing.InQuint);
 
                     this.Delay(600).FadeOut(200);
                     break;
                 default:
-                    this.ScaleTo(origScale * 0.9f);
+                    JudgementBody.ScaleTo(0.9f);
-                    this.ScaleTo(origScale, 500, Easing.OutElastic);
+                    JudgementBody.ScaleTo(1, 500, Easing.OutElastic);
 
                     this.Delay(100).FadeOut(400);
                     break;
@@ -105,9 +110,9 @@ namespace osu.Game.Rulesets.Judgements
                     return colours.Yellow;
                 case HitResult.Miss:
                     return colours.Red;
+                default:
+                    return Color4.White;
             }
-
-            return Color4.White;
         }
     }
 }

osu.Game/Rulesets/UI/RulesetInputManager.cs

@@ -8,7 +8,7 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Input;
 using osu.Framework.Input.Bindings;
-using osu.Framework.Input.EventArgs;
+using osu.Framework.Input.Events;
 using osu.Framework.Input.StateChanges.Events;
 using osu.Framework.Input.States;
 using osu.Framework.Timing;
@@ -18,6 +18,9 @@ using osu.Game.Input.Handlers;
 using osu.Game.Screens.Play;
 using OpenTK.Input;
 using static osu.Game.Input.Handlers.ReplayInputHandler;
+using JoystickState = osu.Framework.Input.States.JoystickState;
+using KeyboardState = osu.Framework.Input.States.KeyboardState;
+using MouseState = osu.Framework.Input.States.MouseState;
 
 namespace osu.Game.Rulesets.UI
 {
@@ -35,13 +38,7 @@ namespace osu.Game.Rulesets.UI
         protected override InputState CreateInitialState()
         {
             var state = base.CreateInitialState();
-            return new RulesetInputManagerInputState<T>
+            return new RulesetInputManagerInputState<T>(state.Mouse, state.Keyboard, state.Joystick);
-            {
-                Mouse = state.Mouse,
-                Keyboard = state.Keyboard,
-                Joystick = state.Joystick,
-                LastReplayState = null
-            };
         }
 
         protected readonly KeyBindingContainer<T> KeyBindingContainer;
@@ -76,12 +73,10 @@ namespace osu.Game.Rulesets.UI
         #region IHasReplayHandler
 
         private ReplayInputHandler replayInputHandler;
+
         public ReplayInputHandler ReplayInputHandler
         {
-            get
+            get => replayInputHandler;
-            {
-                return replayInputHandler;
-            }
             set
             {
                 if (replayInputHandler != null) RemoveHandler(replayInputHandler);
@@ -211,16 +206,20 @@ namespace osu.Game.Rulesets.UI
             mouseDisabled = config.GetBindable<bool>(OsuSetting.MouseDisableButtons);
         }
 
-        protected override bool OnMouseDown(InputState state, MouseDownEventArgs args)
+        protected override bool Handle(UIEvent e)
         {
-            if (mouseDisabled.Value && (args.Button == MouseButton.Left || args.Button == MouseButton.Right)) return false;
+            switch (e)
-            return base.OnMouseDown(state, args);
+            {
-        }
+                case MouseDownEvent mouseDown when mouseDown.Button == MouseButton.Left || mouseDown.Button == MouseButton.Right:
-
+                    if (mouseDisabled.Value)
-        protected override bool OnMouseUp(InputState state, MouseUpEventArgs args)
+                        return false;
-        {
+                    break;
-            if (!CurrentState.Mouse.IsPressed(args.Button)) return false;
+                case MouseUpEvent mouseUp:
-            return base.OnMouseUp(state, args);
+                    if (!CurrentState.Mouse.IsPressed(mouseUp.Button))
+                        return false;
+                    break;
+            }
+            return base.Handle(e);
         }
 
         #endregion
@@ -272,8 +271,13 @@ namespace osu.Game.Rulesets.UI
     }
 
     public class RulesetInputManagerInputState<T> : InputState
-    where T : struct
+        where T : struct
     {
         public ReplayState<T> LastReplayState;
+
+        public RulesetInputManagerInputState(MouseState mouse = null, KeyboardState keyboard = null, JoystickState joystick = null)
+            : base(mouse, keyboard, joystick)
+        {
+        }
     }
 }

osu.Game/Rulesets/UI/Scrolling/ScrollingHitObjectContainer.cs

@@ -1,7 +1,6 @@
 // Copyright (c) 2007-2018 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.Caching;
 using osu.Framework.Configuration;
 using osu.Framework.Graphics;
@@ -33,20 +32,16 @@ namespace osu.Game.Rulesets.UI.Scrolling
 
         private Cached initialStateCache = new Cached();
 
-        public ScrollingHitObjectContainer()
+        private readonly ISpeedChangeVisualiser speedChangeVisualiser;
+
+        public ScrollingHitObjectContainer(SpeedChangeVisualisationMethod visualisationMethod)
         {
             RelativeSizeAxes = Axes.Both;
 
             TimeRange.ValueChanged += _ => initialStateCache.Invalidate();
             Direction.ValueChanged += _ => initialStateCache.Invalidate();
-        }
 
-        private ISpeedChangeVisualiser speedChangeVisualiser;
+            switch (visualisationMethod)
-
-        [BackgroundDependencyLoader]
-        private void load(OsuConfigManager config)
-        {
-            switch (config.Get<SpeedChangeVisualisationMethod>(OsuSetting.SpeedChangeVisualisation))
             {
                 case SpeedChangeVisualisationMethod.Sequential:
                     speedChangeVisualiser = new SequentialSpeedChangeVisualiser(ControlPoints);
@@ -54,6 +49,9 @@ namespace osu.Game.Rulesets.UI.Scrolling
                 case SpeedChangeVisualisationMethod.Overlapping:
                     speedChangeVisualiser = new OverlappingSpeedChangeVisualiser(ControlPoints);
                     break;
+                case SpeedChangeVisualisationMethod.Constant:
+                    speedChangeVisualiser = new ConstantSpeedChangeVisualiser();
+                    break;
             }
         }
 

osu.Game/Rulesets/UI/Scrolling/ScrollingPlayfield.cs

@@ -5,6 +5,7 @@ using osu.Framework.Allocation;
 using osu.Framework.Configuration;
 using osu.Framework.Graphics;
 using osu.Framework.Input.Bindings;
+using osu.Game.Configuration;
 using osu.Game.Input.Bindings;
 using osu.Game.Rulesets.Objects.Drawables;
 
@@ -62,6 +63,8 @@ namespace osu.Game.Rulesets.UI.Scrolling
         /// </summary>
         protected readonly Bindable<ScrollingDirection> Direction = new Bindable<ScrollingDirection>();
 
+        protected virtual SpeedChangeVisualisationMethod VisualisationMethod => SpeedChangeVisualisationMethod.Sequential;
+
         /// <summary>
         /// Creates a new <see cref="ScrollingPlayfield"/>.
         /// </summary>
@@ -104,7 +107,7 @@ namespace osu.Game.Rulesets.UI.Scrolling
 
         protected sealed override HitObjectContainer CreateHitObjectContainer()
         {
-            var container = new ScrollingHitObjectContainer();
+            var container = new ScrollingHitObjectContainer(VisualisationMethod);
             container.Direction.BindTo(Direction);
             return container;
         }

osu.Game/Rulesets/UI/Scrolling/Visualisers/ConstantSpeedChangeVisualiser.cs

@@ -0,0 +1,67 @@
+// Copyright (c) 2007-2018 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.Game.Rulesets.Objects.Drawables;
+using osu.Game.Rulesets.Objects.Types;
+using OpenTK;
+
+namespace osu.Game.Rulesets.UI.Scrolling.Visualisers
+{
+    public class ConstantSpeedChangeVisualiser : ISpeedChangeVisualiser
+    {
+        public void ComputeInitialStates(IEnumerable<DrawableHitObject> hitObjects, ScrollingDirection direction, double timeRange, Vector2 length)
+        {
+            foreach (var obj in hitObjects)
+            {
+                obj.LifetimeStart = obj.HitObject.StartTime - timeRange;
+
+                if (obj.HitObject is IHasEndTime endTime)
+                {
+                    var hitObjectLength = (endTime.EndTime - obj.HitObject.StartTime) / timeRange;
+
+                    switch (direction)
+                    {
+                        case ScrollingDirection.Up:
+                        case ScrollingDirection.Down:
+                            obj.Height = (float)(hitObjectLength * length.Y);
+                            break;
+                        case ScrollingDirection.Left:
+                        case ScrollingDirection.Right:
+                            obj.Width = (float)(hitObjectLength * length.X);
+                            break;
+                    }
+                }
+
+                ComputeInitialStates(obj.NestedHitObjects, direction, timeRange, length);
+
+                // Nested hitobjects don't need to scroll, but they do need accurate positions
+                UpdatePositions(obj.NestedHitObjects, direction, obj.HitObject.StartTime, timeRange, length);
+            }
+        }
+
+        public void UpdatePositions(IEnumerable<DrawableHitObject> hitObjects, ScrollingDirection direction, double currentTime, double timeRange, Vector2 length)
+        {
+            foreach (var obj in hitObjects)
+            {
+                var position = (obj.HitObject.StartTime - currentTime) / timeRange;
+
+                switch (direction)
+                {
+                    case ScrollingDirection.Up:
+                        obj.Y = (float)(position * length.Y);
+                        break;
+                    case ScrollingDirection.Down:
+                        obj.Y = (float)(-position * length.Y);
+                        break;
+                    case ScrollingDirection.Left:
+                        obj.X = (float)(position * length.X);
+                        break;
+                    case ScrollingDirection.Right:
+                        obj.X = (float)(-position * length.X);
+                        break;
+                }
+            }
+        }
+    }
+}

osu.Game/Screens/BackgroundScreen.cs

@@ -5,8 +5,7 @@ using System;
 using System.Threading;
 using osu.Framework.Screens;
 using osu.Framework.Graphics;
-using osu.Framework.Input.EventArgs;
+using osu.Framework.Input.Events;
-using osu.Framework.Input.States;
 using OpenTK;
 
 namespace osu.Game.Screens
@@ -21,7 +20,7 @@ namespace osu.Game.Screens
         private const float transition_length = 500;
         private const float x_movement_amount = 50;
 
-        protected override bool OnKeyDown(InputState state, KeyDownEventArgs args)
+        protected override bool OnKeyDown(KeyDownEvent e)
         {
             //we don't want to handle escape key.
             return false;

osu.Game/Screens/Edit/Components/PlaybackControl.cs

@@ -8,7 +8,7 @@ using osu.Framework.Extensions.IEnumerableExtensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.UserInterface;
-using osu.Framework.Input.States;
+using osu.Framework.Input.Events;
 using osu.Framework.Timing;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Sprites;
@@ -138,13 +138,13 @@ namespace osu.Game.Screens.Edit.Components
                     textBold.Colour = hoveredColour = colours.Yellow;
                 }
 
-                protected override bool OnHover(InputState state)
+                protected override bool OnHover(HoverEvent e)
                 {
                     updateState();
                     return true;
                 }
 
-                protected override void OnHoverLost(InputState state) => updateState();
+                protected override void OnHoverLost(HoverLostEvent e) => updateState();
                 protected override void OnActivated() => updateState();
                 protected override void OnDeactivated() => updateState();
 

osu.Game/Screens/Edit/Components/Timelines/Summary/Parts/MarkerPart.cs

@@ -6,8 +6,7 @@ using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
-using osu.Framework.Input.EventArgs;
+using osu.Framework.Input.Events;
-using osu.Framework.Input.States;
 using osu.Framework.Timing;
 using osu.Game.Beatmaps;
 using osu.Game.Graphics;
@@ -30,17 +29,17 @@ namespace osu.Game.Screens.Edit.Components.Timelines.Summary.Parts
             Add(marker = new MarkerVisualisation());
         }
 
-        protected override bool OnDragStart(InputState state) => true;
+        protected override bool OnDragStart(DragStartEvent e) => true;
-        protected override bool OnDragEnd(InputState state) => true;
+        protected override bool OnDragEnd(DragEndEvent e) => true;
-        protected override bool OnDrag(InputState state)
+        protected override bool OnDrag(DragEvent e)
         {
-            seekToPosition(state.Mouse.NativeState.Position);
+            seekToPosition(e.ScreenSpaceMousePosition);
             return true;
         }
 
-        protected override bool OnMouseDown(InputState state, MouseDownEventArgs args)
+        protected override bool OnMouseDown(MouseDownEvent e)
         {
-            seekToPosition(state.Mouse.NativeState.Position);
+            seekToPosition(e.ScreenSpaceMousePosition);
             return true;
         }