Merge branch 'master' of https://github.com/ppy/osu into present-recommended

 Conflicts:

	osu.Game/OsuGameBase.cs

	osu.Game/Screens/Select/DifficultyRecommender.cs

	osu.Game/Screens/Select/SongSelect.cs

osu.Game/Screens/Backgrounds/BackgroundScreenDefault.cs

@@ -1,6 +1,7 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System.Threading;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
@@ -21,12 +22,11 @@ namespace osu.Game.Screens.Backgrounds
 
         private int currentDisplay;
         private const int background_count = 7;
-
-        private string backgroundName => $@"Menu/menu-background-{currentDisplay % background_count + 1}";
-
         private Bindable<User> user;
         private Bindable<Skin> skin;
         private Bindable<BackgroundSource> mode;
+        private Bindable<IntroSequence> introSequence;
+        private readonly SeasonalBackgroundLoader seasonalBackgroundLoader = new SeasonalBackgroundLoader();
 
         [Resolved]
         private IBindable<WorkingBeatmap> beatmap { get; set; }
@@ -42,15 +42,20 @@ namespace osu.Game.Screens.Backgrounds
             user = api.LocalUser.GetBoundCopy();
             skin = skinManager.CurrentSkin.GetBoundCopy();
             mode = config.GetBindable<BackgroundSource>(OsuSetting.MenuBackgroundSource);
+            introSequence = config.GetBindable<IntroSequence>(OsuSetting.IntroSequence);
+
+            AddInternal(seasonalBackgroundLoader);
 
             user.ValueChanged += _ => Next();
             skin.ValueChanged += _ => Next();
             mode.ValueChanged += _ => Next();
             beatmap.ValueChanged += _ => Next();
+            introSequence.ValueChanged += _ => Next();
+            seasonalBackgroundLoader.SeasonalBackgroundChanged += Next;
 
             currentDisplay = RNG.Next(0, background_count);
 
-            display(createBackground());
+            Next();
         }
 
         private void display(Background newBackground)
@@ -63,16 +68,39 @@ namespace osu.Game.Screens.Backgrounds
         }
 
         private ScheduledDelegate nextTask;
+        private CancellationTokenSource cancellationTokenSource;
 
         public void Next()
         {
             nextTask?.Cancel();
-            nextTask = Scheduler.AddDelayed(() => { LoadComponentAsync(createBackground(), display); }, 100);
+            cancellationTokenSource?.Cancel();
+            cancellationTokenSource = new CancellationTokenSource();
+            nextTask = Scheduler.AddDelayed(() => LoadComponentAsync(createBackground(), display, cancellationTokenSource.Token), 100);
         }
 
         private Background createBackground()
         {
             Background newBackground;
+            string backgroundName;
+
+            var seasonalBackground = seasonalBackgroundLoader.LoadNextBackground();
+
+            if (seasonalBackground != null)
+            {
+                seasonalBackground.Depth = currentDisplay;
+                return seasonalBackground;
+            }
+
+            switch (introSequence.Value)
+            {
+                case IntroSequence.Welcome:
+                    backgroundName = "Intro/Welcome/menu-background";
+                    break;
+
+                default:
+                    backgroundName = $@"Menu/menu-background-{currentDisplay % background_count + 1}";
+                    break;
+            }
 
             if (user.Value?.IsSupporter ?? false)
             {

osu.Game/Screens/Edit/ClipboardContent.cs

@@ -0,0 +1,27 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Collections.Generic;
+using System.Linq;
+using Newtonsoft.Json;
+using osu.Game.IO.Serialization;
+using osu.Game.IO.Serialization.Converters;
+using osu.Game.Rulesets.Objects;
+
+namespace osu.Game.Screens.Edit
+{
+    public class ClipboardContent : IJsonSerializable
+    {
+        [JsonConverter(typeof(TypedListConverter<HitObject>))]
+        public IList<HitObject> HitObjects;
+
+        public ClipboardContent()
+        {
+        }
+
+        public ClipboardContent(EditorBeatmap editorBeatmap)
+        {
+            HitObjects = editorBeatmap.SelectedHitObjects.ToList();
+        }
+    }
+}

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

@@ -18,7 +18,8 @@ namespace osu.Game.Screens.Edit.Components
         private const float contents_padding = 15;
 
         protected readonly IBindable<WorkingBeatmap> Beatmap = new Bindable<WorkingBeatmap>();
-        protected Track Track => Beatmap.Value.Track;
+
+        protected readonly IBindable<Track> Track = new Bindable<Track>();
 
         private readonly Drawable background;
         private readonly Container content;
@@ -42,9 +43,11 @@ namespace osu.Game.Screens.Edit.Components
         }
 
         [BackgroundDependencyLoader]
-        private void load(IBindable<WorkingBeatmap> beatmap, OsuColour colours)
+        private void load(IBindable<WorkingBeatmap> beatmap, OsuColour colours, EditorClock clock)
         {
             Beatmap.BindTo(beatmap);
+            Track.BindTo(clock.Track);
+
             background.Colour = colours.Gray1;
         }
     }

osu.Game/Screens/Edit/Components/Menus/EditorMenuBar.cs

@@ -163,30 +163,27 @@ namespace osu.Game.Screens.Edit.Components.Menus
 
             protected override Framework.Graphics.UserInterface.Menu CreateSubMenu() => new SubMenu();
 
-            protected override DrawableMenuItem CreateDrawableMenuItem(MenuItem item) => new DrawableSubMenuItem(item);
-
-            private class DrawableSubMenuItem : DrawableOsuMenuItem
+            protected override DrawableMenuItem CreateDrawableMenuItem(MenuItem item)
             {
-                public DrawableSubMenuItem(MenuItem item)
+                switch (item)
+                {
+                    case EditorMenuItemSpacer spacer:
+                        return new DrawableSpacer(spacer);
+                }
+
+                return base.CreateDrawableMenuItem(item);
+            }
+
+            private class DrawableSpacer : DrawableOsuMenuItem
+            {
+                public DrawableSpacer(MenuItem item)
                     : base(item)
                 {
                 }
 
-                protected override bool OnHover(HoverEvent e)
-                {
-                    if (Item is EditorMenuItemSpacer)
-                        return true;
+                protected override bool OnHover(HoverEvent e) => true;
 
-                    return base.OnHover(e);
-                }
-
-                protected override bool OnClick(ClickEvent e)
-                {
-                    if (Item is EditorMenuItemSpacer)
-                        return true;
-
-                    return base.OnClick(e);
-                }
+                protected override bool OnClick(ClickEvent e) => true;
             }
         }
     }

osu.Game/Screens/Edit/Components/Menus/ScreenSelectionTabControl.cs

@@ -32,8 +32,6 @@ namespace osu.Game.Screens.Edit.Components.Menus
                 Height = 1,
                 Colour = Color4.White.Opacity(0.2f),
             });
-
-            Current.Value = EditorScreenMode.Compose;
         }
 
         [BackgroundDependencyLoader]

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

@@ -62,12 +62,12 @@ namespace osu.Game.Screens.Edit.Components
                 }
             };
 
-            Track?.AddAdjustment(AdjustableProperty.Tempo, tempo);
+            Track.BindValueChanged(tr => tr.NewValue?.AddAdjustment(AdjustableProperty.Tempo, tempo), true);
         }
 
         protected override void Dispose(bool isDisposing)
         {
-            Track?.RemoveAdjustment(AdjustableProperty.Tempo, tempo);
+            Track.Value?.RemoveAdjustment(AdjustableProperty.Tempo, tempo);
 
             base.Dispose(isDisposing);
         }

osu.Game/Screens/Edit/Components/RadioButtons/DrawableRadioButton.cs

@@ -5,7 +5,6 @@ using System;
 using osu.Framework.Allocation;
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
-using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Effects;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Graphics.Sprites;
@@ -29,7 +28,7 @@ namespace osu.Game.Screens.Edit.Components.RadioButtons
         private Color4 selectedBackgroundColour;
         private Color4 selectedBubbleColour;
 
-        private readonly Drawable bubble;
+        private Drawable icon;
         private readonly RadioButton button;
 
         public DrawableRadioButton(RadioButton button)
@@ -40,19 +39,6 @@ namespace osu.Game.Screens.Edit.Components.RadioButtons
             Action = button.Select;
 
             RelativeSizeAxes = Axes.X;
-
-            bubble = new CircularContainer
-            {
-                Anchor = Anchor.CentreLeft,
-                Origin = Anchor.CentreLeft,
-                RelativeSizeAxes = Axes.Both,
-                FillMode = FillMode.Fit,
-                Scale = new Vector2(0.5f),
-                X = 10,
-                Masking = true,
-                Blending = BlendingParameters.Additive,
-                Child = new Box { RelativeSizeAxes = Axes.Both }
-            };
         }
 
         [BackgroundDependencyLoader]
@@ -73,7 +59,14 @@ namespace osu.Game.Screens.Edit.Components.RadioButtons
                 Colour = Color4.Black.Opacity(0.5f)
             };
 
-            Add(bubble);
+            Add(icon = (button.CreateIcon?.Invoke() ?? new Circle()).With(b =>
+            {
+                b.Blending = BlendingParameters.Additive;
+                b.Anchor = Anchor.CentreLeft;
+                b.Origin = Anchor.CentreLeft;
+                b.Size = new Vector2(20);
+                b.X = 10;
+            }));
         }
 
         protected override void LoadComplete()
@@ -96,7 +89,7 @@ namespace osu.Game.Screens.Edit.Components.RadioButtons
                 return;
 
             BackgroundColour = button.Selected.Value ? selectedBackgroundColour : defaultBackgroundColour;
-            bubble.Colour = button.Selected.Value ? selectedBubbleColour : defaultBubbleColour;
+            icon.Colour = button.Selected.Value ? selectedBubbleColour : defaultBubbleColour;
         }
 
         protected override SpriteText CreateText() => new OsuSpriteText

osu.Game/Screens/Edit/Components/RadioButtons/RadioButton.cs

@@ -3,6 +3,7 @@
 
 using System;
 using osu.Framework.Bindables;
+using osu.Framework.Graphics;
 
 namespace osu.Game.Screens.Edit.Components.RadioButtons
 {
@@ -19,11 +20,17 @@ namespace osu.Game.Screens.Edit.Components.RadioButtons
         /// </summary>
         public object Item;
 
+        /// <summary>
+        /// A function which creates a drawable icon to represent this item. If null, a sane default should be used.
+        /// </summary>
+        public readonly Func<Drawable> CreateIcon;
+
         private readonly Action action;
 
-        public RadioButton(object item, Action action)
+        public RadioButton(object item, Action action, Func<Drawable> createIcon = null)
         {
             Item = item;
+            CreateIcon = createIcon;
             this.action = action;
             Selected = new BindableBool();
         }

osu.Game/Screens/Edit/Components/TernaryButtons/DrawableTernaryButton.cs

@@ -0,0 +1,112 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Allocation;
+using osu.Framework.Extensions.Color4Extensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Effects;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Graphics.Sprites;
+using osu.Game.Graphics;
+using osu.Game.Graphics.Sprites;
+using osu.Game.Graphics.UserInterface;
+using osuTK;
+using osuTK.Graphics;
+
+namespace osu.Game.Screens.Edit.Components.TernaryButtons
+{
+    internal class DrawableTernaryButton : TriangleButton
+    {
+        private Color4 defaultBackgroundColour;
+        private Color4 defaultBubbleColour;
+        private Color4 selectedBackgroundColour;
+        private Color4 selectedBubbleColour;
+
+        private Drawable icon;
+
+        public readonly TernaryButton Button;
+
+        public DrawableTernaryButton(TernaryButton button)
+        {
+            Button = button;
+
+            Text = button.Description;
+
+            RelativeSizeAxes = Axes.X;
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(OsuColour colours)
+        {
+            defaultBackgroundColour = colours.Gray3;
+            defaultBubbleColour = defaultBackgroundColour.Darken(0.5f);
+            selectedBackgroundColour = colours.BlueDark;
+            selectedBubbleColour = selectedBackgroundColour.Lighten(0.5f);
+
+            Triangles.Alpha = 0;
+
+            Content.EdgeEffect = new EdgeEffectParameters
+            {
+                Type = EdgeEffectType.Shadow,
+                Radius = 2,
+                Offset = new Vector2(0, 1),
+                Colour = Color4.Black.Opacity(0.5f)
+            };
+
+            Add(icon = (Button.CreateIcon?.Invoke() ?? new Circle()).With(b =>
+            {
+                b.Blending = BlendingParameters.Additive;
+                b.Anchor = Anchor.CentreLeft;
+                b.Origin = Anchor.CentreLeft;
+                b.Size = new Vector2(20);
+                b.X = 10;
+            }));
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            Button.Bindable.BindValueChanged(selected => updateSelectionState(), true);
+
+            Action = onAction;
+        }
+
+        private void onAction()
+        {
+            Button.Toggle();
+        }
+
+        private void updateSelectionState()
+        {
+            if (!IsLoaded)
+                return;
+
+            switch (Button.Bindable.Value)
+            {
+                case TernaryState.Indeterminate:
+                    icon.Colour = selectedBubbleColour.Darken(0.5f);
+                    BackgroundColour = selectedBackgroundColour.Darken(0.5f);
+                    break;
+
+                case TernaryState.False:
+                    icon.Colour = defaultBubbleColour;
+                    BackgroundColour = defaultBackgroundColour;
+                    break;
+
+                case TernaryState.True:
+                    icon.Colour = selectedBubbleColour;
+                    BackgroundColour = selectedBackgroundColour;
+                    break;
+            }
+        }
+
+        protected override SpriteText CreateText() => new OsuSpriteText
+        {
+            Depth = -1,
+            Origin = Anchor.CentreLeft,
+            Anchor = Anchor.CentreLeft,
+            X = 40f
+        };
+    }
+}

osu.Game/Screens/Edit/Components/TernaryButtons/TernaryButton.cs

@@ -0,0 +1,44 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Game.Graphics.UserInterface;
+
+namespace osu.Game.Screens.Edit.Components.TernaryButtons
+{
+    public class TernaryButton
+    {
+        public readonly Bindable<TernaryState> Bindable;
+
+        public readonly string Description;
+
+        /// <summary>
+        /// A function which creates a drawable icon to represent this item. If null, a sane default should be used.
+        /// </summary>
+        public readonly Func<Drawable> CreateIcon;
+
+        public TernaryButton(Bindable<TernaryState> bindable, string description, Func<Drawable> createIcon = null)
+        {
+            Bindable = bindable;
+            Description = description;
+            CreateIcon = createIcon;
+        }
+
+        public void Toggle()
+        {
+            switch (Bindable.Value)
+            {
+                case TernaryState.False:
+                case TernaryState.Indeterminate:
+                    Bindable.Value = TernaryState.True;
+                    break;
+
+                case TernaryState.True:
+                    Bindable.Value = TernaryState.False;
+                    break;
+            }
+        }
+    }
+}

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

@@ -3,8 +3,8 @@
 
 using osu.Framework.Graphics;
 using osu.Game.Graphics.Sprites;
-using System;
 using osu.Framework.Allocation;
+using osu.Game.Extensions;
 using osu.Game.Graphics;
 
 namespace osu.Game.Screens.Edit.Components
@@ -22,10 +22,12 @@ namespace osu.Game.Screens.Edit.Components
             {
                 trackTimer = new OsuSpriteText
                 {
-                    Origin = Anchor.BottomLeft,
-                    RelativePositionAxes = Axes.Y,
-                    Font = OsuFont.GetFont(size: 22, fixedWidth: true),
-                    Y = 0.5f,
+                    Anchor = Anchor.CentreRight,
+                    Origin = Anchor.CentreRight,
+                    // intentionally fudged centre to avoid movement of the number portion when
+                    // going negative.
+                    X = -35,
+                    Font = OsuFont.GetFont(size: 25, fixedWidth: true),
                 }
             };
         }
@@ -33,8 +35,7 @@ namespace osu.Game.Screens.Edit.Components
         protected override void Update()
         {
             base.Update();
-
-            trackTimer.Text = TimeSpan.FromMilliseconds(editorClock.CurrentTime).ToString(@"mm\:ss\:fff");
+            trackTimer.Text = editorClock.CurrentTime.ToEditorFormattedString();
         }
     }
 }

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

@@ -1,70 +1,51 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System.Collections.Specialized;
 using System.Linq;
-using osu.Framework.Allocation;
-using osu.Framework.Extensions.IEnumerableExtensions;
+using osu.Framework.Bindables;
 using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.ControlPoints;
-using osu.Game.Graphics;
-using osu.Game.Screens.Edit.Components.Timelines.Summary.Visualisations;
 
 namespace osu.Game.Screens.Edit.Components.Timelines.Summary.Parts
 {
     /// <summary>
     /// The part of the timeline that displays the control points.
     /// </summary>
-    public class ControlPointPart : TimelinePart
+    public class ControlPointPart : TimelinePart<GroupVisualisation>
     {
+        private readonly IBindableList<ControlPointGroup> controlPointGroups = new BindableList<ControlPointGroup>();
+
         protected override void LoadBeatmap(WorkingBeatmap beatmap)
         {
             base.LoadBeatmap(beatmap);
 
-            ControlPointInfo cpi = beatmap.Beatmap.ControlPointInfo;
-
-            cpi.TimingPoints.ForEach(addTimingPoint);
-
-            // Consider all non-timing points as the same type
-            cpi.SamplePoints.Select(c => (ControlPoint)c)
-               .Concat(cpi.EffectPoints)
-               .Concat(cpi.DifficultyPoints)
-               .Distinct()
-               // Non-timing points should not be added where there are timing points
-               .Where(c => cpi.TimingPointAt(c.Time).Time != c.Time)
-               .ForEach(addNonTimingPoint);
-        }
-
-        private void addTimingPoint(ControlPoint controlPoint) => Add(new TimingPointVisualisation(controlPoint));
-        private void addNonTimingPoint(ControlPoint controlPoint) => Add(new NonTimingPointVisualisation(controlPoint));
-
-        private class TimingPointVisualisation : ControlPointVisualisation
-        {
-            public TimingPointVisualisation(ControlPoint controlPoint)
-                : base(controlPoint)
+            controlPointGroups.UnbindAll();
+            controlPointGroups.BindTo(beatmap.Beatmap.ControlPointInfo.Groups);
+            controlPointGroups.BindCollectionChanged((sender, args) =>
             {
-            }
+                switch (args.Action)
+                {
+                    case NotifyCollectionChangedAction.Reset:
+                        Clear();
+                        break;
 
-            [BackgroundDependencyLoader]
-            private void load(OsuColour colours) => Colour = colours.YellowDark;
-        }
+                    case NotifyCollectionChangedAction.Add:
+                        foreach (var group in args.NewItems.OfType<ControlPointGroup>())
+                            Add(new GroupVisualisation(group));
+                        break;
 
-        private class NonTimingPointVisualisation : ControlPointVisualisation
-        {
-            public NonTimingPointVisualisation(ControlPoint controlPoint)
-                : base(controlPoint)
-            {
-            }
+                    case NotifyCollectionChangedAction.Remove:
+                        foreach (var group in args.OldItems.OfType<ControlPointGroup>())
+                        {
+                            var matching = Children.SingleOrDefault(gv => gv.Group == group);
 
-            [BackgroundDependencyLoader]
-            private void load(OsuColour colours) => Colour = colours.Green;
-        }
+                            matching?.Expire();
+                        }
 
-        private abstract class ControlPointVisualisation : PointVisualisation
-        {
-            protected ControlPointVisualisation(ControlPoint controlPoint)
-                : base(controlPoint.Time)
-            {
-            }
+                        break;
+                }
+            }, true);
         }
     }
 }

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

@@ -0,0 +1,46 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Linq;
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Game.Beatmaps.ControlPoints;
+using osu.Game.Graphics;
+using osu.Game.Screens.Edit.Components.Timelines.Summary.Visualisations;
+using osuTK.Graphics;
+
+namespace osu.Game.Screens.Edit.Components.Timelines.Summary.Parts
+{
+    public class GroupVisualisation : PointVisualisation
+    {
+        public readonly ControlPointGroup Group;
+
+        private readonly IBindableList<ControlPoint> controlPoints = new BindableList<ControlPoint>();
+
+        [Resolved]
+        private OsuColour colours { get; set; }
+
+        public GroupVisualisation(ControlPointGroup group)
+            : base(group.Time)
+        {
+            Group = group;
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            controlPoints.BindTo(Group.ControlPoints);
+            controlPoints.BindCollectionChanged((_, __) =>
+            {
+                if (controlPoints.Count == 0)
+                {
+                    Colour = Color4.Transparent;
+                    return;
+                }
+
+                Colour = controlPoints.Any(c => c is TimingControlPoint) ? colours.YellowDark : colours.Green;
+            }, true);
+        }
+    }
+}

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

@@ -3,6 +3,7 @@
 
 using System;
 using osu.Framework.Allocation;
+using osu.Framework.Audio.Track;
 using osu.Framework.Bindables;
 using osuTK;
 using osu.Framework.Graphics;
@@ -22,6 +23,8 @@ namespace osu.Game.Screens.Edit.Components.Timelines.Summary.Parts
     {
         protected readonly IBindable<WorkingBeatmap> Beatmap = new Bindable<WorkingBeatmap>();
 
+        protected readonly IBindable<Track> Track = new Bindable<Track>();
+
         private readonly Container<T> content;
 
         protected override Container<T> Content => content;
@@ -35,12 +38,15 @@ namespace osu.Game.Screens.Edit.Components.Timelines.Summary.Parts
                 updateRelativeChildSize();
                 LoadBeatmap(b.NewValue);
             };
+
+            Track.ValueChanged += _ => updateRelativeChildSize();
         }
 
         [BackgroundDependencyLoader]
-        private void load(IBindable<WorkingBeatmap> beatmap)
+        private void load(IBindable<WorkingBeatmap> beatmap, EditorClock clock)
         {
             Beatmap.BindTo(beatmap);
+            Track.BindTo(clock.Track);
         }
 
         private void updateRelativeChildSize()

osu.Game/Screens/Edit/Components/Timelines/Summary/Visualisations/PointVisualisation.cs

@@ -1,9 +1,9 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-using osuTK;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Shapes;
+using osuTK;
 
 namespace osu.Game.Screens.Edit.Components.Timelines.Summary.Visualisations
 {
@@ -12,16 +12,23 @@ namespace osu.Game.Screens.Edit.Components.Timelines.Summary.Visualisations
     /// </summary>
     public class PointVisualisation : Box
     {
+        public const float WIDTH = 1;
+
         public PointVisualisation(double startTime)
+            : this()
+        {
+            X = (float)startTime;
+        }
+
+        public PointVisualisation()
         {
             Origin = Anchor.TopCentre;
 
-            RelativeSizeAxes = Axes.Y;
-            Width = 1;
-            EdgeSmoothness = new Vector2(1, 0);
-
             RelativePositionAxes = Axes.X;
-            X = (float)startTime;
+            RelativeSizeAxes = Axes.Y;
+
+            Width = WIDTH;
+            EdgeSmoothness = new Vector2(WIDTH, 0);
         }
     }
 }

osu.Game/Screens/Edit/Compose/Components/BlueprintContainer.cs

@@ -2,6 +2,7 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
+using System.Collections.Generic;
 using System.Collections.Specialized;
 using System.Diagnostics;
 using System.Linq;
@@ -13,6 +14,7 @@ using osu.Framework.Graphics.Primitives;
 using osu.Framework.Input;
 using osu.Framework.Input.Bindings;
 using osu.Framework.Input.Events;
+using osu.Game.Graphics.UserInterface;
 using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Drawables;
@@ -23,15 +25,17 @@ namespace osu.Game.Screens.Edit.Compose.Components
 {
     /// <summary>
     /// A container which provides a "blueprint" display of hitobjects.
-    /// Includes selection and manipulation support via a <see cref="SelectionHandler"/>.
+    /// Includes selection and manipulation support via a <see cref="Components.SelectionHandler"/>.
     /// </summary>
     public abstract class BlueprintContainer : CompositeDrawable, IKeyBindingHandler<PlatformAction>
     {
         protected DragBox DragBox { get; private set; }
 
-        protected Container<SelectionBlueprint> SelectionBlueprints { get; private set; }
+        public Container<SelectionBlueprint> SelectionBlueprints { get; private set; }
 
-        private SelectionHandler selectionHandler;
+        protected SelectionHandler SelectionHandler { get; private set; }
+
+        protected readonly HitObjectComposer Composer;
 
         [Resolved(CanBeNull = true)]
         private IEditorChangeHandler changeHandler { get; set; }
@@ -40,38 +44,44 @@ namespace osu.Game.Screens.Edit.Compose.Components
         private EditorClock editorClock { get; set; }
 
         [Resolved]
-        private EditorBeatmap beatmap { get; set; }
+        protected EditorBeatmap Beatmap { get; private set; }
 
         private readonly BindableList<HitObject> selectedHitObjects = new BindableList<HitObject>();
-
-        public override bool ReceivePositionalInputAt(Vector2 screenSpacePos) => true;
+        private readonly Dictionary<HitObject, SelectionBlueprint> blueprintMap = new Dictionary<HitObject, SelectionBlueprint>();
 
         [Resolved(canBeNull: true)]
         private IPositionSnapProvider snapProvider { get; set; }
 
-        protected BlueprintContainer()
+        protected BlueprintContainer(HitObjectComposer composer)
         {
+            Composer = composer;
+
             RelativeSizeAxes = Axes.Both;
         }
 
         [BackgroundDependencyLoader]
         private void load()
         {
-            selectionHandler = CreateSelectionHandler();
-            selectionHandler.DeselectAll = deselectAll;
+            SelectionHandler = CreateSelectionHandler();
+            SelectionHandler.DeselectAll = deselectAll;
 
             AddRangeInternal(new[]
             {
-                DragBox = CreateDragBox(select),
-                selectionHandler,
+                DragBox = CreateDragBox(selectBlueprintsFromDragRectangle),
+                SelectionHandler,
                 SelectionBlueprints = CreateSelectionBlueprintContainer(),
+                SelectionHandler.CreateProxy(),
                 DragBox.CreateProxy().With(p => p.Depth = float.MinValue)
             });
 
-            foreach (var obj in beatmap.HitObjects)
-                AddBlueprintFor(obj);
+            // For non-pooled rulesets, hitobjects are already present in the playfield which allows the blueprints to be loaded in the async context.
+            if (Composer != null)
+            {
+                foreach (var obj in Composer.HitObjects)
+                    addBlueprintFor(obj.HitObject);
+            }
 
-            selectedHitObjects.BindTo(beatmap.SelectedHitObjects);
+            selectedHitObjects.BindTo(Beatmap.SelectedHitObjects);
             selectedHitObjects.CollectionChanged += (selectedObjects, args) =>
             {
                 switch (args.Action)
@@ -84,6 +94,7 @@ namespace osu.Game.Screens.Edit.Compose.Components
                     case NotifyCollectionChangedAction.Remove:
                         foreach (var o in args.OldItems)
                             SelectionBlueprints.FirstOrDefault(b => b.HitObject == o)?.Deselect();
+
                         break;
                 }
             };
@@ -93,15 +104,24 @@ namespace osu.Game.Screens.Edit.Compose.Components
         {
             base.LoadComplete();
 
-            beatmap.HitObjectAdded += AddBlueprintFor;
-            beatmap.HitObjectRemoved += removeBlueprintFor;
+            Beatmap.HitObjectAdded += addBlueprintFor;
+            Beatmap.HitObjectRemoved += removeBlueprintFor;
+
+            if (Composer != null)
+            {
+                // For pooled rulesets, blueprints must be added for hitobjects already "current" as they would've not been "current" during the async load addition process above.
+                foreach (var obj in Composer.HitObjects)
+                    addBlueprintFor(obj.HitObject);
+
+                Composer.Playfield.HitObjectUsageBegan += addBlueprintFor;
+                Composer.Playfield.HitObjectUsageFinished += removeBlueprintFor;
+            }
         }
 
-        protected virtual Container<SelectionBlueprint> CreateSelectionBlueprintContainer() =>
-            new Container<SelectionBlueprint> { RelativeSizeAxes = Axes.Both };
+        protected virtual Container<SelectionBlueprint> CreateSelectionBlueprintContainer() => new HitObjectOrderedSelectionContainer { RelativeSizeAxes = Axes.Both };
 
         /// <summary>
-        /// Creates a <see cref="SelectionHandler"/> which outlines <see cref="DrawableHitObject"/>s and handles movement of selections.
+        /// Creates a <see cref="Components.SelectionHandler"/> which outlines <see cref="DrawableHitObject"/>s and handles movement of selections.
         /// </summary>
         protected virtual SelectionHandler CreateSelectionHandler() => new SelectionHandler();
 
@@ -115,20 +135,26 @@ namespace osu.Game.Screens.Edit.Compose.Components
 
         protected override bool OnMouseDown(MouseDownEvent e)
         {
-            beginClickSelection(e);
+            if (!beginClickSelection(e)) return true;
+
             prepareSelectionMovement();
 
             return e.Button == MouseButton.Left;
         }
 
+        private SelectionBlueprint clickedBlueprint;
+
         protected override bool OnClick(ClickEvent e)
         {
             if (e.Button == MouseButton.Right)
                 return false;
 
+            // store for double-click handling
+            clickedBlueprint = SelectionHandler.SelectedBlueprints.FirstOrDefault(b => b.IsHovered);
+
             // Deselection should only occur if no selected blueprints are hovered
             // A special case for when a blueprint was selected via this click is added since OnClick() may occur outside the hitobject and should not trigger deselection
-            if (endClickSelection() || selectionHandler.SelectedBlueprints.Any(b => b.IsHovered))
+            if (endClickSelection() || clickedBlueprint != null)
                 return true;
 
             deselectAll();
@@ -140,9 +166,8 @@ namespace osu.Game.Screens.Edit.Compose.Components
             if (e.Button == MouseButton.Right)
                 return false;
 
-            SelectionBlueprint clickedBlueprint = selectionHandler.SelectedBlueprints.FirstOrDefault(b => b.IsHovered);
-
-            if (clickedBlueprint == null)
+            // ensure the blueprint which was hovered for the first click is still the hovered blueprint.
+            if (clickedBlueprint == null || SelectionHandler.SelectedBlueprints.FirstOrDefault(b => b.IsHovered) != clickedBlueprint)
                 return false;
 
             editorClock?.SeekTo(clickedBlueprint.HitObject.StartTime);
@@ -196,15 +221,16 @@ namespace osu.Game.Screens.Edit.Compose.Components
 
             if (isDraggingBlueprint)
             {
+                // handle positional change etc.
+                foreach (var obj in selectedHitObjects)
+                    Beatmap.Update(obj);
+
                 changeHandler?.EndChange();
                 isDraggingBlueprint = false;
             }
 
             if (DragBox.State == Visibility.Visible)
-            {
                 DragBox.Hide();
-                selectionHandler.UpdateVisibility();
-            }
         }
 
         protected override bool OnKeyDown(KeyDownEvent e)
@@ -212,7 +238,7 @@ namespace osu.Game.Screens.Edit.Compose.Components
             switch (e.Key)
             {
                 case Key.Escape:
-                    if (!selectionHandler.SelectedBlueprints.Any())
+                    if (!SelectionHandler.SelectedBlueprints.Any())
                         return false;
 
                     deselectAll();
@@ -240,30 +266,59 @@ namespace osu.Game.Screens.Edit.Compose.Components
 
         #region Blueprint Addition/Removal
 
-        private void removeBlueprintFor(HitObject hitObject)
+        private void addBlueprintFor(HitObject hitObject)
         {
-            var blueprint = SelectionBlueprints.SingleOrDefault(m => m.HitObject == hitObject);
-            if (blueprint == null)
+            if (blueprintMap.ContainsKey(hitObject))
                 return;
 
-            blueprint.Deselect();
-
-            blueprint.Selected -= onBlueprintSelected;
-            blueprint.Deselected -= onBlueprintDeselected;
-
-            SelectionBlueprints.Remove(blueprint);
-        }
-
-        protected virtual void AddBlueprintFor(HitObject hitObject)
-        {
             var blueprint = CreateBlueprintFor(hitObject);
             if (blueprint == null)
                 return;
 
+            blueprintMap[hitObject] = blueprint;
+
             blueprint.Selected += onBlueprintSelected;
             blueprint.Deselected += onBlueprintDeselected;
 
+            if (Beatmap.SelectedHitObjects.Contains(hitObject))
+                blueprint.Select();
+
             SelectionBlueprints.Add(blueprint);
+
+            OnBlueprintAdded(hitObject);
+        }
+
+        private void removeBlueprintFor(HitObject hitObject)
+        {
+            if (!blueprintMap.Remove(hitObject, out var blueprint))
+                return;
+
+            blueprint.Deselect();
+            blueprint.Selected -= onBlueprintSelected;
+            blueprint.Deselected -= onBlueprintDeselected;
+
+            SelectionBlueprints.Remove(blueprint);
+
+            if (movementBlueprint == blueprint)
+                finishSelectionMovement();
+
+            OnBlueprintRemoved(hitObject);
+        }
+
+        /// <summary>
+        /// Called after a <see cref="HitObject"/> blueprint has been added.
+        /// </summary>
+        /// <param name="hitObject">The <see cref="HitObject"/> for which the blueprint has been added.</param>
+        protected virtual void OnBlueprintAdded(HitObject hitObject)
+        {
+        }
+
+        /// <summary>
+        /// Called after a <see cref="HitObject"/> blueprint has been removed.
+        /// </summary>
+        /// <param name="hitObject">The <see cref="HitObject"/> for which the blueprint has been removed.</param>
+        protected virtual void OnBlueprintRemoved(HitObject hitObject)
+        {
         }
 
         #endregion
@@ -279,26 +334,18 @@ namespace osu.Game.Screens.Edit.Compose.Components
         /// Attempts to select any hovered blueprints.
         /// </summary>
         /// <param name="e">The input event that triggered this selection.</param>
-        private void beginClickSelection(MouseButtonEvent e)
+        /// <returns>Whether a selection was performed.</returns>
+        private bool beginClickSelection(MouseButtonEvent e)
         {
-            Debug.Assert(!clickSelectionBegan);
-
-            // Deselections are only allowed for control + left clicks
-            bool allowDeselection = e.ControlPressed && e.Button == MouseButton.Left;
-
-            // Todo: This is probably incorrectly disallowing multiple selections on stacked objects
-            if (!allowDeselection && selectionHandler.SelectedBlueprints.Any(s => s.IsHovered))
-                return;
-
-            foreach (SelectionBlueprint blueprint in SelectionBlueprints.AliveChildren)
+            // Iterate from the top of the input stack (blueprints closest to the front of the screen first).
+            foreach (SelectionBlueprint blueprint in SelectionBlueprints.AliveChildren.Reverse())
             {
-                if (blueprint.IsHovered)
-                {
-                    selectionHandler.HandleSelectionRequested(blueprint, e.CurrentState);
-                    clickSelectionBegan = true;
-                    break;
-                }
+                if (!blueprint.IsHovered) continue;
+
+                return clickSelectionBegan = SelectionHandler.HandleSelectionRequested(blueprint, e);
             }
+
+            return false;
         }
 
         /// <summary>
@@ -318,14 +365,26 @@ namespace osu.Game.Screens.Edit.Compose.Components
         /// Select all masks in a given rectangle selection area.
         /// </summary>
         /// <param name="rect">The rectangle to perform a selection on in screen-space coordinates.</param>
-        private void select(RectangleF rect)
+        private void selectBlueprintsFromDragRectangle(RectangleF rect)
         {
             foreach (var blueprint in SelectionBlueprints)
             {
-                if (blueprint.IsAlive && blueprint.IsPresent && rect.Contains(blueprint.ScreenSpaceSelectionPoint))
-                    blueprint.Select();
-                else
-                    blueprint.Deselect();
+                // only run when utmost necessary to avoid unnecessary rect computations.
+                bool isValidForSelection() => blueprint.IsAlive && blueprint.IsPresent && rect.Contains(blueprint.ScreenSpaceSelectionPoint);
+
+                switch (blueprint.State)
+                {
+                    case SelectionState.NotSelected:
+                        if (isValidForSelection())
+                            blueprint.Select();
+                        break;
+
+                    case SelectionState.Selected:
+                        // if the editor is playing, we generally don't want to deselect objects even if outside the selection area.
+                        if (!editorClock.IsRunning && !isValidForSelection())
+                            blueprint.Deselect();
+                        break;
+                }
             }
         }
 
@@ -334,27 +393,31 @@ namespace osu.Game.Screens.Edit.Compose.Components
         /// </summary>
         private void selectAll()
         {
-            SelectionBlueprints.ToList().ForEach(m => m.Select());
-            selectionHandler.UpdateVisibility();
+            Composer.Playfield.KeepAllAlive();
+
+            // Scheduled to allow the change in lifetime to take place.
+            Schedule(() => SelectionBlueprints.ToList().ForEach(m => m.Select()));
         }
 
         /// <summary>
         /// Deselects all selected <see cref="SelectionBlueprint"/>s.
         /// </summary>
-        private void deselectAll() => selectionHandler.SelectedBlueprints.ToList().ForEach(m => m.Deselect());
+        private void deselectAll() => SelectionHandler.SelectedBlueprints.ToList().ForEach(m => m.Deselect());
 
         private void onBlueprintSelected(SelectionBlueprint blueprint)
         {
-            selectionHandler.HandleSelected(blueprint);
+            SelectionHandler.HandleSelected(blueprint);
             SelectionBlueprints.ChangeChildDepth(blueprint, 1);
-            beatmap.SelectedHitObjects.Add(blueprint.HitObject);
+
+            Composer.Playfield.SetKeepAlive(blueprint.HitObject, true);
         }
 
         private void onBlueprintDeselected(SelectionBlueprint blueprint)
         {
-            selectionHandler.HandleDeselected(blueprint);
+            SelectionHandler.HandleDeselected(blueprint);
             SelectionBlueprints.ChangeChildDepth(blueprint, 0);
-            beatmap.SelectedHitObjects.Remove(blueprint.HitObject);
+
+            Composer.Playfield.SetKeepAlive(blueprint.HitObject, false);
         }
 
         #endregion
@@ -370,16 +433,16 @@ namespace osu.Game.Screens.Edit.Compose.Components
         /// </summary>
         private void prepareSelectionMovement()
         {
-            if (!selectionHandler.SelectedBlueprints.Any())
+            if (!SelectionHandler.SelectedBlueprints.Any())
                 return;
 
             // Any selected blueprint that is hovered can begin the movement of the group, however only the earliest hitobject is used for movement
             // A special case is added for when a click selection occurred before the drag
-            if (!clickSelectionBegan && !selectionHandler.SelectedBlueprints.Any(b => b.IsHovered))
+            if (!clickSelectionBegan && !SelectionHandler.SelectedBlueprints.Any(b => b.IsHovered))
                 return;
 
             // Movement is tracked from the blueprint of the earliest hitobject, since it only makes sense to distance snap from that hitobject
-            movementBlueprint = selectionHandler.SelectedBlueprints.OrderBy(b => b.HitObject.StartTime).First();
+            movementBlueprint = SelectionHandler.SelectedBlueprints.OrderBy(b => b.HitObject.StartTime).First();
             movementBlueprintOriginalPosition = movementBlueprint.ScreenSpaceSelectionPoint; // todo: unsure if correct
         }
 
@@ -393,6 +456,9 @@ namespace osu.Game.Screens.Edit.Compose.Components
             if (movementBlueprint == null)
                 return false;
 
+            if (snapProvider == null)
+                return true;
+
             Debug.Assert(movementBlueprintOriginalPosition != null);
 
             HitObject draggedObject = movementBlueprint.HitObject;
@@ -404,15 +470,19 @@ namespace osu.Game.Screens.Edit.Compose.Components
             var result = snapProvider.SnapScreenSpacePositionToValidTime(movePosition);
 
             // Move the hitobjects.
-            if (!selectionHandler.HandleMovement(new MoveSelectionEvent(movementBlueprint, result.ScreenSpacePosition)))
+            if (!SelectionHandler.HandleMovement(new MoveSelectionEvent(movementBlueprint, result.ScreenSpacePosition)))
                 return true;
 
             if (result.Time.HasValue)
             {
                 // Apply the start time at the newly snapped-to position
                 double offset = result.Time.Value - draggedObject.StartTime;
-                foreach (HitObject obj in selectionHandler.SelectedHitObjects)
+
+                foreach (HitObject obj in Beatmap.SelectedHitObjects)
+                {
                     obj.StartTime += offset;
+                    Beatmap.Update(obj);
+                }
             }
 
             return true;
@@ -439,10 +509,16 @@ namespace osu.Game.Screens.Edit.Compose.Components
         {
             base.Dispose(isDisposing);
 
-            if (beatmap != null)
+            if (Beatmap != null)
             {
-                beatmap.HitObjectAdded -= AddBlueprintFor;
-                beatmap.HitObjectRemoved -= removeBlueprintFor;
+                Beatmap.HitObjectAdded -= addBlueprintFor;
+                Beatmap.HitObjectRemoved -= removeBlueprintFor;
+            }
+
+            if (Composer != null)
+            {
+                Composer.Playfield.HitObjectUsageBegan -= addBlueprintFor;
+                Composer.Playfield.HitObjectUsageFinished -= removeBlueprintFor;
             }
         }
     }

osu.Game/Screens/Edit/Compose/Components/ComposeBlueprintContainer.cs

@@ -3,14 +3,22 @@
 
 using System.Collections.Generic;
 using System.Linq;
+using Humanizer;
 using osu.Framework.Allocation;
+using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Sprites;
 using osu.Framework.Input;
+using osu.Game.Audio;
+using osu.Game.Graphics.UserInterface;
 using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Edit.Tools;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Drawables;
+using osu.Game.Rulesets.Objects.Types;
+using osu.Game.Screens.Edit.Components.TernaryButtons;
+using osuTK;
 
 namespace osu.Game.Screens.Edit.Compose.Components
 {
@@ -19,21 +27,16 @@ namespace osu.Game.Screens.Edit.Compose.Components
     /// </summary>
     public class ComposeBlueprintContainer : BlueprintContainer
     {
-        [Resolved]
-        private HitObjectComposer composer { get; set; }
-
-        private PlacementBlueprint currentPlacement;
+        public override bool ReceivePositionalInputAt(Vector2 screenSpacePos) => true;
 
         private readonly Container<PlacementBlueprint> placementBlueprintContainer;
 
+        private PlacementBlueprint currentPlacement;
         private InputManager inputManager;
 
-        private readonly IEnumerable<DrawableHitObject> drawableHitObjects;
-
-        public ComposeBlueprintContainer(IEnumerable<DrawableHitObject> drawableHitObjects)
+        public ComposeBlueprintContainer(HitObjectComposer composer)
+            : base(composer)
         {
-            this.drawableHitObjects = drawableHitObjects;
-
             placementBlueprintContainer = new Container<PlacementBlueprint>
             {
                 RelativeSizeAxes = Axes.Both
@@ -43,6 +46,8 @@ namespace osu.Game.Screens.Edit.Compose.Components
         [BackgroundDependencyLoader]
         private void load()
         {
+            TernaryStates = CreateTernaryButtons().ToArray();
+
             AddInternal(placementBlueprintContainer);
         }
 
@@ -51,6 +56,90 @@ namespace osu.Game.Screens.Edit.Compose.Components
             base.LoadComplete();
 
             inputManager = GetContainingInputManager();
+
+            // updates to selected are handled for us by SelectionHandler.
+            NewCombo.BindTo(SelectionHandler.SelectionNewComboState);
+
+            // we are responsible for current placement blueprint updated based on state changes.
+            NewCombo.ValueChanged += _ => updatePlacementNewCombo();
+
+            // we own SelectionHandler so don't need to worry about making bindable copies (for simplicity)
+            foreach (var kvp in SelectionHandler.SelectionSampleStates)
+            {
+                kvp.Value.BindValueChanged(_ => updatePlacementSamples());
+            }
+        }
+
+        private void updatePlacementNewCombo()
+        {
+            if (currentPlacement?.HitObject is IHasComboInformation c)
+                c.NewCombo = NewCombo.Value == TernaryState.True;
+        }
+
+        private void updatePlacementSamples()
+        {
+            if (currentPlacement == null) return;
+
+            foreach (var kvp in SelectionHandler.SelectionSampleStates)
+                sampleChanged(kvp.Key, kvp.Value.Value);
+        }
+
+        private void sampleChanged(string sampleName, TernaryState state)
+        {
+            if (currentPlacement == null) return;
+
+            var samples = currentPlacement.HitObject.Samples;
+
+            var existingSample = samples.FirstOrDefault(s => s.Name == sampleName);
+
+            switch (state)
+            {
+                case TernaryState.False:
+                    if (existingSample != null)
+                        samples.Remove(existingSample);
+                    break;
+
+                case TernaryState.True:
+                    if (existingSample == null)
+                        samples.Add(new HitSampleInfo { Name = sampleName });
+                    break;
+            }
+        }
+
+        public readonly Bindable<TernaryState> NewCombo = new Bindable<TernaryState> { Description = "New Combo" };
+
+        /// <summary>
+        /// A collection of states which will be displayed to the user in the toolbox.
+        /// </summary>
+        public TernaryButton[] TernaryStates { get; private set; }
+
+        /// <summary>
+        /// Create all ternary states required to be displayed to the user.
+        /// </summary>
+        protected virtual IEnumerable<TernaryButton> CreateTernaryButtons()
+        {
+            //TODO: this should only be enabled (visible?) for rulesets that provide combo-supporting HitObjects.
+            yield return new TernaryButton(NewCombo, "New combo", () => new SpriteIcon { Icon = FontAwesome.Regular.DotCircle });
+
+            foreach (var kvp in SelectionHandler.SelectionSampleStates)
+                yield return new TernaryButton(kvp.Value, kvp.Key.Replace("hit", string.Empty).Titleize(), () => getIconForSample(kvp.Key));
+        }
+
+        private Drawable getIconForSample(string sampleName)
+        {
+            switch (sampleName)
+            {
+                case HitSampleInfo.HIT_CLAP:
+                    return new SpriteIcon { Icon = FontAwesome.Solid.Hands };
+
+                case HitSampleInfo.HIT_WHISTLE:
+                    return new SpriteIcon { Icon = FontAwesome.Solid.Bullhorn };
+
+                case HitSampleInfo.HIT_FINISH:
+                    return new SpriteIcon { Icon = FontAwesome.Solid.DrumSteelpan };
+            }
+
+            return null;
         }
 
         #region Placement
@@ -66,7 +155,7 @@ namespace osu.Game.Screens.Edit.Compose.Components
 
         private void updatePlacementPosition()
         {
-            var snapResult = composer.SnapScreenSpacePositionToValidTime(inputManager.CurrentState.Mouse.Position);
+            var snapResult = Composer.SnapScreenSpacePositionToValidTime(inputManager.CurrentState.Mouse.Position);
 
             currentPlacement.UpdatePosition(snapResult);
         }
@@ -77,18 +166,20 @@ namespace osu.Game.Screens.Edit.Compose.Components
         {
             base.Update();
 
-            if (composer.CursorInPlacementArea)
+            if (Composer.CursorInPlacementArea)
                 createPlacement();
             else if (currentPlacement?.PlacementActive == false)
                 removePlacement();
 
             if (currentPlacement != null)
+            {
                 updatePlacementPosition();
+            }
         }
 
         protected sealed override SelectionBlueprint CreateBlueprintFor(HitObject hitObject)
         {
-            var drawable = drawableHitObjects.FirstOrDefault(d => d.HitObject == hitObject);
+            var drawable = Composer.HitObjects.FirstOrDefault(d => d.HitObject == hitObject);
 
             if (drawable == null)
                 return null;
@@ -98,10 +189,15 @@ namespace osu.Game.Screens.Edit.Compose.Components
 
         public virtual OverlaySelectionBlueprint CreateBlueprintFor(DrawableHitObject hitObject) => null;
 
-        protected override void AddBlueprintFor(HitObject hitObject)
+        protected override void OnBlueprintAdded(HitObject hitObject)
         {
+            base.OnBlueprintAdded(hitObject);
+
             refreshTool();
-            base.AddBlueprintFor(hitObject);
+
+            // on successful placement, the new combo button should be reset as this is the most common user interaction.
+            if (Beatmap.SelectedHitObjects.Count == 0)
+                NewCombo.Value = TernaryState.False;
         }
 
         private void createPlacement()
@@ -112,10 +208,17 @@ namespace osu.Game.Screens.Edit.Compose.Components
 
             if (blueprint != null)
             {
+                // doing this post-creations as adding the default hit sample should be the case regardless of the ruleset.
+                blueprint.HitObject.Samples.Add(new HitSampleInfo { Name = HitSampleInfo.HIT_NORMAL });
+
                 placementBlueprintContainer.Child = currentPlacement = blueprint;
 
                 // Fixes a 1-frame position discrepancy due to the first mouse move event happening in the next frame
                 updatePlacementPosition();
+
+                updatePlacementSamples();
+
+                updatePlacementNewCombo();
             }
         }
 

osu.Game/Screens/Edit/Compose/Components/DragBox.cs

@@ -45,7 +45,7 @@ namespace osu.Game.Screens.Edit.Compose.Components
         {
             Masking = true,
             BorderColour = Color4.White,
-            BorderThickness = SelectionHandler.BORDER_RADIUS,
+            BorderThickness = SelectionBox.BORDER_RADIUS,
             Child = new Box
             {
                 RelativeSizeAxes = Axes.Both,
@@ -53,6 +53,8 @@ namespace osu.Game.Screens.Edit.Compose.Components
             }
         };
 
+        private RectangleF? dragRectangle;
+
         /// <summary>
         /// Handle a forwarded mouse event.
         /// </summary>
@@ -66,15 +68,14 @@ namespace osu.Game.Screens.Edit.Compose.Components
             var dragQuad = new Quad(dragStartPosition.X, dragStartPosition.Y, dragPosition.X - dragStartPosition.X, dragPosition.Y - dragStartPosition.Y);
 
             // We use AABBFloat instead of RectangleF since it handles negative sizes for us
-            var dragRectangle = dragQuad.AABBFloat;
+            var rec = dragQuad.AABBFloat;
+            dragRectangle = rec;
 
-            var topLeft = ToLocalSpace(dragRectangle.TopLeft);
-            var bottomRight = ToLocalSpace(dragRectangle.BottomRight);
+            var topLeft = ToLocalSpace(rec.TopLeft);
+            var bottomRight = ToLocalSpace(rec.BottomRight);
 
             Box.Position = topLeft;
             Box.Size = bottomRight - topLeft;
-
-            PerformSelection?.Invoke(dragRectangle);
             return true;
         }
 
@@ -93,7 +94,19 @@ namespace osu.Game.Screens.Edit.Compose.Components
             }
         }
 
-        public override void Hide() => State = Visibility.Hidden;
+        protected override void Update()
+        {
+            base.Update();
+
+            if (dragRectangle != null)
+                PerformSelection?.Invoke(dragRectangle.Value);
+        }
+
+        public override void Hide()
+        {
+            State = Visibility.Hidden;
+            dragRectangle = null;
+        }
 
         public override void Show() => State = Visibility.Visible;
 

osu.Game/Screens/Edit/Compose/Components/EditorPlayfieldBorder.cs

@@ -1,32 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-using osu.Framework.Graphics;
-using osu.Framework.Graphics.Containers;
-using osu.Framework.Graphics.Shapes;
-using osuTK.Graphics;
-
-namespace osu.Game.Screens.Edit.Compose.Components
-{
-    /// <summary>
-    /// Provides a border around the playfield.
-    /// </summary>
-    public class EditorPlayfieldBorder : CompositeDrawable
-    {
-        public EditorPlayfieldBorder()
-        {
-            RelativeSizeAxes = Axes.Both;
-
-            Masking = true;
-            BorderColour = Color4.White;
-            BorderThickness = 2;
-
-            InternalChild = new Box
-            {
-                RelativeSizeAxes = Axes.Both,
-                Alpha = 0,
-                AlwaysPresent = true
-            };
-        }
-    }
-}

osu.Game/Screens/Edit/Compose/Components/HitObjectOrderedSelectionContainer.cs

@@ -0,0 +1,77 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Collections.Generic;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Objects;
+
+namespace osu.Game.Screens.Edit.Compose.Components
+{
+    /// <summary>
+    /// A container for <see cref="SelectionBlueprint"/> ordered by their <see cref="HitObject"/> start times.
+    /// </summary>
+    public sealed class HitObjectOrderedSelectionContainer : Container<SelectionBlueprint>
+    {
+        public override void Add(SelectionBlueprint drawable)
+        {
+            base.Add(drawable);
+            bindStartTime(drawable);
+        }
+
+        public override bool Remove(SelectionBlueprint drawable)
+        {
+            if (!base.Remove(drawable))
+                return false;
+
+            unbindStartTime(drawable);
+            return true;
+        }
+
+        public override void Clear(bool disposeChildren)
+        {
+            base.Clear(disposeChildren);
+            unbindAllStartTimes();
+        }
+
+        private readonly Dictionary<SelectionBlueprint, IBindable> startTimeMap = new Dictionary<SelectionBlueprint, IBindable>();
+
+        private void bindStartTime(SelectionBlueprint blueprint)
+        {
+            var bindable = blueprint.HitObject.StartTimeBindable.GetBoundCopy();
+
+            bindable.BindValueChanged(_ =>
+            {
+                if (LoadState >= LoadState.Ready)
+                    SortInternal();
+            });
+
+            startTimeMap[blueprint] = bindable;
+        }
+
+        private void unbindStartTime(SelectionBlueprint blueprint)
+        {
+            startTimeMap[blueprint].UnbindAll();
+            startTimeMap.Remove(blueprint);
+        }
+
+        private void unbindAllStartTimes()
+        {
+            foreach (var kvp in startTimeMap)
+                kvp.Value.UnbindAll();
+            startTimeMap.Clear();
+        }
+
+        protected override int Compare(Drawable x, Drawable y)
+        {
+            var xObj = (SelectionBlueprint)x;
+            var yObj = (SelectionBlueprint)y;
+
+            // Put earlier blueprints towards the end of the list, so they handle input first
+            int i = yObj.HitObject.StartTime.CompareTo(xObj.HitObject.StartTime);
+            return i == 0 ? CompareReverseChildID(x, y) : i;
+        }
+    }
+}

osu.Game/Screens/Edit/Compose/Components/SelectionBox.cs

@@ -0,0 +1,257 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Graphics.Sprites;
+using osu.Framework.Input.Events;
+using osu.Game.Graphics;
+using osuTK;
+using osuTK.Input;
+
+namespace osu.Game.Screens.Edit.Compose.Components
+{
+    public class SelectionBox : CompositeDrawable
+    {
+        public Func<float, bool> OnRotation;
+        public Func<Vector2, Anchor, bool> OnScale;
+        public Func<Direction, bool> OnFlip;
+        public Func<bool> OnReverse;
+
+        public Action OperationStarted;
+        public Action OperationEnded;
+
+        private bool canReverse;
+
+        /// <summary>
+        /// Whether pattern reversing support should be enabled.
+        /// </summary>
+        public bool CanReverse
+        {
+            get => canReverse;
+            set
+            {
+                if (canReverse == value) return;
+
+                canReverse = value;
+                recreate();
+            }
+        }
+
+        private bool canRotate;
+
+        /// <summary>
+        /// Whether rotation support should be enabled.
+        /// </summary>
+        public bool CanRotate
+        {
+            get => canRotate;
+            set
+            {
+                if (canRotate == value) return;
+
+                canRotate = value;
+                recreate();
+            }
+        }
+
+        private bool canScaleX;
+
+        /// <summary>
+        /// Whether vertical scale support should be enabled.
+        /// </summary>
+        public bool CanScaleX
+        {
+            get => canScaleX;
+            set
+            {
+                if (canScaleX == value) return;
+
+                canScaleX = value;
+                recreate();
+            }
+        }
+
+        private bool canScaleY;
+
+        /// <summary>
+        /// Whether horizontal scale support should be enabled.
+        /// </summary>
+        public bool CanScaleY
+        {
+            get => canScaleY;
+            set
+            {
+                if (canScaleY == value) return;
+
+                canScaleY = value;
+                recreate();
+            }
+        }
+
+        private FillFlowContainer buttons;
+
+        public const float BORDER_RADIUS = 3;
+
+        [Resolved]
+        private OsuColour colours { get; set; }
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            RelativeSizeAxes = Axes.Both;
+
+            recreate();
+        }
+
+        protected override bool OnKeyDown(KeyDownEvent e)
+        {
+            if (e.Repeat || !e.ControlPressed)
+                return false;
+
+            switch (e.Key)
+            {
+                case Key.G:
+                    return CanReverse && OnReverse?.Invoke() == true;
+
+                case Key.H:
+                    return CanScaleX && OnFlip?.Invoke(Direction.Horizontal) == true;
+
+                case Key.J:
+                    return CanScaleY && OnFlip?.Invoke(Direction.Vertical) == true;
+            }
+
+            return base.OnKeyDown(e);
+        }
+
+        private void recreate()
+        {
+            if (LoadState < LoadState.Loading)
+                return;
+
+            InternalChildren = new Drawable[]
+            {
+                new Container
+                {
+                    Masking = true,
+                    BorderThickness = BORDER_RADIUS,
+                    BorderColour = colours.YellowDark,
+                    RelativeSizeAxes = Axes.Both,
+                    Children = new Drawable[]
+                    {
+                        new Box
+                        {
+                            RelativeSizeAxes = Axes.Both,
+
+                            AlwaysPresent = true,
+                            Alpha = 0
+                        },
+                    }
+                },
+                buttons = new FillFlowContainer
+                {
+                    Y = 20,
+                    AutoSizeAxes = Axes.Both,
+                    Direction = FillDirection.Horizontal,
+                    Anchor = Anchor.BottomCentre,
+                    Origin = Anchor.Centre
+                }
+            };
+
+            if (CanScaleX) addXScaleComponents();
+            if (CanScaleX && CanScaleY) addFullScaleComponents();
+            if (CanScaleY) addYScaleComponents();
+            if (CanRotate) addRotationComponents();
+            if (CanReverse) addButton(FontAwesome.Solid.Backward, "Reverse pattern (Ctrl-G)", () => OnReverse?.Invoke());
+        }
+
+        private void addRotationComponents()
+        {
+            const float separation = 40;
+
+            addButton(FontAwesome.Solid.Undo, "Rotate 90 degrees counter-clockwise", () => OnRotation?.Invoke(-90));
+            addButton(FontAwesome.Solid.Redo, "Rotate 90 degrees clockwise", () => OnRotation?.Invoke(90));
+
+            AddRangeInternal(new Drawable[]
+            {
+                new Box
+                {
+                    Depth = float.MaxValue,
+                    Colour = colours.YellowLight,
+                    Blending = BlendingParameters.Additive,
+                    Alpha = 0.3f,
+                    Size = new Vector2(BORDER_RADIUS, separation),
+                    Anchor = Anchor.TopCentre,
+                    Origin = Anchor.BottomCentre,
+                },
+                new SelectionBoxDragHandleButton(FontAwesome.Solid.Redo, "Free rotate")
+                {
+                    Anchor = Anchor.TopCentre,
+                    Y = -separation,
+                    HandleDrag = e => OnRotation?.Invoke(e.Delta.X),
+                    OperationStarted = operationStarted,
+                    OperationEnded = operationEnded
+                }
+            });
+        }
+
+        private void addYScaleComponents()
+        {
+            addButton(FontAwesome.Solid.ArrowsAltV, "Flip vertically (Ctrl-J)", () => OnFlip?.Invoke(Direction.Vertical));
+
+            addDragHandle(Anchor.TopCentre);
+            addDragHandle(Anchor.BottomCentre);
+        }
+
+        private void addFullScaleComponents()
+        {
+            addDragHandle(Anchor.TopLeft);
+            addDragHandle(Anchor.TopRight);
+            addDragHandle(Anchor.BottomLeft);
+            addDragHandle(Anchor.BottomRight);
+        }
+
+        private void addXScaleComponents()
+        {
+            addButton(FontAwesome.Solid.ArrowsAltH, "Flip horizontally (Ctrl-H)", () => OnFlip?.Invoke(Direction.Horizontal));
+
+            addDragHandle(Anchor.CentreLeft);
+            addDragHandle(Anchor.CentreRight);
+        }
+
+        private void addButton(IconUsage icon, string tooltip, Action action)
+        {
+            buttons.Add(new SelectionBoxDragHandleButton(icon, tooltip)
+            {
+                OperationStarted = operationStarted,
+                OperationEnded = operationEnded,
+                Action = action
+            });
+        }
+
+        private void addDragHandle(Anchor anchor) => AddInternal(new SelectionBoxDragHandle
+        {
+            Anchor = anchor,
+            HandleDrag = e => OnScale?.Invoke(e.Delta, anchor),
+            OperationStarted = operationStarted,
+            OperationEnded = operationEnded
+        });
+
+        private int activeOperations;
+
+        private void operationEnded()
+        {
+            if (--activeOperations == 0)
+                OperationEnded?.Invoke();
+        }
+
+        private void operationStarted()
+        {
+            if (activeOperations++ == 0)
+                OperationStarted?.Invoke();
+        }
+    }
+}

osu.Game/Screens/Edit/Compose/Components/SelectionBoxDragHandle.cs

@@ -0,0 +1,105 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Input.Events;
+using osu.Game.Graphics;
+using osuTK;
+
+namespace osu.Game.Screens.Edit.Compose.Components
+{
+    public class SelectionBoxDragHandle : Container
+    {
+        public Action OperationStarted;
+        public Action OperationEnded;
+
+        public Action<DragEvent> HandleDrag { get; set; }
+
+        private Circle circle;
+
+        [Resolved]
+        private OsuColour colours { get; set; }
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            Size = new Vector2(10);
+            Origin = Anchor.Centre;
+
+            InternalChildren = new Drawable[]
+            {
+                circle = new Circle
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                },
+            };
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+            UpdateHoverState();
+        }
+
+        protected override bool OnHover(HoverEvent e)
+        {
+            UpdateHoverState();
+            return base.OnHover(e);
+        }
+
+        protected override void OnHoverLost(HoverLostEvent e)
+        {
+            base.OnHoverLost(e);
+            UpdateHoverState();
+        }
+
+        protected bool HandlingMouse;
+
+        protected override bool OnMouseDown(MouseDownEvent e)
+        {
+            HandlingMouse = true;
+            UpdateHoverState();
+            return true;
+        }
+
+        protected override bool OnDragStart(DragStartEvent e)
+        {
+            OperationStarted?.Invoke();
+            return true;
+        }
+
+        protected override void OnDrag(DragEvent e)
+        {
+            HandleDrag?.Invoke(e);
+            base.OnDrag(e);
+        }
+
+        protected override void OnDragEnd(DragEndEvent e)
+        {
+            HandlingMouse = false;
+            OperationEnded?.Invoke();
+
+            UpdateHoverState();
+            base.OnDragEnd(e);
+        }
+
+        protected override void OnMouseUp(MouseUpEvent e)
+        {
+            HandlingMouse = false;
+            UpdateHoverState();
+            base.OnMouseUp(e);
+        }
+
+        protected virtual void UpdateHoverState()
+        {
+            circle.Colour = HandlingMouse ? colours.GrayF : (IsHovered ? colours.Red : colours.YellowDark);
+            this.ScaleTo(HandlingMouse || IsHovered ? 1.5f : 1, 100, Easing.OutQuint);
+        }
+    }
+}

osu.Game/Screens/Edit/Compose/Components/SelectionBoxDragHandleButton.cs

@@ -0,0 +1,66 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Cursor;
+using osu.Framework.Graphics.Sprites;
+using osu.Framework.Input.Events;
+using osuTK;
+using osuTK.Graphics;
+
+namespace osu.Game.Screens.Edit.Compose.Components
+{
+    /// <summary>
+    /// A drag "handle" which shares the visual appearance but behaves more like a clickable button.
+    /// </summary>
+    public sealed class SelectionBoxDragHandleButton : SelectionBoxDragHandle, IHasTooltip
+    {
+        private SpriteIcon icon;
+
+        private readonly IconUsage iconUsage;
+
+        public Action Action;
+
+        public SelectionBoxDragHandleButton(IconUsage iconUsage, string tooltip)
+        {
+            this.iconUsage = iconUsage;
+
+            TooltipText = tooltip;
+
+            Anchor = Anchor.Centre;
+            Origin = Anchor.Centre;
+        }
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            Size *= 2;
+            AddInternal(icon = new SpriteIcon
+            {
+                RelativeSizeAxes = Axes.Both,
+                Size = new Vector2(0.5f),
+                Icon = iconUsage,
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+            });
+        }
+
+        protected override bool OnClick(ClickEvent e)
+        {
+            OperationStarted?.Invoke();
+            Action?.Invoke();
+            OperationEnded?.Invoke();
+            return true;
+        }
+
+        protected override void UpdateHoverState()
+        {
+            base.UpdateHoverState();
+            icon.Colour = !HandlingMouse && IsHovered ? Color4.White : Color4.Black;
+        }
+
+        public string TooltipText { get; }
+    }
+}

osu.Game/Screens/Edit/Compose/Components/SelectionHandler.cs

@@ -4,7 +4,9 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using Humanizer;
 using osu.Framework.Allocation;
+using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Cursor;
@@ -12,14 +14,17 @@ using osu.Framework.Graphics.Shapes;
 using osu.Framework.Graphics.UserInterface;
 using osu.Framework.Input;
 using osu.Framework.Input.Bindings;
-using osu.Framework.Input.States;
+using osu.Framework.Input.Events;
 using osu.Game.Audio;
 using osu.Game.Graphics;
+using osu.Game.Graphics.Sprites;
 using osu.Game.Graphics.UserInterface;
 using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Drawables;
+using osu.Game.Rulesets.Objects.Types;
 using osuTK;
+using osuTK.Input;
 
 namespace osu.Game.Screens.Edit.Compose.Components
 {
@@ -28,20 +33,22 @@ namespace osu.Game.Screens.Edit.Compose.Components
     /// </summary>
     public class SelectionHandler : CompositeDrawable, IKeyBindingHandler<PlatformAction>, IHasContextMenu
     {
-        public const float BORDER_RADIUS = 2;
-
         public IEnumerable<SelectionBlueprint> SelectedBlueprints => selectedBlueprints;
         private readonly List<SelectionBlueprint> selectedBlueprints;
 
-        public IEnumerable<HitObject> SelectedHitObjects => selectedBlueprints.Select(b => b.HitObject);
+        public int SelectedCount => selectedBlueprints.Count;
 
-        private Drawable outline;
+        private Drawable content;
 
-        [Resolved(CanBeNull = true)]
+        private OsuSpriteText selectionDetailsText;
+
+        protected SelectionBox SelectionBox { get; private set; }
+
+        [Resolved]
         protected EditorBeatmap EditorBeatmap { get; private set; }
 
         [Resolved(CanBeNull = true)]
-        private IEditorChangeHandler changeHandler { get; set; }
+        protected IEditorChangeHandler ChangeHandler { get; private set; }
 
         public SelectionHandler()
         {
@@ -55,20 +62,65 @@ namespace osu.Game.Screens.Edit.Compose.Components
         [BackgroundDependencyLoader]
         private void load(OsuColour colours)
         {
-            InternalChild = outline = new Container
+            createStateBindables();
+
+            InternalChild = content = new Container
             {
-                Masking = true,
-                BorderThickness = BORDER_RADIUS,
-                BorderColour = colours.Yellow,
-                Child = new Box
+                Children = new Drawable[]
                 {
-                    RelativeSizeAxes = Axes.Both,
-                    AlwaysPresent = true,
-                    Alpha = 0
+                    // todo: should maybe be inside the SelectionBox?
+                    new Container
+                    {
+                        Name = "info text",
+                        AutoSizeAxes = Axes.Both,
+                        Children = new Drawable[]
+                        {
+                            new Box
+                            {
+                                Colour = colours.YellowDark,
+                                RelativeSizeAxes = Axes.Both,
+                            },
+                            selectionDetailsText = new OsuSpriteText
+                            {
+                                Padding = new MarginPadding(2),
+                                Colour = colours.Gray0,
+                                Font = OsuFont.Default.With(size: 11)
+                            }
+                        }
+                    },
+                    SelectionBox = CreateSelectionBox(),
                 }
             };
         }
 
+        public SelectionBox CreateSelectionBox()
+            => new SelectionBox
+            {
+                OperationStarted = OnOperationBegan,
+                OperationEnded = OnOperationEnded,
+
+                OnRotation = HandleRotation,
+                OnScale = HandleScale,
+                OnFlip = HandleFlip,
+                OnReverse = HandleReverse,
+            };
+
+        /// <summary>
+        /// Fired when a drag operation ends from the selection box.
+        /// </summary>
+        protected virtual void OnOperationBegan()
+        {
+            ChangeHandler?.BeginChange();
+        }
+
+        /// <summary>
+        /// Fired when a drag operation begins from the selection box.
+        /// </summary>
+        protected virtual void OnOperationEnded()
+        {
+            ChangeHandler?.EndChange();
+        }
+
         #region User Input Handling
 
         /// <summary>
@@ -83,7 +135,35 @@ namespace osu.Game.Screens.Edit.Compose.Components
         /// Whether any <see cref="DrawableHitObject"/>s could be moved.
         /// Returning true will also propagate StartTime changes provided by the closest <see cref="IPositionSnapProvider.SnapScreenSpacePositionToValidTime"/>.
         /// </returns>
-        public virtual bool HandleMovement(MoveSelectionEvent moveEvent) => true;
+        public virtual bool HandleMovement(MoveSelectionEvent moveEvent) => false;
+
+        /// <summary>
+        /// Handles the selected <see cref="DrawableHitObject"/>s being rotated.
+        /// </summary>
+        /// <param name="angle">The delta angle to apply to the selection.</param>
+        /// <returns>Whether any <see cref="DrawableHitObject"/>s could be rotated.</returns>
+        public virtual bool HandleRotation(float angle) => false;
+
+        /// <summary>
+        /// Handles the selected <see cref="DrawableHitObject"/>s being scaled.
+        /// </summary>
+        /// <param name="scale">The delta scale to apply, in playfield local coordinates.</param>
+        /// <param name="anchor">The point of reference where the scale is originating from.</param>
+        /// <returns>Whether any <see cref="DrawableHitObject"/>s could be scaled.</returns>
+        public virtual bool HandleScale(Vector2 scale, Anchor anchor) => false;
+
+        /// <summary>
+        /// Handles the selected <see cref="DrawableHitObject"/>s being flipped.
+        /// </summary>
+        /// <param name="direction">The direction to flip</param>
+        /// <returns>Whether any <see cref="DrawableHitObject"/>s could be flipped.</returns>
+        public virtual bool HandleFlip(Direction direction) => false;
+
+        /// <summary>
+        /// Handles the selected <see cref="DrawableHitObject"/>s being reversed pattern-wise.
+        /// </summary>
+        /// <returns>Whether any <see cref="DrawableHitObject"/>s could be reversed.</returns>
+        public virtual bool HandleReverse() => false;
 
         public bool OnPressed(PlatformAction action)
         {
@@ -117,9 +197,10 @@ namespace osu.Game.Screens.Edit.Compose.Components
         internal void HandleSelected(SelectionBlueprint blueprint)
         {
             selectedBlueprints.Add(blueprint);
-            EditorBeatmap.SelectedHitObjects.Add(blueprint.HitObject);
 
-            UpdateVisibility();
+            // there are potentially multiple SelectionHandlers active, but we only want to add hitobjects to the selected list once.
+            if (!EditorBeatmap.SelectedHitObjects.Contains(blueprint.HitObject))
+                EditorBeatmap.SelectedHitObjects.Add(blueprint.HitObject);
         }
 
         /// <summary>
@@ -129,45 +210,55 @@ namespace osu.Game.Screens.Edit.Compose.Components
         internal void HandleDeselected(SelectionBlueprint blueprint)
         {
             selectedBlueprints.Remove(blueprint);
-            EditorBeatmap.SelectedHitObjects.Remove(blueprint.HitObject);
 
-            // We don't want to update visibility if > 0, since we may be deselecting blueprints during drag-selection
-            if (selectedBlueprints.Count == 0)
-                UpdateVisibility();
+            EditorBeatmap.SelectedHitObjects.Remove(blueprint.HitObject);
         }
 
         /// <summary>
         /// Handle a blueprint requesting selection.
         /// </summary>
         /// <param name="blueprint">The blueprint.</param>
-        /// <param name="state">The input state at the point of selection.</param>
-        internal void HandleSelectionRequested(SelectionBlueprint blueprint, InputState state)
+        /// <param name="e">The mouse event responsible for selection.</param>
+        /// <returns>Whether a selection was performed.</returns>
+        internal bool HandleSelectionRequested(SelectionBlueprint blueprint, MouseButtonEvent e)
         {
-            if (state.Keyboard.ControlPressed)
+            if (e.ShiftPressed && e.Button == MouseButton.Right)
             {
-                if (blueprint.IsSelected)
-                    blueprint.Deselect();
-                else
-                    blueprint.Select();
+                handleQuickDeletion(blueprint);
+                return false;
             }
-            else
-            {
-                if (blueprint.IsSelected)
-                    return;
 
-                DeselectAll?.Invoke();
-                blueprint.Select();
-            }
+            if (e.ControlPressed && e.Button == MouseButton.Left)
+                blueprint.ToggleSelection();
+            else
+                ensureSelected(blueprint);
+
+            return true;
+        }
+
+        private void handleQuickDeletion(SelectionBlueprint blueprint)
+        {
+            if (blueprint.HandleQuickDeletion())
+                return;
+
+            if (!blueprint.IsSelected)
+                EditorBeatmap.Remove(blueprint.HitObject);
+            else
+                deleteSelected();
+        }
+
+        private void ensureSelected(SelectionBlueprint blueprint)
+        {
+            if (blueprint.IsSelected)
+                return;
+
+            DeselectAll?.Invoke();
+            blueprint.Select();
         }
 
         private void deleteSelected()
         {
-            changeHandler?.BeginChange();
-
-            foreach (var h in selectedBlueprints.ToList())
-                EditorBeatmap?.Remove(h.HitObject);
-
-            changeHandler?.EndChange();
+            EditorBeatmap.RemoveRange(selectedBlueprints.Select(b => b.HitObject));
         }
 
         #endregion
@@ -177,12 +268,22 @@ namespace osu.Game.Screens.Edit.Compose.Components
         /// <summary>
         /// Updates whether this <see cref="SelectionHandler"/> is visible.
         /// </summary>
-        internal void UpdateVisibility()
+        private void updateVisibility()
+        {
+            int count = selectedBlueprints.Count;
+
+            selectionDetailsText.Text = count > 0 ? count.ToString() : string.Empty;
+
+            this.FadeTo(count > 0 ? 1 : 0);
+            OnSelectionChanged();
+        }
+
+        /// <summary>
+        /// Triggered whenever the set of selected objects changes.
+        /// Should update the selection box's state to match supported operations.
+        /// </summary>
+        protected virtual void OnSelectionChanged()
         {
-            if (selectedBlueprints.Count > 0)
-                Show();
-            else
-                Hide();
         }
 
         protected override void Update()
@@ -205,8 +306,8 @@ namespace osu.Game.Screens.Edit.Compose.Components
             topLeft -= new Vector2(5);
             bottomRight += new Vector2(5);
 
-            outline.Size = bottomRight - topLeft;
-            outline.Position = topLeft;
+            content.Size = bottomRight - topLeft;
+            content.Position = topLeft;
         }
 
         #endregion
@@ -219,9 +320,9 @@ namespace osu.Game.Screens.Edit.Compose.Components
         /// <param name="sampleName">The name of the hit sample.</param>
         public void AddHitSample(string sampleName)
         {
-            changeHandler?.BeginChange();
+            EditorBeatmap.BeginChange();
 
-            foreach (var h in SelectedHitObjects)
+            foreach (var h in EditorBeatmap.SelectedHitObjects)
             {
                 // Make sure there isn't already an existing sample
                 if (h.Samples.Any(s => s.Name == sampleName))
@@ -230,7 +331,29 @@ namespace osu.Game.Screens.Edit.Compose.Components
                 h.Samples.Add(new HitSampleInfo { Name = sampleName });
             }
 
-            changeHandler?.EndChange();
+            EditorBeatmap.EndChange();
+        }
+
+        /// <summary>
+        /// Set the new combo state of all selected <see cref="HitObject"/>s.
+        /// </summary>
+        /// <param name="state">Whether to set or unset.</param>
+        /// <exception cref="InvalidOperationException">Throws if any selected object doesn't implement <see cref="IHasComboInformation"/></exception>
+        public void SetNewCombo(bool state)
+        {
+            EditorBeatmap.BeginChange();
+
+            foreach (var h in EditorBeatmap.SelectedHitObjects)
+            {
+                var comboInfo = h as IHasComboInformation;
+
+                if (comboInfo == null || comboInfo.NewCombo == state) continue;
+
+                comboInfo.NewCombo = state;
+                EditorBeatmap.Update(h);
+            }
+
+            EditorBeatmap.EndChange();
         }
 
         /// <summary>
@@ -239,12 +362,103 @@ namespace osu.Game.Screens.Edit.Compose.Components
         /// <param name="sampleName">The name of the hit sample.</param>
         public void RemoveHitSample(string sampleName)
         {
-            changeHandler?.BeginChange();
+            EditorBeatmap.BeginChange();
 
-            foreach (var h in SelectedHitObjects)
+            foreach (var h in EditorBeatmap.SelectedHitObjects)
                 h.SamplesBindable.RemoveAll(s => s.Name == sampleName);
 
-            changeHandler?.EndChange();
+            EditorBeatmap.EndChange();
+        }
+
+        #endregion
+
+        #region Selection State
+
+        /// <summary>
+        /// The state of "new combo" for all selected hitobjects.
+        /// </summary>
+        public readonly Bindable<TernaryState> SelectionNewComboState = new Bindable<TernaryState>();
+
+        /// <summary>
+        /// The state of each sample type for all selected hitobjects. Keys match with <see cref="HitSampleInfo"/> constant specifications.
+        /// </summary>
+        public readonly Dictionary<string, Bindable<TernaryState>> SelectionSampleStates = new Dictionary<string, Bindable<TernaryState>>();
+
+        /// <summary>
+        /// Set up ternary state bindables and bind them to selection/hitobject changes (in both directions)
+        /// </summary>
+        private void createStateBindables()
+        {
+            foreach (var sampleName in HitSampleInfo.AllAdditions)
+            {
+                var bindable = new Bindable<TernaryState>
+                {
+                    Description = sampleName.Replace("hit", string.Empty).Titleize()
+                };
+
+                bindable.ValueChanged += state =>
+                {
+                    switch (state.NewValue)
+                    {
+                        case TernaryState.False:
+                            RemoveHitSample(sampleName);
+                            break;
+
+                        case TernaryState.True:
+                            AddHitSample(sampleName);
+                            break;
+                    }
+                };
+
+                SelectionSampleStates[sampleName] = bindable;
+            }
+
+            // new combo
+            SelectionNewComboState.ValueChanged += state =>
+            {
+                switch (state.NewValue)
+                {
+                    case TernaryState.False:
+                        SetNewCombo(false);
+                        break;
+
+                    case TernaryState.True:
+                        SetNewCombo(true);
+                        break;
+                }
+            };
+
+            // bring in updates from selection changes
+            EditorBeatmap.HitObjectUpdated += _ => Scheduler.AddOnce(UpdateTernaryStates);
+            EditorBeatmap.SelectedHitObjects.CollectionChanged += (sender, args) =>
+            {
+                Scheduler.AddOnce(updateVisibility);
+                Scheduler.AddOnce(UpdateTernaryStates);
+            };
+        }
+
+        /// <summary>
+        /// Called when context menu ternary states may need to be recalculated (selection changed or hitobject updated).
+        /// </summary>
+        protected virtual void UpdateTernaryStates()
+        {
+            SelectionNewComboState.Value = GetStateFromSelection(EditorBeatmap.SelectedHitObjects.OfType<IHasComboInformation>(), h => h.NewCombo);
+
+            foreach (var (sampleName, bindable) in SelectionSampleStates)
+            {
+                bindable.Value = GetStateFromSelection(EditorBeatmap.SelectedHitObjects, h => h.Samples.Any(s => s.Name == sampleName));
+            }
+        }
+
+        /// <summary>
+        /// Given a selection target and a function of truth, retrieve the correct ternary state for display.
+        /// </summary>
+        protected TernaryState GetStateFromSelection<T>(IEnumerable<T> selection, Func<T, bool> func)
+        {
+            if (selection.Any(func))
+                return selection.All(func) ? TernaryState.True : TernaryState.Indeterminate;
+
+            return TernaryState.False;
         }
 
         #endregion
@@ -262,6 +476,11 @@ namespace osu.Game.Screens.Edit.Compose.Components
 
                 items.AddRange(GetContextMenuItemsForSelection(selectedBlueprints));
 
+                if (selectedBlueprints.All(b => b.HitObject is IHasComboInformation))
+                {
+                    items.Add(new TernaryStateMenuItem("New combo") { State = { BindTarget = SelectionNewComboState } });
+                }
+
                 if (selectedBlueprints.Count == 1)
                     items.AddRange(selectedBlueprints[0].ContextMenuItems);
 
@@ -269,12 +488,8 @@ namespace osu.Game.Screens.Edit.Compose.Components
                 {
                     new OsuMenuItem("Sound")
                     {
-                        Items = new[]
-                        {
-                            createHitSampleMenuItem("Whistle", HitSampleInfo.HIT_WHISTLE),
-                            createHitSampleMenuItem("Clap", HitSampleInfo.HIT_CLAP),
-                            createHitSampleMenuItem("Finish", HitSampleInfo.HIT_FINISH)
-                        }
+                        Items = SelectionSampleStates.Select(kvp =>
+                            new TernaryStateMenuItem(kvp.Value.Description) { State = { BindTarget = kvp.Value } }).ToArray()
                     },
                     new OsuMenuItem("Delete", MenuItemType.Destructive, deleteSelected),
                 });
@@ -291,41 +506,6 @@ namespace osu.Game.Screens.Edit.Compose.Components
         protected virtual IEnumerable<MenuItem> GetContextMenuItemsForSelection(IEnumerable<SelectionBlueprint> selection)
             => Enumerable.Empty<MenuItem>();
 
-        private MenuItem createHitSampleMenuItem(string name, string sampleName)
-        {
-            return new TernaryStateMenuItem(name, MenuItemType.Standard, setHitSampleState)
-            {
-                State = { Value = getHitSampleState() }
-            };
-
-            void setHitSampleState(TernaryState state)
-            {
-                switch (state)
-                {
-                    case TernaryState.False:
-                        RemoveHitSample(sampleName);
-                        break;
-
-                    case TernaryState.True:
-                        AddHitSample(sampleName);
-                        break;
-                }
-            }
-
-            TernaryState getHitSampleState()
-            {
-                int countExisting = SelectedHitObjects.Count(h => h.Samples.Any(s => s.Name == sampleName));
-
-                if (countExisting == 0)
-                    return TernaryState.False;
-
-                if (countExisting < SelectedHitObjects.Count())
-                    return TernaryState.Indeterminate;
-
-                return TernaryState.True;
-            }
-        }
-
         #endregion
     }
 }

osu.Game/Screens/Edit/Compose/Components/Timeline/DifficultyPointPiece.cs

@@ -0,0 +1,67 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Game.Beatmaps.ControlPoints;
+using osu.Game.Graphics;
+using osu.Game.Graphics.Sprites;
+using osuTK.Graphics;
+
+namespace osu.Game.Screens.Edit.Compose.Components.Timeline
+{
+    public class DifficultyPointPiece : CompositeDrawable
+    {
+        private readonly DifficultyControlPoint difficultyPoint;
+
+        private OsuSpriteText speedMultiplierText;
+        private readonly BindableNumber<double> speedMultiplier;
+
+        public DifficultyPointPiece(DifficultyControlPoint difficultyPoint)
+        {
+            this.difficultyPoint = difficultyPoint;
+            speedMultiplier = difficultyPoint.SpeedMultiplierBindable.GetBoundCopy();
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(OsuColour colours)
+        {
+            RelativeSizeAxes = Axes.Y;
+            AutoSizeAxes = Axes.X;
+
+            Color4 colour = difficultyPoint.GetRepresentingColour(colours);
+
+            InternalChildren = new Drawable[]
+            {
+                new Box
+                {
+                    Colour = colour,
+                    Width = 2,
+                    RelativeSizeAxes = Axes.Y,
+                },
+                new Container
+                {
+                    AutoSizeAxes = Axes.Both,
+                    Children = new Drawable[]
+                    {
+                        new Box
+                        {
+                            Colour = colour,
+                            RelativeSizeAxes = Axes.Both,
+                        },
+                        speedMultiplierText = new OsuSpriteText
+                        {
+                            Font = OsuFont.Default.With(weight: FontWeight.Bold),
+                            Colour = Color4.White,
+                        }
+                    }
+                },
+            };
+
+            speedMultiplier.BindValueChanged(multiplier => speedMultiplierText.Text = $"{multiplier.NewValue:n2}x", true);
+        }
+    }
+}

osu.Game/Screens/Edit/Compose/Components/Timeline/SamplePointPiece.cs

@@ -0,0 +1,85 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Extensions.Color4Extensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Colour;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Game.Beatmaps.ControlPoints;
+using osu.Game.Graphics;
+using osu.Game.Graphics.Sprites;
+using osuTK.Graphics;
+
+namespace osu.Game.Screens.Edit.Compose.Components.Timeline
+{
+    public class SamplePointPiece : CompositeDrawable
+    {
+        private readonly SampleControlPoint samplePoint;
+
+        private readonly Bindable<string> bank;
+        private readonly BindableNumber<int> volume;
+
+        private OsuSpriteText text;
+        private Box volumeBox;
+
+        public SamplePointPiece(SampleControlPoint samplePoint)
+        {
+            this.samplePoint = samplePoint;
+            volume = samplePoint.SampleVolumeBindable.GetBoundCopy();
+            bank = samplePoint.SampleBankBindable.GetBoundCopy();
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(OsuColour colours)
+        {
+            Origin = Anchor.TopLeft;
+            Anchor = Anchor.TopLeft;
+
+            AutoSizeAxes = Axes.X;
+            RelativeSizeAxes = Axes.Y;
+
+            Color4 colour = samplePoint.GetRepresentingColour(colours);
+
+            InternalChildren = new Drawable[]
+            {
+                new Container
+                {
+                    RelativeSizeAxes = Axes.Y,
+                    Width = 20,
+                    Children = new Drawable[]
+                    {
+                        volumeBox = new Box
+                        {
+                            X = 2,
+                            Anchor = Anchor.BottomLeft,
+                            Origin = Anchor.BottomLeft,
+                            Colour = ColourInfo.GradientVertical(colour, Color4.Black),
+                            RelativeSizeAxes = Axes.Both,
+                        },
+                        new Box
+                        {
+                            Colour = colour.Lighten(0.2f),
+                            Width = 2,
+                            RelativeSizeAxes = Axes.Y,
+                        },
+                    }
+                },
+                text = new OsuSpriteText
+                {
+                    X = 2,
+                    Y = -5,
+                    Anchor = Anchor.BottomLeft,
+                    Alpha = 0.9f,
+                    Rotation = -90,
+                    Font = OsuFont.Default.With(weight: FontWeight.SemiBold)
+                }
+            };
+
+            volume.BindValueChanged(volume => volumeBox.Height = volume.NewValue / 100f, true);
+            bank.BindValueChanged(bank => text.Text = bank.NewValue, true);
+        }
+    }
+}

osu.Game/Screens/Edit/Compose/Components/Timeline/Timeline.cs

@@ -8,8 +8,10 @@ using osu.Framework.Bindables;
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Audio;
+using osu.Framework.Graphics.Containers;
 using osu.Framework.Input.Events;
 using osu.Game.Beatmaps;
+using osu.Game.Configuration;
 using osu.Game.Graphics;
 using osu.Game.Rulesets.Edit;
 using osuTK;
@@ -21,55 +23,16 @@ namespace osu.Game.Screens.Edit.Compose.Components.Timeline
     public class Timeline : ZoomableScrollContainer, IPositionSnapProvider
     {
         public readonly Bindable<bool> WaveformVisible = new Bindable<bool>();
+
+        public readonly Bindable<bool> ControlPointsVisible = new Bindable<bool>();
+
+        public readonly Bindable<bool> TicksVisible = new Bindable<bool>();
+
         public readonly IBindable<WorkingBeatmap> Beatmap = new Bindable<WorkingBeatmap>();
 
         [Resolved]
         private EditorClock editorClock { get; set; }
 
-        public Timeline()
-        {
-            ZoomDuration = 200;
-            ZoomEasing = Easing.OutQuint;
-            ScrollbarVisible = false;
-        }
-
-        private WaveformGraph waveform;
-
-        [BackgroundDependencyLoader]
-        private void load(IBindable<WorkingBeatmap> beatmap, OsuColour colours)
-        {
-            Add(waveform = new WaveformGraph
-            {
-                RelativeSizeAxes = Axes.Both,
-                Colour = colours.Blue.Opacity(0.2f),
-                LowColour = colours.BlueLighter,
-                MidColour = colours.BlueDark,
-                HighColour = colours.BlueDarker,
-                Depth = float.MaxValue
-            });
-
-            // We don't want the centre marker to scroll
-            AddInternal(new CentreMarker { Depth = float.MaxValue });
-
-            WaveformVisible.ValueChanged += visible => waveform.FadeTo(visible.NewValue ? 1 : 0, 200, Easing.OutQuint);
-
-            Beatmap.BindTo(beatmap);
-            Beatmap.BindValueChanged(b =>
-            {
-                waveform.Waveform = b.NewValue.Waveform;
-                track = b.NewValue.Track;
-
-                if (track.Length > 0)
-                {
-                    MaxZoom = getZoomLevelForVisibleMilliseconds(500);
-                    MinZoom = getZoomLevelForVisibleMilliseconds(10000);
-                    Zoom = getZoomLevelForVisibleMilliseconds(2000);
-                }
-            }, true);
-        }
-
-        private float getZoomLevelForVisibleMilliseconds(double milliseconds) => (float)(track.Length / milliseconds);
-
         /// <summary>
         /// The timeline's scroll position in the last frame.
         /// </summary>
@@ -92,6 +55,77 @@ namespace osu.Game.Screens.Edit.Compose.Components.Timeline
 
         private Track track;
 
+        public Timeline()
+        {
+            ZoomDuration = 200;
+            ZoomEasing = Easing.OutQuint;
+            ScrollbarVisible = false;
+        }
+
+        private WaveformGraph waveform;
+
+        private TimelineTickDisplay ticks;
+
+        private TimelineControlPointDisplay controlPoints;
+
+        private Bindable<float> waveformOpacity;
+
+        [BackgroundDependencyLoader]
+        private void load(IBindable<WorkingBeatmap> beatmap, OsuColour colours, OsuConfigManager config)
+        {
+            AddRange(new Drawable[]
+            {
+                new Container
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Depth = float.MaxValue,
+                    Children = new Drawable[]
+                    {
+                        waveform = new WaveformGraph
+                        {
+                            RelativeSizeAxes = Axes.Both,
+                            BaseColour = colours.Blue.Opacity(0.2f),
+                            LowColour = colours.BlueLighter,
+                            MidColour = colours.BlueDark,
+                            HighColour = colours.BlueDarker,
+                        },
+                        ticks = new TimelineTickDisplay(),
+                        controlPoints = new TimelineControlPointDisplay(),
+                    }
+                },
+            });
+
+            // We don't want the centre marker to scroll
+            AddInternal(new CentreMarker { Depth = float.MaxValue });
+
+            waveformOpacity = config.GetBindable<float>(OsuSetting.EditorWaveformOpacity);
+            waveformOpacity.BindValueChanged(_ => updateWaveformOpacity(), true);
+
+            WaveformVisible.ValueChanged += _ => updateWaveformOpacity();
+            ControlPointsVisible.ValueChanged += visible => controlPoints.FadeTo(visible.NewValue ? 1 : 0, 200, Easing.OutQuint);
+            TicksVisible.ValueChanged += visible => ticks.FadeTo(visible.NewValue ? 1 : 0, 200, Easing.OutQuint);
+
+            Beatmap.BindTo(beatmap);
+            Beatmap.BindValueChanged(b =>
+            {
+                waveform.Waveform = b.NewValue.Waveform;
+                track = b.NewValue.Track;
+
+                // todo: i don't think this is safe, the track may not be loaded yet.
+                if (track.Length > 0)
+                {
+                    MaxZoom = getZoomLevelForVisibleMilliseconds(500);
+                    MinZoom = getZoomLevelForVisibleMilliseconds(10000);
+                    Zoom = getZoomLevelForVisibleMilliseconds(2000);
+                }
+            }, true);
+        }
+
+        private void updateWaveformOpacity() =>
+            waveform.FadeTo(WaveformVisible.Value ? waveformOpacity.Value : 0, 200, Easing.OutQuint);
+
+        private float getZoomLevelForVisibleMilliseconds(double milliseconds) => Math.Max(1, (float)(track.Length / milliseconds));
+
         protected override void Update()
         {
             base.Update();
@@ -140,6 +174,11 @@ namespace osu.Game.Screens.Edit.Compose.Components.Timeline
             if (!track.IsLoaded || track.Length == 0)
                 return;
 
+            // covers the case where the user starts playback after a drag is in progress.
+            // we want to ensure the clock is always stopped during drags to avoid weird audio playback.
+            if (handlingDragInput)
+                editorClock.Stop();
+
             ScrollTo((float)(editorClock.CurrentTime / track.Length) * Content.DrawWidth, false);
         }
 
@@ -180,6 +219,11 @@ namespace osu.Game.Screens.Edit.Compose.Components.Timeline
         [Resolved]
         private IBeatSnapProvider beatSnapProvider { get; set; }
 
+        /// <summary>
+        /// The total amount of time visible on the timeline.
+        /// </summary>
+        public double VisibleRange => track.Length / Zoom;
+
         public SnapResult SnapScreenSpacePositionToValidTime(Vector2 screenSpacePosition) =>
             new SnapResult(screenSpacePosition, beatSnapProvider.SnapTime(getTimeFromPosition(Content.ToLocalSpace(screenSpacePosition))));
 

osu.Game/Screens/Edit/Compose/Components/Timeline/TimelineArea.cs

@@ -14,9 +14,9 @@ namespace osu.Game.Screens.Edit.Compose.Components.Timeline
 {
     public class TimelineArea : Container
     {
-        private readonly Timeline timeline = new Timeline { RelativeSizeAxes = Axes.Both };
+        public readonly Timeline Timeline = new Timeline { RelativeSizeAxes = Axes.Both };
 
-        protected override Container<Drawable> Content => timeline;
+        protected override Container<Drawable> Content => Timeline;
 
         [BackgroundDependencyLoader]
         private void load()
@@ -25,6 +25,8 @@ namespace osu.Game.Screens.Edit.Compose.Components.Timeline
             CornerRadius = 5;
 
             OsuCheckbox waveformCheckbox;
+            OsuCheckbox controlPointsCheckbox;
+            OsuCheckbox ticksCheckbox;
 
             InternalChildren = new Drawable[]
             {
@@ -57,12 +59,26 @@ namespace osu.Game.Screens.Edit.Compose.Components.Timeline
                                         Origin = Anchor.CentreLeft,
                                         AutoSizeAxes = Axes.Y,
                                         Width = 160,
-                                        Padding = new MarginPadding { Horizontal = 15 },
+                                        Padding = new MarginPadding { Horizontal = 10 },
                                         Direction = FillDirection.Vertical,
                                         Spacing = new Vector2(0, 4),
                                         Children = new[]
                                         {
-                                            waveformCheckbox = new OsuCheckbox { LabelText = "Waveform" }
+                                            waveformCheckbox = new OsuCheckbox
+                                            {
+                                                LabelText = "Waveform",
+                                                Current = { Value = true },
+                                            },
+                                            controlPointsCheckbox = new OsuCheckbox
+                                            {
+                                                LabelText = "Control Points",
+                                                Current = { Value = true },
+                                            },
+                                            ticksCheckbox = new OsuCheckbox
+                                            {
+                                                LabelText = "Ticks",
+                                                Current = { Value = true },
+                                            }
                                         }
                                     }
                                 }
@@ -107,7 +123,7 @@ namespace osu.Game.Screens.Edit.Compose.Components.Timeline
                                     }
                                 }
                             },
-                            timeline
+                            Timeline
                         },
                     },
                     ColumnDimensions = new[]
@@ -119,11 +135,11 @@ namespace osu.Game.Screens.Edit.Compose.Components.Timeline
                 }
             };
 
-            waveformCheckbox.Current.Value = true;
-
-            timeline.WaveformVisible.BindTo(waveformCheckbox.Current);
+            Timeline.WaveformVisible.BindTo(waveformCheckbox.Current);
+            Timeline.ControlPointsVisible.BindTo(controlPointsCheckbox.Current);
+            Timeline.TicksVisible.BindTo(ticksCheckbox.Current);
         }
 
-        private void changeZoom(float change) => timeline.Zoom += change;
+        private void changeZoom(float change) => Timeline.Zoom += change;
     }
 }

osu.Game/Screens/Edit/Compose/Components/Timeline/TimelineBlueprintContainer.cs

@@ -9,10 +9,10 @@ using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Primitives;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Input.Events;
+using osu.Framework.Utils;
 using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Screens.Edit.Components.Timelines.Summary.Parts;
-using osuTK;
 using osuTK.Graphics;
 
 namespace osu.Game.Screens.Edit.Compose.Components.Timeline
@@ -26,12 +26,11 @@ namespace osu.Game.Screens.Edit.Compose.Components.Timeline
         private EditorBeatmap beatmap { get; set; }
 
         private DragEvent lastDragEvent;
-
         private Bindable<HitObject> placement;
-
         private SelectionBlueprint placementBlueprint;
 
-        public TimelineBlueprintContainer()
+        public TimelineBlueprintContainer(HitObjectComposer composer)
+            : base(composer)
         {
             RelativeSizeAxes = Axes.Both;
             Anchor = Anchor.Centre;
@@ -97,6 +96,12 @@ namespace osu.Game.Screens.Edit.Compose.Components.Timeline
             if (lastDragEvent != null)
                 OnDrag(lastDragEvent);
 
+            if (Composer != null && timeline != null)
+            {
+                Composer.Playfield.PastLifetimeExtension = timeline.VisibleRange / 2;
+                Composer.Playfield.FutureLifetimeExtension = timeline.VisibleRange / 2;
+            }
+
             base.Update();
         }
 
@@ -137,8 +142,14 @@ namespace osu.Game.Screens.Edit.Compose.Components.Timeline
 
         private class TimelineDragBox : DragBox
         {
-            private Vector2 lastMouseDown;
-            private float localMouseDown;
+            // the following values hold the start and end X positions of the drag box in the timeline's local space,
+            // but with zoom unapplied in order to be able to compensate for positional changes
+            // while the timeline is being zoomed in/out.
+            private float? selectionStart;
+            private float selectionEnd;
+
+            [Resolved]
+            private Timeline timeline { get; set; }
 
             public TimelineDragBox(Action<RectangleF> performSelect)
                 : base(performSelect)
@@ -153,21 +164,34 @@ namespace osu.Game.Screens.Edit.Compose.Components.Timeline
 
             public override bool HandleDrag(MouseButtonEvent e)
             {
-                // store the original position of the mouse down, as we may be scrolled during selection.
-                if (lastMouseDown != e.ScreenSpaceMouseDownPosition)
-                {
-                    lastMouseDown = e.ScreenSpaceMouseDownPosition;
-                    localMouseDown = e.MouseDownPosition.X;
-                }
+                selectionStart ??= e.MouseDownPosition.X / timeline.CurrentZoom;
 
-                float selection1 = localMouseDown;
-                float selection2 = e.MousePosition.X;
+                // only calculate end when a transition is not in progress to avoid bouncing.
+                if (Precision.AlmostEquals(timeline.CurrentZoom, timeline.Zoom))
+                    selectionEnd = e.MousePosition.X / timeline.CurrentZoom;
 
-                Box.X = Math.Min(selection1, selection2);
-                Box.Width = Math.Abs(selection1 - selection2);
+                updateDragBoxPosition();
+                return true;
+            }
+
+            private void updateDragBoxPosition()
+            {
+                if (selectionStart == null)
+                    return;
+
+                float rescaledStart = selectionStart.Value * timeline.CurrentZoom;
+                float rescaledEnd = selectionEnd * timeline.CurrentZoom;
+
+                Box.X = Math.Min(rescaledStart, rescaledEnd);
+                Box.Width = Math.Abs(rescaledStart - rescaledEnd);
 
                 PerformSelection?.Invoke(Box.ScreenSpaceDrawQuad.AABBFloat);
-                return true;
+            }
+
+            public override void Hide()
+            {
+                base.Hide();
+                selectionStart = null;
             }
         }
 
@@ -177,7 +201,7 @@ namespace osu.Game.Screens.Edit.Compose.Components.Timeline
 
             public TimelineSelectionBlueprintContainer()
             {
-                AddInternal(new TimelinePart<SelectionBlueprint>(Content = new Container<SelectionBlueprint> { RelativeSizeAxes = Axes.Both }) { RelativeSizeAxes = Axes.Both });
+                AddInternal(new TimelinePart<SelectionBlueprint>(Content = new HitObjectOrderedSelectionContainer { RelativeSizeAxes = Axes.Both }) { RelativeSizeAxes = Axes.Both });
             }
         }
     }

osu.Game/Screens/Edit/Compose/Components/Timeline/TimelineControlPointDisplay.cs

@@ -0,0 +1,58 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Collections.Specialized;
+using System.Linq;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Game.Beatmaps;
+using osu.Game.Beatmaps.ControlPoints;
+using osu.Game.Screens.Edit.Components.Timelines.Summary.Parts;
+
+namespace osu.Game.Screens.Edit.Compose.Components.Timeline
+{
+    /// <summary>
+    /// The part of the timeline that displays the control points.
+    /// </summary>
+    public class TimelineControlPointDisplay : TimelinePart<TimelineControlPointGroup>
+    {
+        private readonly IBindableList<ControlPointGroup> controlPointGroups = new BindableList<ControlPointGroup>();
+
+        public TimelineControlPointDisplay()
+        {
+            RelativeSizeAxes = Axes.Both;
+        }
+
+        protected override void LoadBeatmap(WorkingBeatmap beatmap)
+        {
+            base.LoadBeatmap(beatmap);
+
+            controlPointGroups.UnbindAll();
+            controlPointGroups.BindTo(beatmap.Beatmap.ControlPointInfo.Groups);
+            controlPointGroups.BindCollectionChanged((sender, args) =>
+            {
+                switch (args.Action)
+                {
+                    case NotifyCollectionChangedAction.Reset:
+                        Clear();
+                        break;
+
+                    case NotifyCollectionChangedAction.Add:
+                        foreach (var group in args.NewItems.OfType<ControlPointGroup>())
+                            Add(new TimelineControlPointGroup(group));
+                        break;
+
+                    case NotifyCollectionChangedAction.Remove:
+                        foreach (var group in args.OldItems.OfType<ControlPointGroup>())
+                        {
+                            var matching = Children.SingleOrDefault(gv => gv.Group == group);
+
+                            matching?.Expire();
+                        }
+
+                        break;
+                }
+            }, true);
+        }
+    }
+}

osu.Game/Screens/Edit/Compose/Components/Timeline/TimelineControlPointGroup.cs

@@ -0,0 +1,62 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Game.Beatmaps.ControlPoints;
+using osu.Game.Graphics;
+
+namespace osu.Game.Screens.Edit.Compose.Components.Timeline
+{
+    public class TimelineControlPointGroup : CompositeDrawable
+    {
+        public readonly ControlPointGroup Group;
+
+        private readonly IBindableList<ControlPoint> controlPoints = new BindableList<ControlPoint>();
+
+        [Resolved]
+        private OsuColour colours { get; set; }
+
+        public TimelineControlPointGroup(ControlPointGroup group)
+        {
+            Group = group;
+
+            RelativePositionAxes = Axes.X;
+            RelativeSizeAxes = Axes.Y;
+            AutoSizeAxes = Axes.X;
+
+            X = (float)group.Time;
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            controlPoints.BindTo(Group.ControlPoints);
+            controlPoints.BindCollectionChanged((_, __) =>
+            {
+                ClearInternal();
+
+                foreach (var point in controlPoints)
+                {
+                    switch (point)
+                    {
+                        case DifficultyControlPoint difficultyPoint:
+                            AddInternal(new DifficultyPointPiece(difficultyPoint) { Depth = -2 });
+                            break;
+
+                        case TimingControlPoint timingPoint:
+                            AddInternal(new TimingPointPiece(timingPoint));
+                            break;
+
+                        case SampleControlPoint samplePoint:
+                            AddInternal(new SamplePointPiece(samplePoint) { Depth = -1 });
+                            break;
+                    }
+                }
+            }, true);
+        }
+    }
+}

osu.Game/Screens/Edit/Compose/Components/Timeline/TimelineHitObjectBlueprint.cs

@@ -3,18 +3,23 @@
 
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using JetBrains.Annotations;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
+using osu.Framework.Graphics.Colour;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Effects;
 using osu.Framework.Graphics.Primitives;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Input.Events;
+using osu.Game.Graphics;
+using osu.Game.Graphics.Sprites;
 using osu.Game.Graphics.UserInterface;
 using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Objects.Types;
 using osuTK;
 using osuTK.Graphics;
@@ -34,11 +39,21 @@ namespace osu.Game.Screens.Edit.Compose.Components.Timeline
 
         private readonly List<Container> shadowComponents = new List<Container>();
 
+        private DrawableHitObject drawableHitObject;
+
+        private Bindable<Color4> comboColour;
+
+        private readonly Container mainComponents;
+
+        private readonly OsuSpriteText comboIndexText;
+
+        private Bindable<int> comboIndex;
+
         private const float thickness = 5;
 
         private const float shadow_radius = 5;
 
-        private const float circle_size = 16;
+        private const float circle_size = 24;
 
         public TimelineHitObjectBlueprint(HitObject hitObject)
             : base(hitObject)
@@ -54,14 +69,28 @@ namespace osu.Game.Screens.Edit.Compose.Components.Timeline
             RelativeSizeAxes = Axes.X;
             AutoSizeAxes = Axes.Y;
 
+            AddRangeInternal(new Drawable[]
+            {
+                mainComponents = new Container
+                {
+                    Anchor = Anchor.CentreLeft,
+                    Origin = Anchor.CentreLeft,
+                    RelativeSizeAxes = Axes.X,
+                    AutoSizeAxes = Axes.Y,
+                },
+                comboIndexText = new OsuSpriteText
+                {
+                    Anchor = Anchor.CentreLeft,
+                    Origin = Anchor.Centre,
+                    Font = OsuFont.Numeric.With(size: circle_size / 2, weight: FontWeight.Black),
+                },
+            });
+
             circle = new Circle
             {
                 Size = new Vector2(circle_size),
                 Anchor = Anchor.CentreLeft,
                 Origin = Anchor.Centre,
-                RelativePositionAxes = Axes.X,
-                AlwaysPresent = true,
-                Colour = Color4.White,
                 EdgeEffect = new EdgeEffectParameters
                 {
                     Type = EdgeEffectType.Shadow,
@@ -77,7 +106,7 @@ namespace osu.Game.Screens.Edit.Compose.Components.Timeline
                 DragBar dragBarUnderlay;
                 Container extensionBar;
 
-                AddRangeInternal(new Drawable[]
+                mainComponents.AddRange(new Drawable[]
                 {
                     extensionBar = new Container
                     {
@@ -117,18 +146,93 @@ namespace osu.Game.Screens.Edit.Compose.Components.Timeline
             }
             else
             {
-                AddInternal(circle);
+                mainComponents.Add(circle);
             }
 
             updateShadows();
         }
 
+        [BackgroundDependencyLoader(true)]
+        private void load(HitObjectComposer composer)
+        {
+            if (composer != null)
+            {
+                // best effort to get the drawable representation for grabbing colour and what not.
+                drawableHitObject = composer.HitObjects.FirstOrDefault(d => d.HitObject == HitObject);
+            }
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            if (HitObject is IHasComboInformation comboInfo)
+            {
+                comboIndex = comboInfo.IndexInCurrentComboBindable.GetBoundCopy();
+                comboIndex.BindValueChanged(combo =>
+                {
+                    comboIndexText.Text = (combo.NewValue + 1).ToString();
+                }, true);
+            }
+
+            if (drawableHitObject != null)
+            {
+                comboColour = drawableHitObject.AccentColour.GetBoundCopy();
+                comboColour.BindValueChanged(colour =>
+                {
+                    if (HitObject is IHasDuration)
+                        mainComponents.Colour = ColourInfo.GradientHorizontal(drawableHitObject.AccentColour.Value, Color4.White);
+                    else
+                        mainComponents.Colour = drawableHitObject.AccentColour.Value;
+
+                    var col = mainComponents.Colour.TopLeft.Linear;
+                    float brightness = col.R + col.G + col.B;
+
+                    // decide the combo index colour based on brightness?
+                    comboIndexText.Colour = brightness > 0.5f ? Color4.Black : Color4.White;
+                }, true);
+            }
+        }
+
         protected override void Update()
         {
             base.Update();
 
             // no bindable so we perform this every update
-            Width = (float)(HitObject.GetEndTime() - HitObject.StartTime);
+            float duration = (float)(HitObject.GetEndTime() - HitObject.StartTime);
+
+            if (Width != duration)
+            {
+                Width = duration;
+
+                // kind of haphazard but yeah, no bindables.
+                if (HitObject is IHasRepeats repeats)
+                    updateRepeats(repeats);
+            }
+        }
+
+        private Container repeatsContainer;
+
+        private void updateRepeats(IHasRepeats repeats)
+        {
+            repeatsContainer?.Expire();
+
+            mainComponents.Add(repeatsContainer = new Container
+            {
+                RelativeSizeAxes = Axes.Both,
+            });
+
+            for (int i = 0; i < repeats.RepeatCount; i++)
+            {
+                repeatsContainer.Add(new Circle
+                {
+                    Size = new Vector2(circle_size / 2),
+                    Anchor = Anchor.CentreLeft,
+                    Origin = Anchor.Centre,
+                    RelativePositionAxes = Axes.X,
+                    X = (float)(i + 1) / (repeats.RepeatCount + 1),
+                });
+            }
         }
 
         protected override bool ShouldBeConsideredForInput(Drawable child) => true;
@@ -288,6 +392,7 @@ namespace osu.Game.Screens.Edit.Compose.Components.Timeline
                                 return;
 
                             repeatHitObject.RepeatCount = proposedCount;
+                            beatmap.Update(hitObject);
                             break;
 
                         case IHasDuration endTimeHitObject:
@@ -297,10 +402,9 @@ namespace osu.Game.Screens.Edit.Compose.Components.Timeline
                                 return;
 
                             endTimeHitObject.Duration = snappedTime - hitObject.StartTime;
+                            beatmap.Update(hitObject);
                             break;
                     }
-
-                    beatmap.UpdateHitObject(hitObject);
                 }
             }
 

osu.Game/Screens/Edit/Compose/Components/Timeline/TimelineTickDisplay.cs

@@ -1,9 +1,11 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System;
 using System.Linq;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
+using osu.Framework.Caching;
 using osu.Framework.Graphics;
 using osu.Game.Beatmaps;
 using osu.Game.Graphics;
@@ -12,7 +14,7 @@ using osu.Game.Screens.Edit.Components.Timelines.Summary.Visualisations;
 
 namespace osu.Game.Screens.Edit.Compose.Components.Timeline
 {
-    public class TimelineTickDisplay : TimelinePart
+    public class TimelineTickDisplay : TimelinePart<PointVisualisation>
     {
         [Resolved]
         private EditorBeatmap beatmap { get; set; }
@@ -31,15 +33,63 @@ namespace osu.Game.Screens.Edit.Compose.Components.Timeline
             RelativeSizeAxes = Axes.Both;
         }
 
+        private readonly Cached tickCache = new Cached();
+
         [BackgroundDependencyLoader]
         private void load()
         {
-            beatDivisor.BindValueChanged(_ => createLines(), true);
+            beatDivisor.BindValueChanged(_ => tickCache.Invalidate());
         }
 
-        private void createLines()
+        /// <summary>
+        /// The visible time/position range of the timeline.
+        /// </summary>
+        private (float min, float max) visibleRange = (float.MinValue, float.MaxValue);
+
+        /// <summary>
+        /// The next time/position value to the left of the display when tick regeneration needs to be run.
+        /// </summary>
+        private float? nextMinTick;
+
+        /// <summary>
+        /// The next time/position value to the right of the display when tick regeneration needs to be run.
+        /// </summary>
+        private float? nextMaxTick;
+
+        [Resolved(canBeNull: true)]
+        private Timeline timeline { get; set; }
+
+        protected override void Update()
         {
-            Clear();
+            base.Update();
+
+            if (timeline != null)
+            {
+                var newRange = (
+                    (ToLocalSpace(timeline.ScreenSpaceDrawQuad.TopLeft).X - PointVisualisation.WIDTH * 2) / DrawWidth * Content.RelativeChildSize.X,
+                    (ToLocalSpace(timeline.ScreenSpaceDrawQuad.TopRight).X + PointVisualisation.WIDTH * 2) / DrawWidth * Content.RelativeChildSize.X);
+
+                if (visibleRange != newRange)
+                {
+                    visibleRange = newRange;
+
+                    // actual regeneration only needs to occur if we've passed one of the known next min/max tick boundaries.
+                    if (nextMinTick == null || nextMaxTick == null || (visibleRange.min < nextMinTick || visibleRange.max > nextMaxTick))
+                        tickCache.Invalidate();
+                }
+            }
+
+            if (!tickCache.IsValid)
+                createTicks();
+        }
+
+        private void createTicks()
+        {
+            int drawableIndex = 0;
+            int highestDivisor = BindableBeatDivisor.VALID_DIVISORS.Last();
+
+            nextMinTick = null;
+            nextMaxTick = null;
 
             for (var i = 0; i < beatmap.ControlPointInfo.TimingPoints.Count; i++)
             {
@@ -50,41 +100,70 @@ namespace osu.Game.Screens.Edit.Compose.Components.Timeline
 
                 for (double t = point.Time; t < until; t += point.BeatLength / beatDivisor.Value)
                 {
-                    var indexInBeat = beat % beatDivisor.Value;
+                    float xPos = (float)t;
 
-                    if (indexInBeat == 0)
-                    {
-                        Add(new PointVisualisation(t)
-                        {
-                            Colour = BindableBeatDivisor.GetColourFor(1, colours),
-                            Origin = Anchor.TopCentre,
-                        });
-                    }
+                    if (t < visibleRange.min)
+                        nextMinTick = xPos;
+                    else if (t > visibleRange.max)
+                        nextMaxTick ??= xPos;
                     else
                     {
+                        // if this is the first beat in the beatmap, there is no next min tick
+                        if (beat == 0 && i == 0)
+                            nextMinTick = float.MinValue;
+
+                        var indexInBar = beat % ((int)point.TimeSignature * beatDivisor.Value);
+
                         var divisor = BindableBeatDivisor.GetDivisorForBeatIndex(beat, beatDivisor.Value);
                         var colour = BindableBeatDivisor.GetColourFor(divisor, colours);
-                        var height = 0.1f - (float)divisor / BindableBeatDivisor.VALID_DIVISORS.Last() * 0.08f;
 
-                        Add(new PointVisualisation(t)
-                        {
-                            Colour = colour,
-                            Height = height,
-                            Origin = Anchor.TopCentre,
-                        });
+                        // even though "bar lines" take up the full vertical space, we render them in two pieces because it allows for less anchor/origin churn.
+                        var height = indexInBar == 0 ? 0.5f : 0.1f - (float)divisor / highestDivisor * 0.08f;
 
-                        Add(new PointVisualisation(t)
-                        {
-                            Colour = colour,
-                            Anchor = Anchor.BottomLeft,
-                            Origin = Anchor.BottomCentre,
-                            Height = height,
-                        });
+                        var topPoint = getNextUsablePoint();
+                        topPoint.X = xPos;
+                        topPoint.Colour = colour;
+                        topPoint.Height = height;
+                        topPoint.Anchor = Anchor.TopLeft;
+                        topPoint.Origin = Anchor.TopCentre;
+
+                        var bottomPoint = getNextUsablePoint();
+                        bottomPoint.X = xPos;
+                        bottomPoint.Colour = colour;
+                        bottomPoint.Anchor = Anchor.BottomLeft;
+                        bottomPoint.Origin = Anchor.BottomCentre;
+                        bottomPoint.Height = height;
                     }
 
                     beat++;
                 }
             }
+
+            int usedDrawables = drawableIndex;
+
+            // save a few drawables beyond the currently used for edge cases.
+            while (drawableIndex < Math.Min(usedDrawables + 16, Count))
+                Children[drawableIndex++].Hide();
+
+            // expire any excess
+            while (drawableIndex < Count)
+                Children[drawableIndex++].Expire();
+
+            tickCache.Validate();
+
+            Drawable getNextUsablePoint()
+            {
+                PointVisualisation point;
+                if (drawableIndex >= Count)
+                    Add(point = new PointVisualisation());
+                else
+                    point = Children[drawableIndex];
+
+                drawableIndex++;
+                point.Show();
+
+                return point;
+            }
         }
     }
 }

osu.Game/Screens/Edit/Compose/Components/Timeline/TimingPointPiece.cs

@@ -0,0 +1,63 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Extensions.Color4Extensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Colour;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Game.Beatmaps.ControlPoints;
+using osu.Game.Graphics;
+using osu.Game.Graphics.Sprites;
+using osuTK.Graphics;
+
+namespace osu.Game.Screens.Edit.Compose.Components.Timeline
+{
+    public class TimingPointPiece : CompositeDrawable
+    {
+        private readonly TimingControlPoint point;
+
+        private readonly BindableNumber<double> beatLength;
+        private OsuSpriteText bpmText;
+
+        public TimingPointPiece(TimingControlPoint point)
+        {
+            this.point = point;
+            beatLength = point.BeatLengthBindable.GetBoundCopy();
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(OsuColour colours)
+        {
+            Origin = Anchor.CentreLeft;
+            Anchor = Anchor.CentreLeft;
+
+            AutoSizeAxes = Axes.Both;
+
+            Color4 colour = point.GetRepresentingColour(colours);
+
+            InternalChildren = new Drawable[]
+            {
+                new Box
+                {
+                    Alpha = 0.9f,
+                    Colour = ColourInfo.GradientHorizontal(colour, colour.Opacity(0.5f)),
+                    RelativeSizeAxes = Axes.Both,
+                },
+                bpmText = new OsuSpriteText
+                {
+                    Alpha = 0.9f,
+                    Padding = new MarginPadding(3),
+                    Font = OsuFont.Default.With(size: 40)
+                }
+            };
+
+            beatLength.BindValueChanged(beatLength =>
+            {
+                bpmText.Text = $"{60000 / beatLength.NewValue:n1} BPM";
+            }, true);
+        }
+    }
+}

osu.Game/Screens/Edit/Compose/Components/Timeline/ZoomableScrollContainer.cs

@@ -29,9 +29,14 @@ namespace osu.Game.Screens.Edit.Compose.Components.Timeline
 
         private readonly Container zoomedContent;
         protected override Container<Drawable> Content => zoomedContent;
-
         private float currentZoom = 1;
 
+        /// <summary>
+        /// The current zoom level of <see cref="ZoomableScrollContainer" />.
+        /// It may differ from <see cref="Zoom" /> during transitions.
+        /// </summary>
+        public float CurrentZoom => currentZoom;
+
         [Resolved(canBeNull: true)]
         private IFrameBasedClock editorClock { get; set; }
 
@@ -108,19 +113,19 @@ namespace osu.Game.Screens.Edit.Compose.Components.Timeline
 
         protected override bool OnScroll(ScrollEvent e)
         {
-            if (e.IsPrecise)
+            if (e.AltPressed)
             {
-                // can't handle scroll correctly while playing.
-                // the editor will handle this case for us.
-                if (editorClock?.IsRunning == true)
-                    return false;
-
-                // for now, we don't support zoom when using a precision scroll device. this needs gesture support.
-                return base.OnScroll(e);
+                // zoom when holding alt.
+                setZoomTarget(zoomTarget + e.ScrollDelta.Y, zoomedContent.ToLocalSpace(e.ScreenSpaceMousePosition).X);
+                return true;
             }
 
-            setZoomTarget(zoomTarget + e.ScrollDelta.Y, zoomedContent.ToLocalSpace(e.ScreenSpaceMousePosition).X);
-            return true;
+            // can't handle scroll correctly while playing.
+            // the editor will handle this case for us.
+            if (editorClock?.IsRunning == true)
+                return false;
+
+            return base.OnScroll(e);
         }
 
         private void updateZoomedContentWidth() => zoomedContent.Width = DrawWidth * currentZoom;

osu.Game/Screens/Edit/Compose/ComposeScreen.cs

@@ -1,8 +1,12 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
+using osu.Game.Beatmaps;
+using osu.Game.Rulesets;
 using osu.Game.Rulesets.Edit;
 using osu.Game.Screens.Edit.Compose.Components.Timeline;
 using osu.Game.Skinning;
@@ -13,11 +17,29 @@ namespace osu.Game.Screens.Edit.Compose
     {
         private HitObjectComposer composer;
 
-        protected override Drawable CreateMainContent()
+        public ComposeScreen()
+            : base(EditorScreenMode.Compose)
         {
-            var ruleset = Beatmap.Value.BeatmapInfo.Ruleset?.CreateInstance();
+        }
+
+        private Ruleset ruleset;
+
+        protected override IReadOnlyDependencyContainer CreateChildDependencies(IReadOnlyDependencyContainer parent)
+        {
+            var dependencies = new DependencyContainer(base.CreateChildDependencies(parent));
+
+            ruleset = parent.Get<IBindable<WorkingBeatmap>>().Value.BeatmapInfo.Ruleset?.CreateInstance();
             composer = ruleset?.CreateHitObjectComposer();
 
+            // make the composer available to the timeline and other components in this screen.
+            if (composer != null)
+                dependencies.CacheAs(composer);
+
+            return dependencies;
+        }
+
+        protected override Drawable CreateMainContent()
+        {
             if (ruleset == null || composer == null)
                 return new ScreenWhiteBox.UnderConstructionMessage(ruleset == null ? "This beatmap" : $"{ruleset.Description}'s composer");
 
@@ -32,6 +54,6 @@ namespace osu.Game.Screens.Edit.Compose
             return beatmapSkinProvider.WithChild(rulesetSkinProvider.WithChild(composer));
         }
 
-        protected override Drawable CreateTimelineContent() => composer == null ? base.CreateTimelineContent() : new TimelineBlueprintContainer();
+        protected override Drawable CreateTimelineContent() => composer == null ? base.CreateTimelineContent() : new TimelineBlueprintContainer(composer);
     }
 }

osu.Game/Screens/Edit/Design/DesignScreen.cs

@@ -6,6 +6,7 @@ namespace osu.Game.Screens.Edit.Design
     public class DesignScreen : EditorScreen
     {
         public DesignScreen()
+            : base(EditorScreenMode.Design)
         {
             Child = new ScreenWhiteBox.UnderConstructionMessage("Design mode");
         }

osu.Game/Screens/Edit/Editor.cs

@@ -2,43 +2,51 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
-using osuTK.Graphics;
-using osu.Framework.Screens;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using osu.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
-using osu.Game.Graphics;
-using osu.Game.Screens.Edit.Components.Timelines.Summary;
-using osu.Framework.Allocation;
-using osu.Framework.Bindables;
 using osu.Framework.Graphics.UserInterface;
-using osu.Framework.Input.Events;
-using osu.Framework.Platform;
-using osu.Framework.Timing;
-using osu.Game.Graphics.UserInterface;
-using osu.Game.Screens.Edit.Components;
-using osu.Game.Screens.Edit.Components.Menus;
-using osu.Game.Screens.Edit.Design;
-using osuTK.Input;
-using System.Collections.Generic;
-using osu.Framework;
 using osu.Framework.Input;
 using osu.Framework.Input.Bindings;
+using osu.Framework.Input.Events;
 using osu.Framework.Logging;
+using osu.Framework.Platform;
+using osu.Framework.Screens;
+using osu.Framework.Timing;
 using osu.Game.Beatmaps;
+using osu.Game.Configuration;
+using osu.Game.Graphics;
 using osu.Game.Graphics.Cursor;
+using osu.Game.Graphics.UserInterface;
 using osu.Game.Input.Bindings;
+using osu.Game.IO.Serialization;
+using osu.Game.Online.API;
+using osu.Game.Overlays;
 using osu.Game.Rulesets.Edit;
+using osu.Game.Screens.Edit.Components;
+using osu.Game.Screens.Edit.Components.Menus;
+using osu.Game.Screens.Edit.Components.Timelines.Summary;
 using osu.Game.Screens.Edit.Compose;
+using osu.Game.Screens.Edit.Design;
 using osu.Game.Screens.Edit.Setup;
 using osu.Game.Screens.Edit.Timing;
 using osu.Game.Screens.Play;
 using osu.Game.Users;
+using osuTK.Graphics;
+using osuTK.Input;
 
 namespace osu.Game.Screens.Edit
 {
     [Cached(typeof(IBeatSnapProvider))]
-    public class Editor : ScreenWithBeatmapBackground, IKeyBindingHandler<GlobalAction>, IKeyBindingHandler<PlatformAction>, IBeatSnapProvider
+    [Cached(typeof(ISamplePlaybackDisabler))]
+    [Cached]
+    public class Editor : ScreenWithBeatmapBackground, IKeyBindingHandler<GlobalAction>, IKeyBindingHandler<PlatformAction>, IBeatSnapProvider, ISamplePlaybackDisabler
     {
         public override float BackgroundParallaxAmount => 0.1f;
 
@@ -50,11 +58,24 @@ namespace osu.Game.Screens.Edit
 
         public override bool AllowRateAdjustments => false;
 
+        protected bool HasUnsavedChanges => lastSavedHash != changeHandler.CurrentStateHash;
+
         [Resolved]
         private BeatmapManager beatmapManager { get; set; }
 
+        [Resolved(canBeNull: true)]
+        private DialogOverlay dialogOverlay { get; set; }
+
+        public IBindable<bool> SamplePlaybackDisabled => samplePlaybackDisabled;
+
+        private readonly Bindable<bool> samplePlaybackDisabled = new Bindable<bool>();
+
+        private bool exitConfirmed;
+
+        private string lastSavedHash;
+
         private Box bottomBackground;
-        private Container screenContainer;
+        private Container<EditorScreen> screenContainer;
 
         private EditorScreen currentScreen;
 
@@ -65,30 +86,48 @@ namespace osu.Game.Screens.Edit
         private EditorBeatmap editorBeatmap;
         private EditorChangeHandler changeHandler;
 
+        private EditorMenuBar menuBar;
+
         private DependencyContainer dependencies;
 
+        private bool isNewBeatmap;
+
         protected override UserActivity InitialActivity => new UserActivity.Editing(Beatmap.Value.BeatmapInfo);
 
         protected override IReadOnlyDependencyContainer CreateChildDependencies(IReadOnlyDependencyContainer parent)
             => dependencies = new DependencyContainer(base.CreateChildDependencies(parent));
 
+        [Resolved]
+        private IAPIProvider api { get; set; }
+
+        [Resolved]
+        private MusicController music { get; set; }
+
         [BackgroundDependencyLoader]
-        private void load(OsuColour colours, GameHost host)
+        private void load(OsuColour colours, GameHost host, OsuConfigManager config)
         {
             beatDivisor.Value = Beatmap.Value.BeatmapInfo.BeatDivisor;
             beatDivisor.BindValueChanged(divisor => Beatmap.Value.BeatmapInfo.BeatDivisor = divisor.NewValue);
 
             // Todo: should probably be done at a DrawableRuleset level to share logic with Player.
-            var sourceClock = (IAdjustableClock)Beatmap.Value.Track ?? new StopwatchClock();
             clock = new EditorClock(Beatmap.Value, beatDivisor) { IsCoupled = false };
-            clock.ChangeSource(sourceClock);
+
+            UpdateClockSource();
 
             dependencies.CacheAs(clock);
             AddInternal(clock);
 
+            clock.SeekingOrStopped.BindValueChanged(_ => updateSampleDisabledState());
+
             // todo: remove caching of this and consume via editorBeatmap?
             dependencies.Cache(beatDivisor);
 
+            if (Beatmap.Value is DummyWorkingBeatmap)
+            {
+                isNewBeatmap = true;
+                Beatmap.Value = beatmapManager.CreateNew(Ruleset.Value, api.LocalUser.Value);
+            }
+
             try
             {
                 playableBeatmap = Beatmap.Value.GetPlayableBeatmap(Beatmap.Value.BeatmapInfo.Ruleset);
@@ -101,19 +140,23 @@ namespace osu.Game.Screens.Edit
                 return;
             }
 
-            AddInternal(editorBeatmap = new EditorBeatmap(playableBeatmap));
+            AddInternal(editorBeatmap = new EditorBeatmap(playableBeatmap, Beatmap.Value.Skin));
             dependencies.CacheAs(editorBeatmap);
-
             changeHandler = new EditorChangeHandler(editorBeatmap);
             dependencies.CacheAs<IEditorChangeHandler>(changeHandler);
 
-            EditorMenuBar menuBar;
+            updateLastSavedHash();
+
             OsuMenuItem undoMenuItem;
             OsuMenuItem redoMenuItem;
 
+            EditorMenuItem cutMenuItem;
+            EditorMenuItem copyMenuItem;
+            EditorMenuItem pasteMenuItem;
+
             var fileMenuItems = new List<MenuItem>
             {
-                new EditorMenuItem("Save", MenuItemType.Standard, saveBeatmap)
+                new EditorMenuItem("Save", MenuItemType.Standard, Save)
             };
 
             if (RuntimeInfo.IsDesktop)
@@ -132,7 +175,7 @@ namespace osu.Game.Screens.Edit
                         Name = "Screen container",
                         RelativeSizeAxes = Axes.Both,
                         Padding = new MarginPadding { Top = 40, Bottom = 60 },
-                        Child = screenContainer = new Container
+                        Child = screenContainer = new Container<EditorScreen>
                         {
                             RelativeSizeAxes = Axes.Both,
                             Masking = true
@@ -148,6 +191,7 @@ namespace osu.Game.Screens.Edit
                             Anchor = Anchor.CentreLeft,
                             Origin = Anchor.CentreLeft,
                             RelativeSizeAxes = Axes.Both,
+                            Mode = { Value = isNewBeatmap ? EditorScreenMode.SongSetup : EditorScreenMode.Compose },
                             Items = new[]
                             {
                                 new MenuItem("File")
@@ -159,7 +203,18 @@ namespace osu.Game.Screens.Edit
                                     Items = new[]
                                     {
                                         undoMenuItem = new EditorMenuItem("Undo", MenuItemType.Standard, Undo),
-                                        redoMenuItem = new EditorMenuItem("Redo", MenuItemType.Standard, Redo)
+                                        redoMenuItem = new EditorMenuItem("Redo", MenuItemType.Standard, Redo),
+                                        new EditorMenuItemSpacer(),
+                                        cutMenuItem = new EditorMenuItem("Cut", MenuItemType.Standard, Cut),
+                                        copyMenuItem = new EditorMenuItem("Copy", MenuItemType.Standard, Copy),
+                                        pasteMenuItem = new EditorMenuItem("Paste", MenuItemType.Standard, Paste),
+                                    }
+                                },
+                                new MenuItem("View")
+                                {
+                                    Items = new[]
+                                    {
+                                        new WaveformOpacityMenu(config)
                                     }
                                 }
                             }
@@ -220,11 +275,44 @@ namespace osu.Game.Screens.Edit
             changeHandler.CanUndo.BindValueChanged(v => undoMenuItem.Action.Disabled = !v.NewValue, true);
             changeHandler.CanRedo.BindValueChanged(v => redoMenuItem.Action.Disabled = !v.NewValue, true);
 
+            editorBeatmap.SelectedHitObjects.BindCollectionChanged((_, __) =>
+            {
+                var hasObjects = editorBeatmap.SelectedHitObjects.Count > 0;
+
+                cutMenuItem.Action.Disabled = !hasObjects;
+                copyMenuItem.Action.Disabled = !hasObjects;
+            }, true);
+
+            clipboard.BindValueChanged(content => pasteMenuItem.Action.Disabled = string.IsNullOrEmpty(content.NewValue));
+
             menuBar.Mode.ValueChanged += onModeChanged;
 
             bottomBackground.Colour = colours.Gray2;
         }
 
+        /// <summary>
+        /// If the beatmap's track has changed, this method must be called to keep the editor in a valid state.
+        /// </summary>
+        public void UpdateClockSource()
+        {
+            var sourceClock = (IAdjustableClock)Beatmap.Value.Track ?? new StopwatchClock();
+            clock.ChangeSource(sourceClock);
+        }
+
+        protected void Save()
+        {
+            // no longer new after first user-triggered save.
+            isNewBeatmap = false;
+
+            // apply any set-level metadata changes.
+            beatmapManager.Update(playableBeatmap.BeatmapInfo.BeatmapSet);
+
+            // save the loaded beatmap's data stream.
+            beatmapManager.Save(playableBeatmap.BeatmapInfo, editorBeatmap, editorBeatmap.BeatmapSkin);
+
+            updateLastSavedHash();
+        }
+
         protected override void Update()
         {
             base.Update();
@@ -235,6 +323,18 @@ namespace osu.Game.Screens.Edit
         {
             switch (action.ActionType)
             {
+                case PlatformActionType.Cut:
+                    Cut();
+                    return true;
+
+                case PlatformActionType.Copy:
+                    Copy();
+                    return true;
+
+                case PlatformActionType.Paste:
+                    Paste();
+                    return true;
+
                 case PlatformActionType.Undo:
                     Undo();
                     return true;
@@ -244,7 +344,7 @@ namespace osu.Game.Screens.Edit
                     return true;
 
                 case PlatformActionType.Save:
-                    saveBeatmap();
+                    Save();
                     return true;
             }
 
@@ -275,11 +375,22 @@ namespace osu.Game.Screens.Edit
 
         protected override bool OnScroll(ScrollEvent e)
         {
-            scrollAccumulation += (e.ScrollDelta.X + e.ScrollDelta.Y) * (e.IsPrecise ? 0.1 : 1);
+            const double precision = 1;
 
-            const int precision = 1;
+            double scrollComponent = e.ScrollDelta.X + e.ScrollDelta.Y;
 
-            while (Math.Abs(scrollAccumulation) > precision)
+            double scrollDirection = Math.Sign(scrollComponent);
+
+            // this is a special case to handle the "pivot" scenario.
+            // if we are precise scrolling in one direction then change our mind and scroll backwards,
+            // the existing accumulation should be applied in the inverse direction to maintain responsiveness.
+            if (scrollAccumulation != 0 && Math.Sign(scrollAccumulation) != scrollDirection)
+                scrollAccumulation = scrollDirection * (precision - Math.Abs(scrollAccumulation));
+
+            scrollAccumulation += scrollComponent * (e.IsPrecise ? 0.1 : 1);
+
+            // because we are doing snapped seeking, we need to add up precise scrolls until they accumulate to an arbitrary cut-off.
+            while (Math.Abs(scrollAccumulation) >= precision)
             {
                 if (scrollAccumulation > 0)
                     seek(e, -1);
@@ -294,14 +405,32 @@ namespace osu.Game.Screens.Edit
 
         public bool OnPressed(GlobalAction action)
         {
-            if (action == GlobalAction.Back)
+            switch (action)
             {
-                // as we don't want to display the back button, manual handling of exit action is required.
-                this.Exit();
-                return true;
-            }
+                case GlobalAction.Back:
+                    // as we don't want to display the back button, manual handling of exit action is required.
+                    this.Exit();
+                    return true;
 
-            return false;
+                case GlobalAction.EditorComposeMode:
+                    menuBar.Mode.Value = EditorScreenMode.Compose;
+                    return true;
+
+                case GlobalAction.EditorDesignMode:
+                    menuBar.Mode.Value = EditorScreenMode.Design;
+                    return true;
+
+                case GlobalAction.EditorTimingMode:
+                    menuBar.Mode.Value = EditorScreenMode.Timing;
+                    return true;
+
+                case GlobalAction.EditorSetupMode:
+                    menuBar.Mode.Value = EditorScreenMode.SongSetup;
+                    return true;
+
+                default:
+                    return false;
+            }
         }
 
         public void OnReleased(GlobalAction action)
@@ -323,12 +452,104 @@ namespace osu.Game.Screens.Edit
 
         public override bool OnExiting(IScreen next)
         {
+            if (!exitConfirmed)
+            {
+                // if the confirm dialog is already showing (or we can't show it, ie. in tests) exit without save.
+                if (dialogOverlay == null || dialogOverlay.CurrentDialog is PromptForSaveDialog)
+                {
+                    confirmExit();
+                    return false;
+                }
+
+                if (isNewBeatmap || HasUnsavedChanges)
+                {
+                    dialogOverlay?.Push(new PromptForSaveDialog(() =>
+                    {
+                        confirmExit();
+                        this.Exit();
+                    }, () =>
+                    {
+                        confirmExitWithSave();
+                        this.Exit();
+                    }));
+
+                    return true;
+                }
+            }
+
             Background.FadeColour(Color4.White, 500);
             resetTrack();
 
             return base.OnExiting(next);
         }
 
+        private void confirmExitWithSave()
+        {
+            exitConfirmed = true;
+            Save();
+        }
+
+        private void confirmExit()
+        {
+            // stop the track if playing to allow the parent screen to choose a suitable playback mode.
+            Beatmap.Value.Track.Stop();
+
+            if (isNewBeatmap)
+            {
+                // confirming exit without save means we should delete the new beatmap completely.
+                beatmapManager.Delete(playableBeatmap.BeatmapInfo.BeatmapSet);
+
+                // eagerly clear contents before restoring default beatmap to prevent value change callbacks from firing.
+                ClearInternal();
+
+                // in theory this shouldn't be required but due to EF core not sharing instance states 100%
+                // MusicController is unaware of the changed DeletePending state.
+                Beatmap.SetDefault();
+            }
+
+            exitConfirmed = true;
+        }
+
+        private readonly Bindable<string> clipboard = new Bindable<string>();
+
+        protected void Cut()
+        {
+            Copy();
+            editorBeatmap.RemoveRange(editorBeatmap.SelectedHitObjects.ToArray());
+        }
+
+        protected void Copy()
+        {
+            if (editorBeatmap.SelectedHitObjects.Count == 0)
+                return;
+
+            clipboard.Value = new ClipboardContent(editorBeatmap).Serialize();
+        }
+
+        protected void Paste()
+        {
+            if (string.IsNullOrEmpty(clipboard.Value))
+                return;
+
+            var objects = clipboard.Value.Deserialize<ClipboardContent>().HitObjects;
+
+            Debug.Assert(objects.Any());
+
+            double timeOffset = clock.CurrentTime - objects.Min(o => o.StartTime);
+
+            foreach (var h in objects)
+                h.StartTime += timeOffset;
+
+            editorBeatmap.BeginChange();
+
+            editorBeatmap.SelectedHitObjects.Clear();
+
+            editorBeatmap.AddRange(objects);
+            editorBeatmap.SelectedHitObjects.AddRange(objects);
+
+            editorBeatmap.EndChange();
+        }
+
         protected void Undo() => changeHandler.RestoreState(-1);
 
         protected void Redo() => changeHandler.RestoreState(1);
@@ -354,48 +575,91 @@ namespace osu.Game.Screens.Edit
 
         private void onModeChanged(ValueChangedEvent<EditorScreenMode> e)
         {
-            currentScreen?.Exit();
+            var lastScreen = currentScreen;
 
-            switch (e.NewValue)
+            lastScreen?
+                .ScaleTo(0.98f, 200, Easing.OutQuint)
+                .FadeOut(200, Easing.OutQuint);
+
+            try
             {
-                case EditorScreenMode.SongSetup:
-                    currentScreen = new SetupScreen();
-                    break;
+                if ((currentScreen = screenContainer.SingleOrDefault(s => s.Type == e.NewValue)) != null)
+                {
+                    screenContainer.ChangeChildDepth(currentScreen, lastScreen?.Depth + 1 ?? 0);
 
-                case EditorScreenMode.Compose:
-                    currentScreen = new ComposeScreen();
-                    break;
+                    currentScreen
+                        .ScaleTo(1, 200, Easing.OutQuint)
+                        .FadeIn(200, Easing.OutQuint);
+                    return;
+                }
 
-                case EditorScreenMode.Design:
-                    currentScreen = new DesignScreen();
-                    break;
+                switch (e.NewValue)
+                {
+                    case EditorScreenMode.SongSetup:
+                        currentScreen = new SetupScreen();
+                        break;
 
-                case EditorScreenMode.Timing:
-                    currentScreen = new TimingScreen();
-                    break;
+                    case EditorScreenMode.Compose:
+                        currentScreen = new ComposeScreen();
+                        break;
+
+                    case EditorScreenMode.Design:
+                        currentScreen = new DesignScreen();
+                        break;
+
+                    case EditorScreenMode.Timing:
+                        currentScreen = new TimingScreen();
+                        break;
+                }
+
+                LoadComponentAsync(currentScreen, newScreen =>
+                {
+                    if (newScreen == currentScreen)
+                        screenContainer.Add(newScreen);
+                });
             }
+            finally
+            {
+                updateSampleDisabledState();
+            }
+        }
 
-            LoadComponentAsync(currentScreen, screenContainer.Add);
+        private void updateSampleDisabledState()
+        {
+            samplePlaybackDisabled.Value = clock.SeekingOrStopped.Value || !(currentScreen is ComposeScreen);
         }
 
         private void seek(UIEvent e, int direction)
         {
-            double amount = e.ShiftPressed ? 2 : 1;
+            double amount = e.ShiftPressed ? 4 : 1;
+
+            bool trackPlaying = clock.IsRunning;
+
+            if (trackPlaying)
+            {
+                // generally users are not looking to perform tiny seeks when the track is playing,
+                // so seeks should always be by one full beat, bypassing the beatDivisor.
+                // this multiplication undoes the division that will be applied in the underlying seek operation.
+                amount *= beatDivisor.Value;
+            }
 
             if (direction < 1)
-                clock.SeekBackward(!clock.IsRunning, amount);
+                clock.SeekBackward(!trackPlaying, amount);
             else
-                clock.SeekForward(!clock.IsRunning, amount);
+                clock.SeekForward(!trackPlaying, amount);
         }
 
-        private void saveBeatmap() => beatmapManager.Save(playableBeatmap.BeatmapInfo, editorBeatmap);
-
         private void exportBeatmap()
         {
-            saveBeatmap();
+            Save();
             beatmapManager.Export(Beatmap.Value.BeatmapSetInfo);
         }
 
+        private void updateLastSavedHash()
+        {
+            lastSavedHash = changeHandler.CurrentStateHash;
+        }
+
         public double SnapTime(double time, double? referenceTime) => editorBeatmap.SnapTime(time, referenceTime);
 
         public double GetBeatLengthAtTime(double referenceTime) => editorBeatmap.GetBeatLengthAtTime(referenceTime);

osu.Game/Screens/Edit/EditorBeatmap.cs

@@ -8,17 +8,16 @@ using System.Linq;
 using JetBrains.Annotations;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
-using osu.Framework.Graphics;
-using osu.Framework.Threading;
 using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Beatmaps.Timing;
 using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Objects;
+using osu.Game.Skinning;
 
 namespace osu.Game.Screens.Edit
 {
-    public class EditorBeatmap : Component, IBeatmap, IBeatSnapProvider
+    public class EditorBeatmap : TransactionalCommitComponent, IBeatmap, IBeatSnapProvider
     {
         /// <summary>
         /// Invoked when a <see cref="HitObject"/> is added to this <see cref="EditorBeatmap"/>.
@@ -47,6 +46,8 @@ namespace osu.Game.Screens.Edit
 
         public readonly IBeatmap PlayableBeatmap;
 
+        public readonly ISkin BeatmapSkin;
+
         [Resolved]
         private BindableBeatDivisor beatDivisor { get; set; }
 
@@ -54,9 +55,10 @@ namespace osu.Game.Screens.Edit
 
         private readonly Dictionary<HitObject, Bindable<double>> startTimeBindables = new Dictionary<HitObject, Bindable<double>>();
 
-        public EditorBeatmap(IBeatmap playableBeatmap)
+        public EditorBeatmap(IBeatmap playableBeatmap, ISkin beatmapSkin = null)
         {
             PlayableBeatmap = playableBeatmap;
+            BeatmapSkin = beatmapSkin;
 
             beatmapProcessor = playableBeatmap.BeatmapInfo.Ruleset?.CreateInstance().CreateBeatmapProcessor(PlayableBeatmap);
 
@@ -64,41 +66,6 @@ namespace osu.Game.Screens.Edit
                 trackStartTime(obj);
         }
 
-        private readonly HashSet<HitObject> pendingUpdates = new HashSet<HitObject>();
-        private ScheduledDelegate scheduledUpdate;
-
-        /// <summary>
-        /// Updates a <see cref="HitObject"/>, invoking <see cref="HitObject.ApplyDefaults"/> and re-processing the beatmap.
-        /// </summary>
-        /// <param name="hitObject">The <see cref="HitObject"/> to update.</param>
-        public void UpdateHitObject([NotNull] HitObject hitObject) => updateHitObject(hitObject, false);
-
-        private void updateHitObject([CanBeNull] HitObject hitObject, bool silent)
-        {
-            scheduledUpdate?.Cancel();
-
-            if (hitObject != null)
-                pendingUpdates.Add(hitObject);
-
-            scheduledUpdate = Schedule(() =>
-            {
-                beatmapProcessor?.PreProcess();
-
-                foreach (var obj in pendingUpdates)
-                    obj.ApplyDefaults(ControlPointInfo, BeatmapInfo.BaseDifficulty);
-
-                beatmapProcessor?.PostProcess();
-
-                if (!silent)
-                {
-                    foreach (var obj in pendingUpdates)
-                        HitObjectUpdated?.Invoke(obj);
-                }
-
-                pendingUpdates.Clear();
-            });
-        }
-
         public BeatmapInfo BeatmapInfo
         {
             get => PlayableBeatmap.BeatmapInfo;
@@ -121,14 +88,22 @@ namespace osu.Game.Screens.Edit
 
         private IList mutableHitObjects => (IList)PlayableBeatmap.HitObjects;
 
+        private readonly List<HitObject> batchPendingInserts = new List<HitObject>();
+
+        private readonly List<HitObject> batchPendingDeletes = new List<HitObject>();
+
+        private readonly HashSet<HitObject> batchPendingUpdates = new HashSet<HitObject>();
+
         /// <summary>
         /// Adds a collection of <see cref="HitObject"/>s to this <see cref="EditorBeatmap"/>.
         /// </summary>
         /// <param name="hitObjects">The <see cref="HitObject"/>s to add.</param>
         public void AddRange(IEnumerable<HitObject> hitObjects)
         {
+            BeginChange();
             foreach (var h in hitObjects)
                 Add(h);
+            EndChange();
         }
 
         /// <summary>
@@ -156,14 +131,34 @@ namespace osu.Game.Screens.Edit
 
             mutableHitObjects.Insert(index, hitObject);
 
-            HitObjectAdded?.Invoke(hitObject);
-            updateHitObject(hitObject, true);
+            BeginChange();
+            batchPendingInserts.Add(hitObject);
+            EndChange();
+        }
+
+        /// <summary>
+        /// Updates a <see cref="HitObject"/>, invoking <see cref="HitObject.ApplyDefaults"/> and re-processing the beatmap.
+        /// </summary>
+        /// <param name="hitObject">The <see cref="HitObject"/> to update.</param>
+        public void Update([NotNull] HitObject hitObject)
+        {
+            // updates are debounced regardless of whether a batch is active.
+            batchPendingUpdates.Add(hitObject);
+        }
+
+        /// <summary>
+        /// Update all hit objects with potentially changed difficulty or control point data.
+        /// </summary>
+        public void UpdateAllHitObjects()
+        {
+            foreach (var h in HitObjects)
+                batchPendingUpdates.Add(h);
         }
 
         /// <summary>
         /// Removes a <see cref="HitObject"/> from this <see cref="EditorBeatmap"/>.
         /// </summary>
-        /// <param name="hitObject">The <see cref="HitObject"/> to add.</param>
+        /// <param name="hitObject">The <see cref="HitObject"/> to remove.</param>
         /// <returns>True if the <see cref="HitObject"/> has been removed, false otherwise.</returns>
         public bool Remove(HitObject hitObject)
         {
@@ -176,6 +171,18 @@ namespace osu.Game.Screens.Edit
             return true;
         }
 
+        /// <summary>
+        /// Removes a collection of <see cref="HitObject"/>s to this <see cref="EditorBeatmap"/>.
+        /// </summary>
+        /// <param name="hitObjects">The <see cref="HitObject"/>s to remove.</param>
+        public void RemoveRange(IEnumerable<HitObject> hitObjects)
+        {
+            BeginChange();
+            foreach (var h in hitObjects)
+                Remove(h);
+            EndChange();
+        }
+
         /// <summary>
         /// Finds the index of a <see cref="HitObject"/> in this <see cref="EditorBeatmap"/>.
         /// </summary>
@@ -195,31 +202,55 @@ namespace osu.Game.Screens.Edit
 
             var bindable = startTimeBindables[hitObject];
             bindable.UnbindAll();
-
             startTimeBindables.Remove(hitObject);
-            HitObjectRemoved?.Invoke(hitObject);
 
-            updateHitObject(null, true);
+            BeginChange();
+            batchPendingDeletes.Add(hitObject);
+            EndChange();
+        }
+
+        protected override void Update()
+        {
+            base.Update();
+
+            if (batchPendingUpdates.Count > 0)
+                UpdateState();
+        }
+
+        protected override void UpdateState()
+        {
+            if (batchPendingUpdates.Count == 0 && batchPendingDeletes.Count == 0 && batchPendingInserts.Count == 0)
+                return;
+
+            beatmapProcessor?.PreProcess();
+
+            foreach (var h in batchPendingDeletes) processHitObject(h);
+            foreach (var h in batchPendingInserts) processHitObject(h);
+            foreach (var h in batchPendingUpdates) processHitObject(h);
+
+            beatmapProcessor?.PostProcess();
+
+            // callbacks may modify the lists so let's be safe about it
+            var deletes = batchPendingDeletes.ToArray();
+            batchPendingDeletes.Clear();
+
+            var inserts = batchPendingInserts.ToArray();
+            batchPendingInserts.Clear();
+
+            var updates = batchPendingUpdates.ToArray();
+            batchPendingUpdates.Clear();
+
+            foreach (var h in deletes) HitObjectRemoved?.Invoke(h);
+            foreach (var h in inserts) HitObjectAdded?.Invoke(h);
+            foreach (var h in updates) HitObjectUpdated?.Invoke(h);
         }
 
         /// <summary>
         /// Clears all <see cref="HitObjects"/> from this <see cref="EditorBeatmap"/>.
         /// </summary>
-        public void Clear()
-        {
-            var removed = HitObjects.ToList();
+        public void Clear() => RemoveRange(HitObjects.ToArray());
 
-            mutableHitObjects.Clear();
-
-            foreach (var b in startTimeBindables)
-                b.Value.UnbindAll();
-            startTimeBindables.Clear();
-
-            foreach (var h in removed)
-                HitObjectRemoved?.Invoke(h);
-
-            updateHitObject(null, true);
-        }
+        private void processHitObject(HitObject hitObject) => hitObject.ApplyDefaults(ControlPointInfo, BeatmapInfo.BaseDifficulty);
 
         private void trackStartTime(HitObject hitObject)
         {
@@ -232,7 +263,7 @@ namespace osu.Game.Screens.Edit
                 var insertionIndex = findInsertionIndex(PlayableBeatmap.HitObjects, hitObject.StartTime);
                 mutableHitObjects.Insert(insertionIndex + 1, hitObject);
 
-                UpdateHitObject(hitObject);
+                Update(hitObject);
             };
         }
 

osu.Game/Screens/Edit/EditorChangeHandler.cs

@@ -4,8 +4,10 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
+using System.Linq;
 using System.Text;
 using osu.Framework.Bindables;
+using osu.Framework.Extensions;
 using osu.Game.Beatmaps.Formats;
 using osu.Game.Rulesets.Objects;
 
@@ -14,18 +16,31 @@ namespace osu.Game.Screens.Edit
     /// <summary>
     /// Tracks changes to the <see cref="Editor"/>.
     /// </summary>
-    public class EditorChangeHandler : IEditorChangeHandler
+    public class EditorChangeHandler : TransactionalCommitComponent, IEditorChangeHandler
     {
         public readonly Bindable<bool> CanUndo = new Bindable<bool>();
         public readonly Bindable<bool> CanRedo = new Bindable<bool>();
 
+        public event Action OnStateChange;
+
         private readonly LegacyEditorBeatmapPatcher patcher;
         private readonly List<byte[]> savedStates = new List<byte[]>();
 
         private int currentState = -1;
 
+        /// <summary>
+        /// A SHA-2 hash representing the current visible editor state.
+        /// </summary>
+        public string CurrentStateHash
+        {
+            get
+            {
+                using (var stream = new MemoryStream(savedStates[currentState]))
+                    return stream.ComputeSHA2Hash();
+            }
+        }
+
         private readonly EditorBeatmap editorBeatmap;
-        private int bulkChangesStarted;
         private bool isRestoring;
 
         public const int MAX_SAVED_STATES = 50;
@@ -38,9 +53,9 @@ namespace osu.Game.Screens.Edit
         {
             this.editorBeatmap = editorBeatmap;
 
-            editorBeatmap.HitObjectAdded += hitObjectAdded;
-            editorBeatmap.HitObjectRemoved += hitObjectRemoved;
-            editorBeatmap.HitObjectUpdated += hitObjectUpdated;
+            editorBeatmap.TransactionBegan += BeginChange;
+            editorBeatmap.TransactionEnded += EndChange;
+            editorBeatmap.SaveStateTriggered += SaveState;
 
             patcher = new LegacyEditorBeatmapPatcher(editorBeatmap);
 
@@ -48,51 +63,34 @@ namespace osu.Game.Screens.Edit
             SaveState();
         }
 
-        private void hitObjectAdded(HitObject obj) => SaveState();
-
-        private void hitObjectRemoved(HitObject obj) => SaveState();
-
-        private void hitObjectUpdated(HitObject obj) => SaveState();
-
-        public void BeginChange() => bulkChangesStarted++;
-
-        public void EndChange()
+        protected override void UpdateState()
         {
-            if (bulkChangesStarted == 0)
-                throw new InvalidOperationException($"Cannot call {nameof(EndChange)} without a previous call to {nameof(BeginChange)}.");
-
-            if (--bulkChangesStarted == 0)
-                SaveState();
-        }
-
-        /// <summary>
-        /// Saves the current <see cref="Editor"/> state.
-        /// </summary>
-        public void SaveState()
-        {
-            if (bulkChangesStarted > 0)
-                return;
-
             if (isRestoring)
                 return;
 
-            if (currentState < savedStates.Count - 1)
-                savedStates.RemoveRange(currentState + 1, savedStates.Count - currentState - 1);
-
-            if (savedStates.Count > MAX_SAVED_STATES)
-                savedStates.RemoveAt(0);
-
             using (var stream = new MemoryStream())
             {
                 using (var sw = new StreamWriter(stream, Encoding.UTF8, 1024, true))
-                    new LegacyBeatmapEncoder(editorBeatmap).Encode(sw);
+                    new LegacyBeatmapEncoder(editorBeatmap, editorBeatmap.BeatmapSkin).Encode(sw);
 
-                savedStates.Add(stream.ToArray());
+                var newState = stream.ToArray();
+
+                // if the previous state is binary equal we don't need to push a new one, unless this is the initial state.
+                if (savedStates.Count > 0 && newState.SequenceEqual(savedStates.Last())) return;
+
+                if (currentState < savedStates.Count - 1)
+                    savedStates.RemoveRange(currentState + 1, savedStates.Count - currentState - 1);
+
+                if (savedStates.Count > MAX_SAVED_STATES)
+                    savedStates.RemoveAt(0);
+
+                savedStates.Add(newState);
+
+                currentState = savedStates.Count - 1;
+
+                OnStateChange?.Invoke();
+                updateBindables();
             }
-
-            currentState = savedStates.Count - 1;
-
-            updateBindables();
         }
 
         /// <summary>
@@ -101,7 +99,7 @@ namespace osu.Game.Screens.Edit
         /// <param name="direction">The direction to restore in. If less than 0, an older state will be used. If greater than 0, a newer state will be used.</param>
         public void RestoreState(int direction)
         {
-            if (bulkChangesStarted > 0)
+            if (TransactionActive)
                 return;
 
             if (savedStates.Count == 0)
@@ -118,6 +116,7 @@ namespace osu.Game.Screens.Edit
 
             isRestoring = false;
 
+            OnStateChange?.Invoke();
             updateBindables();
         }
 

osu.Game/Screens/Edit/EditorClock.cs

@@ -3,10 +3,12 @@
 
 using System;
 using System.Linq;
+using osu.Framework.Audio.Track;
+using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Transforms;
-using osu.Framework.Utils;
 using osu.Framework.Timing;
+using osu.Framework.Utils;
 using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.ControlPoints;
 
@@ -17,7 +19,11 @@ namespace osu.Game.Screens.Edit
     /// </summary>
     public class EditorClock : Component, IFrameBasedClock, IAdjustableClock, ISourceChangeableClock
     {
-        public readonly double TrackLength;
+        public IBindable<Track> Track => track;
+
+        private readonly Bindable<Track> track = new Bindable<Track>();
+
+        public double TrackLength => track.Value?.Length ?? 60000;
 
         public ControlPointInfo ControlPointInfo;
 
@@ -25,6 +31,10 @@ namespace osu.Game.Screens.Edit
 
         private readonly DecoupleableInterpolatingFramedClock underlyingClock;
 
+        public IBindable<bool> SeekingOrStopped => seekingOrStopped;
+
+        private readonly Bindable<bool> seekingOrStopped = new Bindable<bool>(true);
+
         public EditorClock(WorkingBeatmap beatmap, BindableBeatDivisor beatDivisor)
             : this(beatmap.Beatmap.ControlPointInfo, beatmap.Track.Length, beatDivisor)
         {
@@ -35,7 +45,6 @@ namespace osu.Game.Screens.Edit
             this.beatDivisor = beatDivisor;
 
             ControlPointInfo = controlPointInfo;
-            TrackLength = trackLength;
 
             underlyingClock = new DecoupleableInterpolatingFramedClock();
         }
@@ -76,7 +85,7 @@ namespace osu.Game.Screens.Edit
         /// </summary>
         /// <param name="snapped">Whether to snap to the closest beat after seeking.</param>
         /// <param name="amount">The relative amount (magnitude) which should be seeked.</param>
-        public void SeekBackward(bool snapped = false, double amount = 1) => seek(-1, snapped, amount);
+        public void SeekBackward(bool snapped = false, double amount = 1) => seek(-1, snapped, amount + (IsRunning ? 1.5 : 0));
 
         /// <summary>
         /// Seeks forwards by one beat length.
@@ -118,9 +127,14 @@ namespace osu.Game.Screens.Edit
 
             seekTime = timingPoint.Time + closestBeat * seekAmount;
 
+            // limit forward seeking to only up to the next timing point's start time.
+            var nextTimingPoint = ControlPointInfo.TimingPoints.FirstOrDefault(t => t.Time > timingPoint.Time);
+            if (seekTime > nextTimingPoint?.Time)
+                seekTime = nextTimingPoint.Time;
+
             // Due to the rounding above, we may end up on the current beat. This will effectively cause 0 seeking to happen, but we don't want this.
             // Instead, we'll go to the next beat in the direction when this is the case
-            if (Precision.AlmostEquals(current, seekTime))
+            if (Precision.AlmostEquals(current, seekTime, 0.5f))
             {
                 closestBeat += direction > 0 ? 1 : -1;
                 seekTime = timingPoint.Time + closestBeat * seekAmount;
@@ -129,10 +143,6 @@ namespace osu.Game.Screens.Edit
             if (seekTime < timingPoint.Time && timingPoint != ControlPointInfo.TimingPoints.First())
                 seekTime = timingPoint.Time;
 
-            var nextTimingPoint = ControlPointInfo.TimingPoints.FirstOrDefault(t => t.Time > timingPoint.Time);
-            if (seekTime > nextTimingPoint?.Time)
-                seekTime = nextTimingPoint.Time;
-
             // Ensure the sought point is within the boundaries
             seekTime = Math.Clamp(seekTime, 0, TrackLength);
             SeekTo(seekTime);
@@ -160,11 +170,14 @@ namespace osu.Game.Screens.Edit
 
         public void Stop()
         {
+            seekingOrStopped.Value = true;
             underlyingClock.Stop();
         }
 
         public bool Seek(double position)
         {
+            seekingOrStopped.Value = true;
+
             ClearTransforms();
             return underlyingClock.Seek(position);
         }
@@ -189,7 +202,11 @@ namespace osu.Game.Screens.Edit
 
         public FrameTimeInfo TimeInfo => underlyingClock.TimeInfo;
 
-        public void ChangeSource(IClock source) => underlyingClock.ChangeSource(source);
+        public void ChangeSource(IClock source)
+        {
+            track.Value = source as Track;
+            underlyingClock.ChangeSource(source);
+        }
 
         public IClock Source => underlyingClock.Source;
 
@@ -201,8 +218,35 @@ namespace osu.Game.Screens.Edit
 
         private const double transform_time = 300;
 
+        protected override void Update()
+        {
+            base.Update();
+
+            updateSeekingState();
+        }
+
+        private void updateSeekingState()
+        {
+            if (seekingOrStopped.Value)
+            {
+                if (track.Value?.IsRunning != true)
+                {
+                    // seeking in the editor can happen while the track isn't running.
+                    // in this case we always want to expose ourselves as seeking (to avoid sample playback).
+                    return;
+                }
+
+                // we are either running a seek tween or doing an immediate seek.
+                // in the case of an immediate seek the seeking bool will be set to false after one update.
+                // this allows for silencing hit sounds and the likes.
+                seekingOrStopped.Value = Transforms.Any();
+            }
+        }
+
         public void SeekTo(double seekDestination)
         {
+            seekingOrStopped.Value = true;
+
             if (IsRunning)
                 Seek(seekDestination);
             else
@@ -222,8 +266,15 @@ namespace osu.Game.Screens.Edit
         {
             public override string TargetMember => nameof(currentTime);
 
-            protected override void Apply(EditorClock clock, double time) =>
-                clock.currentTime = Interpolation.ValueAt(time, StartValue, EndValue, StartTime, EndTime, Easing);
+            protected override void Apply(EditorClock clock, double time) => clock.currentTime = valueAt(time);
+
+            private double valueAt(double time)
+            {
+                if (time < StartTime) return StartValue;
+                if (time >= EndTime) return EndValue;
+
+                return Interpolation.ValueAt(time, StartValue, EndValue, StartTime, EndTime, Easing);
+            }
 
             protected override void ReadIntoStartValue(EditorClock clock) => StartValue = clock.currentTime;
         }

osu.Game/Screens/Edit/EditorScreen.cs

@@ -23,8 +23,12 @@ namespace osu.Game.Screens.Edit
         protected override Container<Drawable> Content => content;
         private readonly Container content;
 
-        protected EditorScreen()
+        public readonly EditorScreenMode Type;
+
+        protected EditorScreen(EditorScreenMode type)
         {
+            Type = type;
+
             Anchor = Anchor.Centre;
             Origin = Anchor.Centre;
             RelativeSizeAxes = Axes.Both;
@@ -40,10 +44,5 @@ namespace osu.Game.Screens.Edit
                 .Then()
                 .FadeTo(1f, 250, Easing.OutQuint);
         }
-
-        public void Exit()
-        {
-            this.FadeOut(250).Expire();
-        }
     }
 }

osu.Game/Screens/Edit/EditorScreenWithTimeline.cs

@@ -7,6 +7,7 @@ using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
+using osu.Game.Graphics.UserInterface;
 using osu.Game.Screens.Edit.Compose.Components;
 using osu.Game.Screens.Edit.Compose.Components.Timeline;
 using osuTK.Graphics;
@@ -24,6 +25,11 @@ namespace osu.Game.Screens.Edit
 
         private Container timelineContainer;
 
+        protected EditorScreenWithTimeline(EditorScreenMode type)
+            : base(type)
+        {
+        }
+
         [BackgroundDependencyLoader(true)]
         private void load([CanBeNull] BindableBeatDivisor beatDivisor)
         {
@@ -32,6 +38,8 @@ namespace osu.Game.Screens.Edit
 
             Container mainContent;
 
+            LoadingSpinner spinner;
+
             Children = new Drawable[]
             {
                 mainContent = new Container
@@ -44,6 +52,10 @@ namespace osu.Game.Screens.Edit
                         Top = vertical_margins + timeline_height,
                         Bottom = vertical_margins
                     },
+                    Child = spinner = new LoadingSpinner(true)
+                    {
+                        State = { Value = Visibility.Visible },
+                    },
                 },
                 new Container
                 {
@@ -90,6 +102,8 @@ namespace osu.Game.Screens.Edit
 
             LoadComponentAsync(CreateMainContent(), content =>
             {
+                spinner.State.Value = Visibility.Hidden;
+
                 mainContent.Add(content);
                 content.FadeInFromZero(300, Easing.OutQuint);
 
@@ -98,13 +112,20 @@ namespace osu.Game.Screens.Edit
                     RelativeSizeAxes = Axes.Both,
                     Children = new[]
                     {
-                        new TimelineTickDisplay(),
                         CreateTimelineContent(),
                     }
-                }, timelineContainer.Add);
+                }, t =>
+                {
+                    timelineContainer.Add(t);
+                    OnTimelineLoaded(t);
+                });
             });
         }
 
+        protected virtual void OnTimelineLoaded(TimelineArea timelineArea)
+        {
+        }
+
         protected abstract Drawable CreateMainContent();
 
         protected virtual Drawable CreateTimelineContent() => new Container();

osu.Game/Screens/Edit/IEditorChangeHandler.cs

@@ -1,6 +1,7 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System;
 using osu.Game.Rulesets.Objects;
 
 namespace osu.Game.Screens.Edit
@@ -10,6 +11,11 @@ namespace osu.Game.Screens.Edit
     /// </summary>
     public interface IEditorChangeHandler
     {
+        /// <summary>
+        /// Fired whenever a state change occurs.
+        /// </summary>
+        event Action OnStateChange;
+
         /// <summary>
         /// Begins a bulk state change event. <see cref="EndChange"/> should be invoked soon after.
         /// </summary>
@@ -29,5 +35,11 @@ namespace osu.Game.Screens.Edit
         /// This should be invoked as soon as possible after <see cref="BeginChange"/> to cause a state change.
         /// </remarks>
         void EndChange();
+
+        /// <summary>
+        /// Immediately saves the current <see cref="Editor"/> state.
+        /// Note that this will be a no-op if there is a change in progress via <see cref="BeginChange"/>.
+        /// </summary>
+        void SaveState();
     }
 }

osu.Game/Screens/Edit/LegacyEditorBeatmapPatcher.cs

@@ -3,6 +3,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.IO;
 using System.Text;
 using DiffPlex;
@@ -35,6 +36,9 @@ namespace osu.Game.Screens.Edit
             int oldHitObjectsIndex = Array.IndexOf(result.PiecesOld, "[HitObjects]");
             int newHitObjectsIndex = Array.IndexOf(result.PiecesNew, "[HitObjects]");
 
+            Debug.Assert(oldHitObjectsIndex >= 0);
+            Debug.Assert(newHitObjectsIndex >= 0);
+
             var toRemove = new List<int>();
             var toAdd = new List<int>();
 
@@ -68,6 +72,8 @@ namespace osu.Game.Screens.Edit
             toRemove.Sort();
             toAdd.Sort();
 
+            editorBeatmap.BeginChange();
+
             // Apply the changes.
             for (int i = toRemove.Count - 1; i >= 0; i--)
                 editorBeatmap.RemoveAt(toRemove[i]);
@@ -78,6 +84,8 @@ namespace osu.Game.Screens.Edit
                 foreach (var i in toAdd)
                     editorBeatmap.Insert(i, newBeatmap.HitObjects[i]);
             }
+
+            editorBeatmap.EndChange();
         }
 
         private string readString(byte[] state) => Encoding.UTF8.GetString(state);
@@ -107,7 +115,7 @@ namespace osu.Game.Screens.Edit
 
             protected override Texture GetBackground() => throw new NotImplementedException();
 
-            protected override Track GetTrack() => throw new NotImplementedException();
+            protected override Track GetBeatmapTrack() => throw new NotImplementedException();
         }
     }
 }

osu.Game/Screens/Edit/PromptForSaveDialog.cs

@@ -0,0 +1,37 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using osu.Framework.Graphics.Sprites;
+using osu.Game.Overlays.Dialog;
+
+namespace osu.Game.Screens.Edit
+{
+    public class PromptForSaveDialog : PopupDialog
+    {
+        public PromptForSaveDialog(Action exit, Action saveAndExit)
+        {
+            HeaderText = "Did you want to save your changes?";
+
+            Icon = FontAwesome.Regular.Save;
+
+            Buttons = new PopupDialogButton[]
+            {
+                new PopupDialogCancelButton
+                {
+                    Text = @"Save my masterpiece!",
+                    Action = saveAndExit
+                },
+                new PopupDialogOkButton
+                {
+                    Text = @"Forget all changes",
+                    Action = exit
+                },
+                new PopupDialogCancelButton
+                {
+                    Text = @"Oops, continue editing",
+                },
+            };
+        }
+    }
+}

osu.Game/Screens/Edit/Setup/DifficultySection.cs

@@ -0,0 +1,99 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Linq;
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Game.Beatmaps;
+using osu.Game.Graphics.Sprites;
+using osu.Game.Graphics.UserInterfaceV2;
+
+namespace osu.Game.Screens.Edit.Setup
+{
+    internal class DifficultySection : SetupSection
+    {
+        [Resolved]
+        private EditorBeatmap editorBeatmap { get; set; }
+
+        private LabelledSliderBar<float> circleSizeSlider;
+        private LabelledSliderBar<float> healthDrainSlider;
+        private LabelledSliderBar<float> approachRateSlider;
+        private LabelledSliderBar<float> overallDifficultySlider;
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            Children = new Drawable[]
+            {
+                new OsuSpriteText
+                {
+                    Text = "Difficulty settings"
+                },
+                circleSizeSlider = new LabelledSliderBar<float>
+                {
+                    Label = "Object Size",
+                    Description = "The size of all hit objects",
+                    Current = new BindableFloat(Beatmap.Value.BeatmapInfo.BaseDifficulty.CircleSize)
+                    {
+                        Default = BeatmapDifficulty.DEFAULT_DIFFICULTY,
+                        MinValue = 2,
+                        MaxValue = 7,
+                        Precision = 0.1f,
+                    }
+                },
+                healthDrainSlider = new LabelledSliderBar<float>
+                {
+                    Label = "Health Drain",
+                    Description = "The rate of passive health drain throughout playable time",
+                    Current = new BindableFloat(Beatmap.Value.BeatmapInfo.BaseDifficulty.DrainRate)
+                    {
+                        Default = BeatmapDifficulty.DEFAULT_DIFFICULTY,
+                        MinValue = 0,
+                        MaxValue = 10,
+                        Precision = 0.1f,
+                    }
+                },
+                approachRateSlider = new LabelledSliderBar<float>
+                {
+                    Label = "Approach Rate",
+                    Description = "The speed at which objects are presented to the player",
+                    Current = new BindableFloat(Beatmap.Value.BeatmapInfo.BaseDifficulty.ApproachRate)
+                    {
+                        Default = BeatmapDifficulty.DEFAULT_DIFFICULTY,
+                        MinValue = 0,
+                        MaxValue = 10,
+                        Precision = 0.1f,
+                    }
+                },
+                overallDifficultySlider = new LabelledSliderBar<float>
+                {
+                    Label = "Overall Difficulty",
+                    Description = "The harshness of hit windows and difficulty of special objects (ie. spinners)",
+                    Current = new BindableFloat(Beatmap.Value.BeatmapInfo.BaseDifficulty.OverallDifficulty)
+                    {
+                        Default = BeatmapDifficulty.DEFAULT_DIFFICULTY,
+                        MinValue = 0,
+                        MaxValue = 10,
+                        Precision = 0.1f,
+                    }
+                },
+            };
+
+            foreach (var item in Children.OfType<LabelledSliderBar<float>>())
+                item.Current.ValueChanged += onValueChanged;
+        }
+
+        private void onValueChanged(ValueChangedEvent<float> args)
+        {
+            // for now, update these on commit rather than making BeatmapMetadata bindables.
+            // after switching database engines we can reconsider if switching to bindables is a good direction.
+            Beatmap.Value.BeatmapInfo.BaseDifficulty.CircleSize = circleSizeSlider.Current.Value;
+            Beatmap.Value.BeatmapInfo.BaseDifficulty.DrainRate = healthDrainSlider.Current.Value;
+            Beatmap.Value.BeatmapInfo.BaseDifficulty.ApproachRate = approachRateSlider.Current.Value;
+            Beatmap.Value.BeatmapInfo.BaseDifficulty.OverallDifficulty = overallDifficultySlider.Current.Value;
+
+            editorBeatmap.UpdateAllHitObjects();
+        }
+    }
+}

osu.Game/Screens/Edit/Setup/FileChooserLabelledTextBox.cs

@@ -0,0 +1,73 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.IO;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Input.Events;
+using osu.Game.Graphics.UserInterface;
+using osu.Game.Graphics.UserInterfaceV2;
+
+namespace osu.Game.Screens.Edit.Setup
+{
+    /// <summary>
+    /// A labelled textbox which reveals an inline file chooser when clicked.
+    /// </summary>
+    internal class FileChooserLabelledTextBox : LabelledTextBox
+    {
+        public Container Target;
+
+        private readonly IBindable<FileInfo> currentFile = new Bindable<FileInfo>();
+
+        public FileChooserLabelledTextBox()
+        {
+            currentFile.BindValueChanged(onFileSelected);
+        }
+
+        private void onFileSelected(ValueChangedEvent<FileInfo> file)
+        {
+            if (file.NewValue == null)
+                return;
+
+            Target.Clear();
+            Current.Value = file.NewValue.FullName;
+        }
+
+        protected override OsuTextBox CreateTextBox() =>
+            new FileChooserOsuTextBox
+            {
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+                RelativeSizeAxes = Axes.X,
+                CornerRadius = CORNER_RADIUS,
+                OnFocused = DisplayFileChooser
+            };
+
+        public void DisplayFileChooser()
+        {
+            Target.Child = new FileSelector(validFileExtensions: ResourcesSection.AudioExtensions)
+            {
+                RelativeSizeAxes = Axes.X,
+                Height = 400,
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+                CurrentFile = { BindTarget = currentFile }
+            };
+        }
+
+        internal class FileChooserOsuTextBox : OsuTextBox
+        {
+            public Action OnFocused;
+
+            protected override void OnFocus(FocusEvent e)
+            {
+                OnFocused?.Invoke();
+                base.OnFocus(e);
+
+                GetContainingInputManager().TriggerFocusContention(this);
+            }
+        }
+    }
+}

osu.Game/Screens/Edit/Setup/MetadataSection.cs

@@ -0,0 +1,71 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Linq;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.UserInterface;
+using osu.Game.Graphics.Sprites;
+using osu.Game.Graphics.UserInterfaceV2;
+
+namespace osu.Game.Screens.Edit.Setup
+{
+    internal class MetadataSection : SetupSection
+    {
+        private LabelledTextBox artistTextBox;
+        private LabelledTextBox titleTextBox;
+        private LabelledTextBox creatorTextBox;
+        private LabelledTextBox difficultyTextBox;
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            Children = new Drawable[]
+            {
+                new OsuSpriteText
+                {
+                    Text = "Beatmap metadata"
+                },
+                artistTextBox = new LabelledTextBox
+                {
+                    Label = "Artist",
+                    Current = { Value = Beatmap.Value.Metadata.Artist },
+                    TabbableContentContainer = this
+                },
+                titleTextBox = new LabelledTextBox
+                {
+                    Label = "Title",
+                    Current = { Value = Beatmap.Value.Metadata.Title },
+                    TabbableContentContainer = this
+                },
+                creatorTextBox = new LabelledTextBox
+                {
+                    Label = "Creator",
+                    Current = { Value = Beatmap.Value.Metadata.AuthorString },
+                    TabbableContentContainer = this
+                },
+                difficultyTextBox = new LabelledTextBox
+                {
+                    Label = "Difficulty Name",
+                    Current = { Value = Beatmap.Value.BeatmapInfo.Version },
+                    TabbableContentContainer = this
+                },
+            };
+
+            foreach (var item in Children.OfType<LabelledTextBox>())
+                item.OnCommit += onCommit;
+        }
+
+        private void onCommit(TextBox sender, bool newText)
+        {
+            if (!newText) return;
+
+            // for now, update these on commit rather than making BeatmapMetadata bindables.
+            // after switching database engines we can reconsider if switching to bindables is a good direction.
+            Beatmap.Value.Metadata.Artist = artistTextBox.Current.Value;
+            Beatmap.Value.Metadata.Title = titleTextBox.Current.Value;
+            Beatmap.Value.Metadata.AuthorString = creatorTextBox.Current.Value;
+            Beatmap.Value.BeatmapInfo.Version = difficultyTextBox.Current.Value;
+        }
+    }
+}

osu.Game/Screens/Edit/Setup/ResourcesSection.cs

@@ -0,0 +1,211 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Threading.Tasks;
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Game.Beatmaps;
+using osu.Game.Beatmaps.Drawables;
+using osu.Game.Database;
+using osu.Game.Graphics;
+using osu.Game.Graphics.Containers;
+using osu.Game.Graphics.Sprites;
+using osu.Game.Graphics.UserInterfaceV2;
+using osu.Game.Overlays;
+
+namespace osu.Game.Screens.Edit.Setup
+{
+    internal class ResourcesSection : SetupSection, ICanAcceptFiles
+    {
+        private LabelledTextBox audioTrackTextBox;
+        private Container backgroundSpriteContainer;
+
+        public IEnumerable<string> HandledExtensions => ImageExtensions.Concat(AudioExtensions);
+
+        public static string[] ImageExtensions { get; } = { ".jpg", ".jpeg", ".png" };
+
+        public static string[] AudioExtensions { get; } = { ".mp3", ".ogg" };
+
+        [Resolved]
+        private OsuGameBase game { get; set; }
+
+        [Resolved]
+        private MusicController music { get; set; }
+
+        [Resolved]
+        private BeatmapManager beatmaps { get; set; }
+
+        [Resolved(canBeNull: true)]
+        private Editor editor { get; set; }
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            Container audioTrackFileChooserContainer = new Container
+            {
+                RelativeSizeAxes = Axes.X,
+                AutoSizeAxes = Axes.Y,
+            };
+
+            Children = new Drawable[]
+            {
+                backgroundSpriteContainer = new Container
+                {
+                    RelativeSizeAxes = Axes.X,
+                    Height = 250,
+                    Masking = true,
+                    CornerRadius = 10,
+                },
+                new OsuSpriteText
+                {
+                    Text = "Resources"
+                },
+                audioTrackTextBox = new FileChooserLabelledTextBox
+                {
+                    Label = "Audio Track",
+                    Current = { Value = Beatmap.Value.Metadata.AudioFile ?? "Click to select a track" },
+                    Target = audioTrackFileChooserContainer,
+                    TabbableContentContainer = this
+                },
+                audioTrackFileChooserContainer,
+            };
+
+            updateBackgroundSprite();
+
+            audioTrackTextBox.Current.BindValueChanged(audioTrackChanged);
+        }
+
+        Task ICanAcceptFiles.Import(params string[] paths)
+        {
+            Schedule(() =>
+            {
+                var firstFile = new FileInfo(paths.First());
+
+                if (ImageExtensions.Contains(firstFile.Extension))
+                {
+                    ChangeBackgroundImage(firstFile.FullName);
+                }
+                else if (AudioExtensions.Contains(firstFile.Extension))
+                {
+                    audioTrackTextBox.Text = firstFile.FullName;
+                }
+            });
+            return Task.CompletedTask;
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+            game.RegisterImportHandler(this);
+        }
+
+        public bool ChangeBackgroundImage(string path)
+        {
+            var info = new FileInfo(path);
+
+            if (!info.Exists)
+                return false;
+
+            var set = Beatmap.Value.BeatmapSetInfo;
+
+            // remove the previous background for now.
+            // in the future we probably want to check if this is being used elsewhere (other difficulties?)
+            var oldFile = set.Files.FirstOrDefault(f => f.Filename == Beatmap.Value.Metadata.BackgroundFile);
+
+            using (var stream = info.OpenRead())
+            {
+                if (oldFile != null)
+                    beatmaps.ReplaceFile(set, oldFile, stream, info.Name);
+                else
+                    beatmaps.AddFile(set, stream, info.Name);
+            }
+
+            Beatmap.Value.Metadata.BackgroundFile = info.Name;
+            updateBackgroundSprite();
+
+            return true;
+        }
+
+        protected override void Dispose(bool isDisposing)
+        {
+            base.Dispose(isDisposing);
+            game?.UnregisterImportHandler(this);
+        }
+
+        public bool ChangeAudioTrack(string path)
+        {
+            var info = new FileInfo(path);
+
+            if (!info.Exists)
+                return false;
+
+            var set = Beatmap.Value.BeatmapSetInfo;
+
+            // remove the previous audio track for now.
+            // in the future we probably want to check if this is being used elsewhere (other difficulties?)
+            var oldFile = set.Files.FirstOrDefault(f => f.Filename == Beatmap.Value.Metadata.AudioFile);
+
+            using (var stream = info.OpenRead())
+            {
+                if (oldFile != null)
+                    beatmaps.ReplaceFile(set, oldFile, stream, info.Name);
+                else
+                    beatmaps.AddFile(set, stream, info.Name);
+            }
+
+            Beatmap.Value.Metadata.AudioFile = info.Name;
+
+            music.ReloadCurrentTrack();
+
+            editor?.UpdateClockSource();
+            return true;
+        }
+
+        private void audioTrackChanged(ValueChangedEvent<string> filePath)
+        {
+            if (!ChangeAudioTrack(filePath.NewValue))
+                audioTrackTextBox.Current.Value = filePath.OldValue;
+        }
+
+        private void updateBackgroundSprite()
+        {
+            LoadComponentAsync(new BeatmapBackgroundSprite(Beatmap.Value)
+            {
+                RelativeSizeAxes = Axes.Both,
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+                FillMode = FillMode.Fill,
+            }, background =>
+            {
+                if (background.Texture != null)
+                    backgroundSpriteContainer.Child = background;
+                else
+                {
+                    backgroundSpriteContainer.Children = new Drawable[]
+                    {
+                        new Box
+                        {
+                            Colour = Colours.GreySeafoamDarker,
+                            RelativeSizeAxes = Axes.Both,
+                        },
+                        new OsuTextFlowContainer(t => t.Font = OsuFont.Default.With(size: 24))
+                        {
+                            Text = "Drag image here to set beatmap background!",
+                            Anchor = Anchor.Centre,
+                            Origin = Anchor.Centre,
+                            AutoSizeAxes = Axes.X,
+                        }
+                    };
+                }
+
+                background.FadeInFromZero(500);
+            });
+        }
+    }
+}

osu.Game/Screens/Edit/Setup/SetupScreen.cs

@@ -1,13 +1,78 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Game.Graphics;
+using osu.Game.Graphics.Containers;
+using osu.Game.Overlays;
+
 namespace osu.Game.Screens.Edit.Setup
 {
     public class SetupScreen : EditorScreen
     {
+        [Resolved]
+        private OsuColour colours { get; set; }
+
+        [Cached]
+        protected readonly OverlayColourProvider ColourProvider;
+
         public SetupScreen()
+            : base(EditorScreenMode.SongSetup)
         {
-            Child = new ScreenWhiteBox.UnderConstructionMessage("Setup mode");
+            ColourProvider = new OverlayColourProvider(OverlayColourScheme.Green);
+        }
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            Child = new Container
+            {
+                RelativeSizeAxes = Axes.Both,
+                Padding = new MarginPadding(50),
+                Child = new Container
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Masking = true,
+                    CornerRadius = 10,
+                    Children = new Drawable[]
+                    {
+                        new Box
+                        {
+                            Colour = colours.GreySeafoamDark,
+                            RelativeSizeAxes = Axes.Both,
+                        },
+                        new SectionsContainer<SetupSection>
+                        {
+                            FixedHeader = new SetupScreenHeader(),
+                            RelativeSizeAxes = Axes.Both,
+                            Children = new SetupSection[]
+                            {
+                                new ResourcesSection(),
+                                new MetadataSection(),
+                                new DifficultySection(),
+                            }
+                        },
+                    }
+                }
+            };
+        }
+    }
+
+    internal class SetupScreenHeader : OverlayHeader
+    {
+        protected override OverlayTitle CreateTitle() => new SetupScreenTitle();
+
+        private class SetupScreenTitle : OverlayTitle
+        {
+            public SetupScreenTitle()
+            {
+                Title = "beatmap setup";
+                Description = "change general settings of your beatmap";
+                IconTexture = "Icons/Hexacons/social";
+            }
         }
     }
 }

osu.Game/Screens/Edit/Setup/SetupSection.cs

@@ -0,0 +1,42 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Game.Beatmaps;
+using osu.Game.Graphics;
+using osuTK;
+
+namespace osu.Game.Screens.Edit.Setup
+{
+    internal class SetupSection : Container
+    {
+        private readonly FillFlowContainer flow;
+
+        [Resolved]
+        protected OsuColour Colours { get; private set; }
+
+        [Resolved]
+        protected IBindable<WorkingBeatmap> Beatmap { get; private set; }
+
+        protected override Container<Drawable> Content => flow;
+
+        public SetupSection()
+        {
+            RelativeSizeAxes = Axes.X;
+            AutoSizeAxes = Axes.Y;
+
+            Padding = new MarginPadding(10);
+
+            InternalChild = flow = new FillFlowContainer
+            {
+                RelativeSizeAxes = Axes.X,
+                AutoSizeAxes = Axes.Y,
+                Spacing = new Vector2(20),
+                Direction = FillDirection.Vertical,
+            };
+        }
+    }
+}

osu.Game/Screens/Edit/Timing/ControlPointSettings.cs

@@ -41,6 +41,7 @@ namespace osu.Game.Screens.Edit.Timing
 
         private IReadOnlyList<Drawable> createSections() => new Drawable[]
         {
+            new GroupSection(),
             new TimingSection(),
             new DifficultySection(),
             new SampleSection(),

osu.Game/Screens/Edit/Timing/ControlPointTable.cs

@@ -11,6 +11,7 @@ using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Input.Events;
 using osu.Game.Beatmaps.ControlPoints;
+using osu.Game.Extensions;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Containers;
 using osu.Game.Graphics.Sprites;
@@ -89,7 +90,7 @@ namespace osu.Game.Screens.Edit.Timing
             },
             new OsuSpriteText
             {
-                Text = $"{group.Time:n0}ms",
+                Text = group.Time.ToEditorFormattedString(),
                 Font = OsuFont.GetFont(size: text_size, weight: FontWeight.Bold)
             },
             new ControlGroupAttributes(group),
@@ -97,7 +98,7 @@ namespace osu.Game.Screens.Edit.Timing
 
         private class ControlGroupAttributes : CompositeDrawable
         {
-            private readonly IBindableList<ControlPoint> controlPoints;
+            private readonly IBindableList<ControlPoint> controlPoints = new BindableList<ControlPoint>();
 
             private readonly FillFlowContainer fill;
 
@@ -111,13 +112,24 @@ namespace osu.Game.Screens.Edit.Timing
                     Spacing = new Vector2(2)
                 };
 
-                controlPoints = group.ControlPoints.GetBoundCopy();
-                controlPoints.ItemsAdded += _ => createChildren();
-                controlPoints.ItemsRemoved += _ => createChildren();
+                controlPoints.BindTo(group.ControlPoints);
+            }
 
+            [Resolved]
+            private OsuColour colours { get; set; }
+
+            [BackgroundDependencyLoader]
+            private void load()
+            {
                 createChildren();
             }
 
+            protected override void LoadComplete()
+            {
+                base.LoadComplete();
+                controlPoints.CollectionChanged += (_, __) => createChildren();
+            }
+
             private void createChildren()
             {
                 fill.ChildrenEnumerable = controlPoints.Select(createAttribute).Where(c => c != null);
@@ -125,20 +137,22 @@ namespace osu.Game.Screens.Edit.Timing
 
             private Drawable createAttribute(ControlPoint controlPoint)
             {
+                Color4 colour = controlPoint.GetRepresentingColour(colours);
+
                 switch (controlPoint)
                 {
                     case TimingControlPoint timing:
-                        return new RowAttribute("timing", () => $"{60000 / timing.BeatLength:n1}bpm {timing.TimeSignature}");
+                        return new RowAttribute("timing", () => $"{60000 / timing.BeatLength:n1}bpm {timing.TimeSignature}", colour);
 
                     case DifficultyControlPoint difficulty:
 
-                        return new RowAttribute("difficulty", () => $"{difficulty.SpeedMultiplier:n2}x");
+                        return new RowAttribute("difficulty", () => $"{difficulty.SpeedMultiplier:n2}x", colour);
 
                     case EffectControlPoint effect:
-                        return new RowAttribute("effect", () => $"{(effect.KiaiMode ? "Kiai " : "")}{(effect.OmitFirstBarLine ? "NoBarLine " : "")}");
+                        return new RowAttribute("effect", () => $"{(effect.KiaiMode ? "Kiai " : "")}{(effect.OmitFirstBarLine ? "NoBarLine " : "")}", colour);
 
                     case SampleControlPoint sample:
-                        return new RowAttribute("sample", () => $"{sample.SampleBank} {sample.SampleVolume}%");
+                        return new RowAttribute("sample", () => $"{sample.SampleBank} {sample.SampleVolume}%", colour);
                 }
 
                 return null;
@@ -163,6 +177,9 @@ namespace osu.Game.Screens.Edit.Timing
 
             private readonly Box hoveredBackground;
 
+            [Resolved]
+            private EditorClock clock { get; set; }
+
             [Resolved]
             private Bindable<ControlPointGroup> selectedGroup { get; set; }
 
@@ -186,7 +203,11 @@ namespace osu.Game.Screens.Edit.Timing
                     },
                 };
 
-                Action = () => selectedGroup.Value = controlGroup;
+                Action = () =>
+                {
+                    selectedGroup.Value = controlGroup;
+                    clock.SeekTo(controlGroup.Time);
+                };
             }
 
             private Color4 colourHover;

osu.Game/Screens/Edit/Timing/DifficultySection.cs

@@ -2,27 +2,23 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using osu.Framework.Allocation;
-using osu.Framework.Graphics;
 using osu.Framework.Bindables;
 using osu.Game.Beatmaps.ControlPoints;
-using osu.Game.Overlays.Settings;
 
 namespace osu.Game.Screens.Edit.Timing
 {
     internal class DifficultySection : Section<DifficultyControlPoint>
     {
-        private SettingsSlider<double> multiplier;
+        private SliderWithTextBoxInput<double> multiplierSlider;
 
         [BackgroundDependencyLoader]
         private void load()
         {
             Flow.AddRange(new[]
             {
-                multiplier = new SettingsSlider<double>
+                multiplierSlider = new SliderWithTextBoxInput<double>("Speed Multiplier")
                 {
-                    LabelText = "Speed Multiplier",
-                    Bindable = new DifficultyControlPoint().SpeedMultiplierBindable,
-                    RelativeSizeAxes = Axes.X,
+                    Current = new DifficultyControlPoint().SpeedMultiplierBindable
                 }
             });
         }
@@ -31,7 +27,8 @@ namespace osu.Game.Screens.Edit.Timing
         {
             if (point.NewValue != null)
             {
-                multiplier.Bindable = point.NewValue.SpeedMultiplierBindable;
+                multiplierSlider.Current = point.NewValue.SpeedMultiplierBindable;
+                multiplierSlider.Current.BindValueChanged(_ => ChangeHandler?.SaveState());
             }
         }
 

osu.Game/Screens/Edit/Timing/EffectSection.cs

@@ -28,7 +28,10 @@ namespace osu.Game.Screens.Edit.Timing
             if (point.NewValue != null)
             {
                 kiai.Current = point.NewValue.KiaiModeBindable;
+                kiai.Current.BindValueChanged(_ => ChangeHandler?.SaveState());
+
                 omitBarLine.Current = point.NewValue.OmitFirstBarLineBindable;
+                omitBarLine.Current.BindValueChanged(_ => ChangeHandler?.SaveState());
             }
         }
 

osu.Game/Screens/Edit/Timing/GroupSection.cs

@@ -0,0 +1,121 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Linq;
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Game.Beatmaps;
+using osu.Game.Beatmaps.ControlPoints;
+using osu.Game.Graphics.UserInterface;
+using osu.Game.Graphics.UserInterfaceV2;
+using osuTK;
+
+namespace osu.Game.Screens.Edit.Timing
+{
+    internal class GroupSection : CompositeDrawable
+    {
+        private LabelledTextBox textBox;
+
+        private TriangleButton button;
+
+        [Resolved]
+        protected Bindable<ControlPointGroup> SelectedGroup { get; private set; }
+
+        [Resolved]
+        protected IBindable<WorkingBeatmap> Beatmap { get; private set; }
+
+        [Resolved]
+        private EditorClock clock { get; set; }
+
+        [Resolved(canBeNull: true)]
+        private IEditorChangeHandler changeHandler { get; set; }
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            RelativeSizeAxes = Axes.X;
+            AutoSizeAxes = Axes.Y;
+
+            Padding = new MarginPadding(10);
+
+            InternalChildren = new Drawable[]
+            {
+                new FillFlowContainer
+                {
+                    RelativeSizeAxes = Axes.X,
+                    AutoSizeAxes = Axes.Y,
+                    Spacing = new Vector2(10),
+                    Direction = FillDirection.Vertical,
+                    Children = new Drawable[]
+                    {
+                        textBox = new LabelledTextBox
+                        {
+                            Label = "Time"
+                        },
+                        button = new TriangleButton
+                        {
+                            Text = "Use current time",
+                            RelativeSizeAxes = Axes.X,
+                            Action = () => changeSelectedGroupTime(clock.CurrentTime)
+                        }
+                    }
+                },
+            };
+
+            textBox.OnCommit += (sender, isNew) =>
+            {
+                if (!isNew)
+                    return;
+
+                if (double.TryParse(sender.Text, out var newTime))
+                {
+                    changeSelectedGroupTime(newTime);
+                }
+                else
+                {
+                    SelectedGroup.TriggerChange();
+                }
+            };
+
+            SelectedGroup.BindValueChanged(group =>
+            {
+                if (group.NewValue == null)
+                {
+                    textBox.Text = string.Empty;
+
+                    // cannot use textBox.Current.Disabled due to https://github.com/ppy/osu-framework/issues/3919
+                    textBox.ReadOnly = true;
+                    button.Enabled.Value = false;
+                    return;
+                }
+
+                textBox.ReadOnly = false;
+                button.Enabled.Value = true;
+
+                textBox.Text = $"{group.NewValue.Time:n0}";
+            }, true);
+        }
+
+        private void changeSelectedGroupTime(in double time)
+        {
+            if (SelectedGroup.Value == null || time == SelectedGroup.Value.Time)
+                return;
+
+            changeHandler?.BeginChange();
+
+            var currentGroupItems = SelectedGroup.Value.ControlPoints.ToArray();
+
+            Beatmap.Value.Beatmap.ControlPointInfo.RemoveGroup(SelectedGroup.Value);
+
+            foreach (var cp in currentGroupItems)
+                Beatmap.Value.Beatmap.ControlPointInfo.Add(time, cp);
+
+            // the control point might not necessarily exist yet, if currentGroupItems was empty.
+            SelectedGroup.Value = Beatmap.Value.Beatmap.ControlPointInfo.GroupAt(time, true);
+
+            changeHandler?.EndChange();
+        }
+    }
+}

osu.Game/Screens/Edit/Timing/RowAttribute.cs

@@ -9,6 +9,7 @@ using osu.Framework.Graphics.Cursor;
 using osu.Framework.Graphics.Shapes;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Sprites;
+using osuTK.Graphics;
 
 namespace osu.Game.Screens.Edit.Timing
 {
@@ -16,11 +17,13 @@ namespace osu.Game.Screens.Edit.Timing
     {
         private readonly string header;
         private readonly Func<string> content;
+        private readonly Color4 colour;
 
-        public RowAttribute(string header, Func<string> content)
+        public RowAttribute(string header, Func<string> content, Color4 colour)
         {
             this.header = header;
             this.content = content;
+            this.colour = colour;
         }
 
         [BackgroundDependencyLoader]
@@ -40,7 +43,7 @@ namespace osu.Game.Screens.Edit.Timing
             {
                 new Box
                 {
-                    Colour = colours.Yellow,
+                    Colour = colour,
                     RelativeSizeAxes = Axes.Both,
                 },
                 new OsuSpriteText
@@ -50,7 +53,7 @@ namespace osu.Game.Screens.Edit.Timing
                     Origin = Anchor.Centre,
                     Font = OsuFont.Default.With(weight: FontWeight.SemiBold, size: 12),
                     Text = header,
-                    Colour = colours.Gray3
+                    Colour = colours.Gray0
                 },
             };
         }

osu.Game/Screens/Edit/Timing/SampleSection.cs

@@ -2,18 +2,17 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using osu.Framework.Allocation;
-using osu.Framework.Graphics;
 using osu.Framework.Bindables;
+using osu.Framework.Graphics;
 using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Graphics.UserInterfaceV2;
-using osu.Game.Overlays.Settings;
 
 namespace osu.Game.Screens.Edit.Timing
 {
     internal class SampleSection : Section<SampleControlPoint>
     {
         private LabelledTextBox bank;
-        private SettingsSlider<int> volume;
+        private SliderWithTextBoxInput<int> volume;
 
         [BackgroundDependencyLoader]
         private void load()
@@ -24,10 +23,9 @@ namespace osu.Game.Screens.Edit.Timing
                 {
                     Label = "Bank Name",
                 },
-                volume = new SettingsSlider<int>
+                volume = new SliderWithTextBoxInput<int>("Volume")
                 {
-                    Bindable = new SampleControlPoint().SampleVolumeBindable,
-                    LabelText = "Volume",
+                    Current = new SampleControlPoint().SampleVolumeBindable,
                 }
             });
         }
@@ -37,7 +35,10 @@ namespace osu.Game.Screens.Edit.Timing
             if (point.NewValue != null)
             {
                 bank.Current = point.NewValue.SampleBankBindable;
-                volume.Bindable = point.NewValue.SampleVolumeBindable;
+                bank.Current.BindValueChanged(_ => ChangeHandler?.SaveState());
+
+                volume.Current = point.NewValue.SampleVolumeBindable;
+                volume.Current.BindValueChanged(_ => ChangeHandler?.SaveState());
             }
         }
 

osu.Game/Screens/Edit/Timing/Section.cs

@@ -32,6 +32,9 @@ namespace osu.Game.Screens.Edit.Timing
         [Resolved]
         protected Bindable<ControlPointGroup> SelectedGroup { get; private set; }
 
+        [Resolved(canBeNull: true)]
+        protected IEditorChangeHandler ChangeHandler { get; private set; }
+
         [BackgroundDependencyLoader]
         private void load(OsuColour colours)
         {
@@ -57,7 +60,7 @@ namespace osu.Game.Screens.Edit.Timing
                     {
                         checkbox = new OsuCheckbox
                         {
-                            LabelText = typeof(T).Name.Replace(typeof(ControlPoint).Name, string.Empty)
+                            LabelText = typeof(T).Name.Replace(nameof(Beatmaps.ControlPoints.ControlPoint), string.Empty)
                         }
                     }
                 },

osu.Game/Screens/Edit/Timing/SliderWithTextBoxInput.cs

@@ -0,0 +1,78 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.UserInterface;
+using osu.Game.Graphics.UserInterfaceV2;
+using osu.Game.Overlays.Settings;
+
+namespace osu.Game.Screens.Edit.Timing
+{
+    public class SliderWithTextBoxInput<T> : CompositeDrawable, IHasCurrentValue<T>
+        where T : struct, IEquatable<T>, IComparable<T>, IConvertible
+    {
+        private readonly SettingsSlider<T> slider;
+
+        public SliderWithTextBoxInput(string labelText)
+        {
+            LabelledTextBox textbox;
+
+            RelativeSizeAxes = Axes.X;
+            AutoSizeAxes = Axes.Y;
+
+            InternalChildren = new Drawable[]
+            {
+                new FillFlowContainer
+                {
+                    RelativeSizeAxes = Axes.X,
+                    AutoSizeAxes = Axes.Y,
+                    Direction = FillDirection.Vertical,
+                    Children = new Drawable[]
+                    {
+                        textbox = new LabelledTextBox
+                        {
+                            Label = labelText,
+                        },
+                        slider = new SettingsSlider<T>
+                        {
+                            TransferValueOnCommit = true,
+                            RelativeSizeAxes = Axes.X,
+                        }
+                    }
+                },
+            };
+
+            textbox.OnCommit += (t, isNew) =>
+            {
+                if (!isNew) return;
+
+                try
+                {
+                    slider.Current.Parse(t.Text);
+                }
+                catch
+                {
+                    // TriggerChange below will restore the previous text value on failure.
+                }
+
+                // This is run regardless of parsing success as the parsed number may not actually trigger a change
+                // due to bindable clamping. Even in such a case we want to update the textbox to a sane visual state.
+                Current.TriggerChange();
+            };
+
+            Current.BindValueChanged(val =>
+            {
+                textbox.Text = val.NewValue.ToString();
+            }, true);
+        }
+
+        public Bindable<T> Current
+        {
+            get => slider.Current;
+            set => slider.Current = value;
+        }
+    }
+}

osu.Game/Screens/Edit/Timing/TimingScreen.cs

@@ -12,6 +12,7 @@ using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Containers;
 using osu.Game.Graphics.UserInterface;
+using osu.Game.Screens.Edit.Compose.Components.Timeline;
 using osuTK;
 
 namespace osu.Game.Screens.Edit.Timing
@@ -21,8 +22,10 @@ namespace osu.Game.Screens.Edit.Timing
         [Cached]
         private Bindable<ControlPointGroup> selectedGroup = new Bindable<ControlPointGroup>();
 
-        [Resolved]
-        private EditorClock clock { get; set; }
+        public TimingScreen()
+            : base(EditorScreenMode.Timing)
+        {
+        }
 
         protected override Drawable CreateMainContent() => new GridContainer
         {
@@ -42,15 +45,10 @@ namespace osu.Game.Screens.Edit.Timing
             }
         };
 
-        protected override void LoadComplete()
+        protected override void OnTimelineLoaded(TimelineArea timelineArea)
         {
-            base.LoadComplete();
-
-            selectedGroup.BindValueChanged(selected =>
-            {
-                if (selected.NewValue != null)
-                    clock.SeekTo(selected.NewValue.Time);
-            });
+            base.OnTimelineLoaded(timelineArea);
+            timelineArea.Timeline.Zoom = timelineArea.Timeline.MinZoom;
         }
 
         public class ControlPointList : CompositeDrawable
@@ -58,7 +56,7 @@ namespace osu.Game.Screens.Edit.Timing
             private OsuButton deleteButton;
             private ControlPointTable table;
 
-            private IBindableList<ControlPointGroup> controlGroups;
+            private readonly IBindableList<ControlPointGroup> controlPointGroups = new BindableList<ControlPointGroup>();
 
             [Resolved]
             private EditorClock clock { get; set; }
@@ -69,6 +67,9 @@ namespace osu.Game.Screens.Edit.Timing
             [Resolved]
             private Bindable<ControlPointGroup> selectedGroup { get; set; }
 
+            [Resolved(canBeNull: true)]
+            private IEditorChangeHandler changeHandler { get; set; }
+
             [BackgroundDependencyLoader]
             private void load(OsuColour colours)
             {
@@ -123,14 +124,14 @@ namespace osu.Game.Screens.Edit.Timing
 
                 selectedGroup.BindValueChanged(selected => { deleteButton.Enabled.Value = selected.NewValue != null; }, true);
 
-                controlGroups = Beatmap.Value.Beatmap.ControlPointInfo.Groups.GetBoundCopy();
-                controlGroups.ItemsAdded += _ => createContent();
-                controlGroups.ItemsRemoved += _ => createContent();
-                createContent();
+                controlPointGroups.BindTo(Beatmap.Value.Beatmap.ControlPointInfo.Groups);
+                controlPointGroups.BindCollectionChanged((sender, args) =>
+                {
+                    table.ControlGroups = controlPointGroups;
+                    changeHandler?.SaveState();
+                }, true);
             }
 
-            private void createContent() => table.ControlGroups = controlGroups;
-
             private void delete()
             {
                 if (selectedGroup.Value == null)

osu.Game/Screens/Edit/Timing/TimingSection.cs

@@ -1,30 +1,30 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Beatmaps.Timing;
+using osu.Game.Graphics.UserInterfaceV2;
 using osu.Game.Overlays.Settings;
 
 namespace osu.Game.Screens.Edit.Timing
 {
     internal class TimingSection : Section<TimingControlPoint>
     {
-        private SettingsSlider<double> bpm;
+        private SettingsSlider<double> bpmSlider;
         private SettingsEnumDropdown<TimeSignatures> timeSignature;
+        private BPMTextBox bpmTextEntry;
 
         [BackgroundDependencyLoader]
         private void load()
         {
             Flow.AddRange(new Drawable[]
             {
-                bpm = new BPMSlider
-                {
-                    Bindable = new TimingControlPoint().BeatLengthBindable,
-                    LabelText = "BPM",
-                },
+                bpmTextEntry = new BPMTextBox(),
+                bpmSlider = new BPMSlider(),
                 timeSignature = new SettingsEnumDropdown<TimeSignatures>
                 {
                     LabelText = "Time Signature"
@@ -36,8 +36,14 @@ namespace osu.Game.Screens.Edit.Timing
         {
             if (point.NewValue != null)
             {
-                bpm.Bindable = point.NewValue.BeatLengthBindable;
-                timeSignature.Bindable = point.NewValue.TimeSignatureBindable;
+                bpmSlider.Current = point.NewValue.BeatLengthBindable;
+                bpmSlider.Current.BindValueChanged(_ => ChangeHandler?.SaveState());
+
+                bpmTextEntry.Bindable = point.NewValue.BeatLengthBindable;
+                // no need to hook change handler here as it's the same bindable as above
+
+                timeSignature.Current = point.NewValue.TimeSignatureBindable;
+                timeSignature.Current.BindValueChanged(_ => ChangeHandler?.SaveState());
             }
         }
 
@@ -52,34 +58,96 @@ namespace osu.Game.Screens.Edit.Timing
             };
         }
 
-        private class BPMSlider : SettingsSlider<double>
+        private class BPMTextBox : LabelledTextBox
         {
-            private readonly BindableDouble beatLengthBindable = new BindableDouble();
+            private readonly BindableNumber<double> beatLengthBindable = new TimingControlPoint().BeatLengthBindable;
 
-            private BindableDouble bpmBindable;
-
-            public override Bindable<double> Bindable
+            public BPMTextBox()
             {
-                get => base.Bindable;
+                Label = "BPM";
+
+                OnCommit += (val, isNew) =>
+                {
+                    if (!isNew) return;
+
+                    try
+                    {
+                        if (double.TryParse(Current.Value, out double doubleVal) && doubleVal > 0)
+                            beatLengthBindable.Value = beatLengthToBpm(doubleVal);
+                    }
+                    catch
+                    {
+                        // TriggerChange below will restore the previous text value on failure.
+                    }
+
+                    // This is run regardless of parsing success as the parsed number may not actually trigger a change
+                    // due to bindable clamping. Even in such a case we want to update the textbox to a sane visual state.
+                    beatLengthBindable.TriggerChange();
+                };
+
+                beatLengthBindable.BindValueChanged(val =>
+                {
+                    Current.Value = beatLengthToBpm(val.NewValue).ToString("N2");
+                }, true);
+            }
+
+            public Bindable<double> Bindable
+            {
+                get => beatLengthBindable;
                 set
                 {
-                    // incoming will be beatlength
-
+                    // incoming will be beat length, not bpm
                     beatLengthBindable.UnbindBindings();
                     beatLengthBindable.BindTo(value);
+                }
+            }
+        }
 
-                    base.Bindable = bpmBindable = new BindableDouble(beatLengthToBpm(beatLengthBindable.Value))
-                    {
-                        MinValue = beatLengthToBpm(beatLengthBindable.MaxValue),
-                        MaxValue = beatLengthToBpm(beatLengthBindable.MinValue),
-                        Default = beatLengthToBpm(beatLengthBindable.Default),
-                    };
+        private class BPMSlider : SettingsSlider<double>
+        {
+            private const double sane_minimum = 60;
+            private const double sane_maximum = 240;
 
-                    bpmBindable.BindValueChanged(bpm => beatLengthBindable.Value = beatLengthToBpm(bpm.NewValue));
+            private readonly BindableNumber<double> beatLengthBindable = new TimingControlPoint().BeatLengthBindable;
+
+            private readonly BindableDouble bpmBindable = new BindableDouble(60000 / TimingControlPoint.DEFAULT_BEAT_LENGTH)
+            {
+                MinValue = sane_minimum,
+                MaxValue = sane_maximum,
+            };
+
+            public BPMSlider()
+            {
+                beatLengthBindable.BindValueChanged(beatLength => updateCurrent(beatLengthToBpm(beatLength.NewValue)), true);
+                bpmBindable.BindValueChanged(bpm => beatLengthBindable.Value = beatLengthToBpm(bpm.NewValue));
+
+                base.Current = bpmBindable;
+
+                TransferValueOnCommit = true;
+            }
+
+            public override Bindable<double> Current
+            {
+                get => base.Current;
+                set
+                {
+                    // incoming will be beat length, not bpm
+                    beatLengthBindable.UnbindBindings();
+                    beatLengthBindable.BindTo(value);
                 }
             }
 
-            private double beatLengthToBpm(double beatLength) => 60000 / beatLength;
+            private void updateCurrent(double newValue)
+            {
+                // we use a more sane range for the slider display unless overridden by the user.
+                // if a value comes in outside our range, we should expand temporarily.
+                bpmBindable.MinValue = Math.Min(newValue, sane_minimum);
+                bpmBindable.MaxValue = Math.Max(newValue, sane_maximum);
+
+                bpmBindable.Value = newValue;
+            }
         }
+
+        private static double beatLengthToBpm(double beatLength) => 60000 / beatLength;
     }
 }

osu.Game/Screens/Edit/TransactionalCommitComponent.cs

@@ -0,0 +1,73 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using osu.Framework.Graphics;
+
+namespace osu.Game.Screens.Edit
+{
+    /// <summary>
+    /// A component that tracks a batch change, only applying after all active changes are completed.
+    /// </summary>
+    public abstract class TransactionalCommitComponent : Component
+    {
+        /// <summary>
+        /// Fires whenever a transaction begins. Will not fire on nested transactions.
+        /// </summary>
+        public event Action TransactionBegan;
+
+        /// <summary>
+        /// Fires when the last transaction completes.
+        /// </summary>
+        public event Action TransactionEnded;
+
+        /// <summary>
+        /// Fires when <see cref="SaveState"/> is called and results in a non-transactional state save.
+        /// </summary>
+        public event Action SaveStateTriggered;
+
+        public bool TransactionActive => bulkChangesStarted > 0;
+
+        private int bulkChangesStarted;
+
+        /// <summary>
+        /// Signal the beginning of a change.
+        /// </summary>
+        public void BeginChange()
+        {
+            if (bulkChangesStarted++ == 0)
+                TransactionBegan?.Invoke();
+        }
+
+        /// <summary>
+        /// Signal the end of a change.
+        /// </summary>
+        /// <exception cref="InvalidOperationException">Throws if <see cref="BeginChange"/> was not first called.</exception>
+        public void EndChange()
+        {
+            if (bulkChangesStarted == 0)
+                throw new InvalidOperationException($"Cannot call {nameof(EndChange)} without a previous call to {nameof(BeginChange)}.");
+
+            if (--bulkChangesStarted == 0)
+            {
+                UpdateState();
+                TransactionEnded?.Invoke();
+            }
+        }
+
+        /// <summary>
+        /// Force an update of the state with no attached transaction.
+        /// This is a no-op if a transaction is already active. Should generally be used as a safety measure to ensure granular changes are not left outside a transaction.
+        /// </summary>
+        public void SaveState()
+        {
+            if (bulkChangesStarted > 0)
+                return;
+
+            SaveStateTriggered?.Invoke();
+            UpdateState();
+        }
+
+        protected abstract void UpdateState();
+    }
+}

osu.Game/Screens/Edit/WaveformOpacityMenu.cs

@@ -0,0 +1,46 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Collections.Generic;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics.UserInterface;
+using osu.Game.Configuration;
+using osu.Game.Graphics.UserInterface;
+
+namespace osu.Game.Screens.Edit
+{
+    internal class WaveformOpacityMenu : MenuItem
+    {
+        private readonly Bindable<float> waveformOpacity;
+
+        private readonly Dictionary<float, ToggleMenuItem> menuItemLookup = new Dictionary<float, ToggleMenuItem>();
+
+        public WaveformOpacityMenu(OsuConfigManager config)
+            : base("Waveform opacity")
+        {
+            Items = new[]
+            {
+                createMenuItem(0.25f),
+                createMenuItem(0.5f),
+                createMenuItem(0.75f),
+                createMenuItem(1f),
+            };
+
+            waveformOpacity = config.GetBindable<float>(OsuSetting.EditorWaveformOpacity);
+            waveformOpacity.BindValueChanged(opacity =>
+            {
+                foreach (var kvp in menuItemLookup)
+                    kvp.Value.State.Value = kvp.Key == opacity.NewValue;
+            }, true);
+        }
+
+        private ToggleMenuItem createMenuItem(float opacity)
+        {
+            var item = new ToggleMenuItem($"{opacity * 100}%", MenuItemType.Standard, _ => updateOpacity(opacity));
+            menuItemLookup[opacity] = item;
+            return item;
+        }
+
+        private void updateOpacity(float opacity) => waveformOpacity.Value = opacity;
+    }
+}

osu.Game/Screens/IOsuScreen.cs

@@ -6,6 +6,7 @@ using osu.Framework.Screens;
 using osu.Game.Beatmaps;
 using osu.Game.Overlays;
 using osu.Game.Rulesets;
+using osu.Game.Users;
 
 namespace osu.Game.Screens
 {
@@ -39,9 +40,14 @@ namespace osu.Game.Screens
         bool HideOverlaysOnEnter { get; }
 
         /// <summary>
-        /// Whether overlays should be able to be opened once this screen is entered or resumed.
+        /// Whether overlays should be able to be opened when this screen is current.
         /// </summary>
-        OverlayActivation InitialOverlayActivationMode { get; }
+        IBindable<OverlayActivation> OverlayActivationMode { get; }
+
+        /// <summary>
+        /// The current <see cref="UserActivity"/> for this screen.
+        /// </summary>
+        IBindable<UserActivity> Activity { get; }
 
         /// <summary>
         /// The amount of parallax to be applied while this screen is displayed.
@@ -56,5 +62,14 @@ namespace osu.Game.Screens
         /// Whether mod rate adjustments are allowed to be applied.
         /// </summary>
         bool AllowRateAdjustments { get; }
+
+        /// <summary>
+        /// Invoked when the back button has been pressed to close any overlays before exiting this <see cref="IOsuScreen"/>.
+        /// </summary>
+        /// <remarks>
+        /// Return <c>true</c> to block this <see cref="IOsuScreen"/> from being exited after closing an overlay.
+        /// Return <c>false</c> if this <see cref="IOsuScreen"/> should continue exiting.
+        /// </remarks>
+        bool OnBackButton();
     }
 }

osu.Game/Screens/Loader.cs

@@ -51,6 +51,9 @@ namespace osu.Game.Screens
                 case IntroSequence.Circles:
                     return new IntroCircles();
 
+                case IntroSequence.Welcome:
+                    return new IntroWelcome();
+
                 default:
                     return new IntroTriangles();
             }

osu.Game/Screens/Menu/Button.cs

@@ -6,6 +6,7 @@ using osu.Framework;
 using osu.Framework.Allocation;
 using osu.Framework.Audio;
 using osu.Framework.Audio.Sample;
+using osu.Framework.Audio.Track;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
@@ -15,7 +16,6 @@ using osuTK.Graphics;
 using osuTK.Input;
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Game.Graphics.Containers;
-using osu.Framework.Audio.Track;
 using osu.Framework.Graphics.Effects;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Input.Events;
@@ -132,7 +132,7 @@ namespace osu.Game.Screens.Menu
 
         private bool rightward;
 
-        protected override void OnNewBeat(int beatIndex, TimingControlPoint timingPoint, EffectControlPoint effectPoint, TrackAmplitudes amplitudes)
+        protected override void OnNewBeat(int beatIndex, TimingControlPoint timingPoint, EffectControlPoint effectPoint, ChannelAmplitudes amplitudes)
         {
             base.OnNewBeat(beatIndex, timingPoint, effectPoint, amplitudes);
 

osu.Game/Screens/Menu/ButtonSystem.cs

@@ -270,9 +270,6 @@ namespace osu.Game.Screens.Menu
                 ButtonSystemState lastState = state;
                 state = value;
 
-                if (game != null)
-                    game.OverlayActivationMode.Value = state == ButtonSystemState.Exit ? OverlayActivation.Disabled : OverlayActivation.All;
-
                 updateLogoState(lastState);
 
                 Logger.Log($"{nameof(ButtonSystem)}'s state changed from {lastState} to {state}");
@@ -324,10 +321,9 @@ namespace osu.Game.Screens.Menu
 
                             bool impact = logo.Scale.X > 0.6f;
 
-                            if (lastState == ButtonSystemState.Initial)
-                                logo.ScaleTo(0.5f, 200, Easing.In);
+                            logo.ScaleTo(0.5f, 200, Easing.In);
 
-                            logoTrackingContainer.StartTracking(logo, lastState == ButtonSystemState.EnteringMode ? 0 : 200, Easing.In);
+                            logoTrackingContainer.StartTracking(logo, 200, Easing.In);
 
                             logoDelayedAction?.Cancel();
                             logoDelayedAction = Scheduler.AddDelayed(() =>

osu.Game/Screens/Menu/ConfirmExitDialog.cs

@@ -0,0 +1,34 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using osu.Framework.Graphics.Sprites;
+using osu.Game.Overlays.Dialog;
+
+namespace osu.Game.Screens.Menu
+{
+    public class ConfirmExitDialog : PopupDialog
+    {
+        public ConfirmExitDialog(Action confirm, Action cancel)
+        {
+            HeaderText = "Are you sure you want to exit?";
+            BodyText = "Last chance to back out.";
+
+            Icon = FontAwesome.Solid.ExclamationTriangle;
+
+            Buttons = new PopupDialogButton[]
+            {
+                new PopupDialogOkButton
+                {
+                    Text = @"Goodbye",
+                    Action = confirm
+                },
+                new PopupDialogCancelButton
+                {
+                    Text = @"Just a little more",
+                    Action = cancel
+                },
+            };
+        }
+    }
+}

osu.Game/Screens/Menu/Disclaimer.cs

@@ -42,8 +42,11 @@ namespace osu.Game.Screens.Menu
             ValidForResume = false;
         }
 
+        [Resolved]
+        private IAPIProvider api { get; set; }
+
         [BackgroundDependencyLoader]
-        private void load(OsuColour colours, IAPIProvider api)
+        private void load(OsuColour colours)
         {
             InternalChildren = new Drawable[]
             {
@@ -51,7 +54,7 @@ namespace osu.Game.Screens.Menu
                 {
                     Anchor = Anchor.Centre,
                     Origin = Anchor.Centre,
-                    Icon = FontAwesome.Solid.Poo,
+                    Icon = FontAwesome.Solid.Flask,
                     Size = new Vector2(icon_size),
                     Y = icon_y,
                 },
@@ -104,7 +107,9 @@ namespace osu.Game.Screens.Menu
 
             iconColour = colours.Yellow;
 
-            currentUser.BindTo(api.LocalUser);
+            // manually transfer the user once, but only do the final bind in LoadComplete to avoid thread woes (API scheduler could run while this screen is still loading).
+            // the manual transfer is here to ensure all text content is loaded ahead of time as this is very early in the game load process and we want to avoid stutters.
+            currentUser.Value = api.LocalUser.Value;
             currentUser.BindValueChanged(e =>
             {
                 supportFlow.Children.ForEach(d => d.FadeOut().Expire());
@@ -141,6 +146,8 @@ namespace osu.Game.Screens.Menu
             base.LoadComplete();
             if (nextScreen != null)
                 LoadComponentAsync(nextScreen);
+
+            currentUser.BindTo(api.LocalUser);
         }
 
         public override void OnEntering(IScreen last)
@@ -190,7 +197,7 @@ namespace osu.Game.Screens.Menu
             {
                 "You can press Ctrl-T anywhere in the game to toggle the toolbar!",
                 "You can press Ctrl-O anywhere in the game to access options!",
-                "All settings are dynamic and take effect in real-time. Try changing the skin while playing!",
+                "All settings are dynamic and take effect in real-time. Try pausing and changing the skin while playing!",
                 "New features are coming online every update. Make sure to stay up-to-date!",
                 "If you find the UI too large or small, try adjusting UI scale in settings!",
                 "Try adjusting the \"Screen Scaling\" mode to change your gameplay or UI area, even in fullscreen!",

osu.Game/Screens/Menu/IntroCircles.cs

@@ -24,7 +24,7 @@ namespace osu.Game.Screens.Menu
         private void load(AudioManager audio)
         {
             if (MenuVoice.Value)
-                welcome = audio.Samples.Get(@"welcome");
+                welcome = audio.Samples.Get(@"Intro/welcome");
         }
 
         protected override void LogoArriving(OsuLogo logo, bool resuming)

osu.Game/Screens/Menu/IntroScreen.cs

@@ -12,6 +12,7 @@ using osu.Framework.Screens;
 using osu.Game.Beatmaps;
 using osu.Game.Configuration;
 using osu.Game.IO.Archives;
+using osu.Game.Overlays;
 using osu.Game.Screens.Backgrounds;
 using osu.Game.Skinning;
 using osuTK;
@@ -41,16 +42,16 @@ namespace osu.Game.Screens.Menu
 
         protected IBindable<bool> MenuMusic { get; private set; }
 
-        private WorkingBeatmap introBeatmap;
+        private WorkingBeatmap initialBeatmap;
 
-        protected Track Track { get; private set; }
-
-        private readonly BindableDouble exitingVolumeFade = new BindableDouble(1);
+        protected ITrack Track { get; private set; }
 
         private const int exit_delay = 3000;
 
         private SampleChannel seeya;
 
+        protected virtual string SeeyaSampleName => "Intro/seeya";
+
         private LeasedBindable<WorkingBeatmap> beatmap;
 
         private MainMenu mainMenu;
@@ -58,6 +59,15 @@ namespace osu.Game.Screens.Menu
         [Resolved]
         private AudioManager audio { get; set; }
 
+        [Resolved]
+        private MusicController musicController { get; set; }
+
+        /// <summary>
+        /// Whether the <see cref="Track"/> is provided by osu! resources, rather than a user beatmap.
+        /// Only valid during or after <see cref="LogoArriving"/>.
+        /// </summary>
+        protected bool UsingThemedIntro { get; private set; }
+
         [BackgroundDependencyLoader]
         private void load(OsuConfigManager config, SkinManager skinManager, BeatmapManager beatmaps, Framework.Game game)
         {
@@ -66,34 +76,48 @@ namespace osu.Game.Screens.Menu
 
             MenuVoice = config.GetBindable<bool>(OsuSetting.MenuVoice);
             MenuMusic = config.GetBindable<bool>(OsuSetting.MenuMusic);
-
-            seeya = audio.Samples.Get(@"seeya");
+            seeya = audio.Samples.Get(SeeyaSampleName);
 
             BeatmapSetInfo setInfo = null;
 
+            // if the user has requested not to play theme music, we should attempt to find a random beatmap from their collection.
             if (!MenuMusic.Value)
             {
                 var sets = beatmaps.GetAllUsableBeatmapSets(IncludedDetails.Minimal);
+
                 if (sets.Count > 0)
-                    setInfo = beatmaps.QueryBeatmapSet(s => s.ID == sets[RNG.Next(0, sets.Count - 1)].ID);
-            }
-
-            if (setInfo == null)
-            {
-                setInfo = beatmaps.QueryBeatmapSet(b => b.Hash == BeatmapHash);
-
-                if (setInfo == null)
                 {
-                    // we need to import the default menu background beatmap
-                    setInfo = beatmaps.Import(new ZipArchiveReader(game.Resources.GetStream($"Tracks/{BeatmapFile}"), BeatmapFile)).Result;
-
-                    setInfo.Protected = true;
-                    beatmaps.Update(setInfo);
+                    setInfo = beatmaps.QueryBeatmapSet(s => s.ID == sets[RNG.Next(0, sets.Count - 1)].ID);
+                    initialBeatmap = beatmaps.GetWorkingBeatmap(setInfo.Beatmaps[0]);
                 }
             }
 
-            introBeatmap = beatmaps.GetWorkingBeatmap(setInfo.Beatmaps[0]);
-            Track = introBeatmap.Track;
+            // we generally want a song to be playing on startup, so use the intro music even if a user has specified not to if no other track is available.
+            if (setInfo == null)
+            {
+                if (!loadThemedIntro())
+                {
+                    // if we detect that the theme track or beatmap is unavailable this is either first startup or things are in a bad state.
+                    // this could happen if a user has nuked their files store. for now, reimport to repair this.
+                    var import = beatmaps.Import(new ZipArchiveReader(game.Resources.GetStream($"Tracks/{BeatmapFile}"), BeatmapFile)).Result;
+                    import.Protected = true;
+                    beatmaps.Update(import);
+
+                    loadThemedIntro();
+                }
+            }
+
+            bool loadThemedIntro()
+            {
+                setInfo = beatmaps.QueryBeatmapSet(b => b.Hash == BeatmapHash);
+
+                if (setInfo != null)
+                {
+                    initialBeatmap = beatmaps.GetWorkingBeatmap(setInfo.Beatmaps[0]);
+                }
+
+                return UsingThemedIntro;
+            }
         }
 
         public override void OnResuming(IScreen last)
@@ -101,17 +125,35 @@ namespace osu.Game.Screens.Menu
             this.FadeIn(300);
 
             double fadeOutTime = exit_delay;
+
+            var track = musicController.CurrentTrack;
+
+            // ensure the track doesn't change or loop as we are exiting.
+            track.Looping = false;
+            Beatmap.Disabled = true;
+
             // we also handle the exit transition.
             if (MenuVoice.Value)
+            {
                 seeya.Play();
+
+                // if playing the outro voice, we have more time to have fun with the background track.
+                // initially fade to almost silent then ramp out over the remaining time.
+                const double initial_fade = 200;
+                track
+                    .VolumeTo(0.03f, initial_fade).Then()
+                    .VolumeTo(0, fadeOutTime - initial_fade, Easing.In);
+            }
             else
+            {
                 fadeOutTime = 500;
 
-            audio.AddAdjustment(AdjustableProperty.Volume, exitingVolumeFade);
-            this.TransformBindableTo(exitingVolumeFade, 0, fadeOutTime).OnComplete(_ => this.Exit());
+                // if outro voice is turned off, just do a simple fade out.
+                track.VolumeTo(0, fadeOutTime, Easing.Out);
+            }
 
             //don't want to fade out completely else we will stop running updates.
-            Game.FadeTo(0.01f, fadeOutTime);
+            Game.FadeTo(0.01f, fadeOutTime).OnComplete(_ => this.Exit());
 
             base.OnResuming(last);
         }
@@ -119,7 +161,7 @@ namespace osu.Game.Screens.Menu
         public override void OnSuspending(IScreen next)
         {
             base.OnSuspending(next);
-            Track = null;
+            initialBeatmap = null;
         }
 
         protected override BackgroundScreen CreateBackground() => new BackgroundScreenBlack();
@@ -127,7 +169,7 @@ namespace osu.Game.Screens.Menu
         protected void StartTrack()
         {
             // Only start the current track if it is the menu music. A beatmap's track is started when entering the Main Menu.
-            if (MenuMusic.Value)
+            if (UsingThemedIntro)
                 Track.Restart();
         }
 
@@ -141,8 +183,12 @@ namespace osu.Game.Screens.Menu
 
             if (!resuming)
             {
-                beatmap.Value = introBeatmap;
-                introBeatmap = null;
+                beatmap.Value = initialBeatmap;
+                Track = initialBeatmap.Track;
+                UsingThemedIntro = !initialBeatmap.Track.IsDummyDevice;
+
+                // ensure the track starts at maximum volume
+                musicController.CurrentTrack.FinishTransforms();
 
                 logo.MoveTo(new Vector2(0.5f));
                 logo.ScaleTo(Vector2.One);

osu.Game/Screens/Menu/IntroSequence.cs

@@ -205,6 +205,7 @@ namespace osu.Game.Screens.Menu
                 const int line_end_offset = 120;
 
                 smallRing.Foreground.ResizeTo(1, line_duration, Easing.OutQuint);
+                smallRing.Delay(400).FadeColour(Color4.Black, 300);
 
                 lineTopLeft.MoveTo(new Vector2(-line_end_offset, -line_end_offset), line_duration, Easing.OutQuint);
                 lineTopRight.MoveTo(new Vector2(line_end_offset, -line_end_offset), line_duration, Easing.OutQuint);

osu.Game/Screens/Menu/IntroTriangles.cs

@@ -3,7 +3,6 @@
 
 using System;
 using System.Collections.Generic;
-using System.IO;
 using osu.Framework.Allocation;
 using osu.Framework.Audio;
 using osu.Framework.Audio.Sample;
@@ -12,7 +11,6 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Graphics.Textures;
-using osu.Framework.Graphics.Video;
 using osu.Framework.Utils;
 using osu.Framework.Timing;
 using osu.Game.Graphics;
@@ -46,8 +44,8 @@ namespace osu.Game.Screens.Menu
         [BackgroundDependencyLoader]
         private void load()
         {
-            if (MenuVoice.Value && !MenuMusic.Value)
-                welcome = audio.Samples.Get(@"welcome");
+            if (MenuVoice.Value)
+                welcome = audio.Samples.Get(@"Intro/welcome");
         }
 
         protected override void LogoArriving(OsuLogo logo, bool resuming)
@@ -61,12 +59,13 @@ namespace osu.Game.Screens.Menu
                 LoadComponentAsync(new TrianglesIntroSequence(logo, background)
                 {
                     RelativeSizeAxes = Axes.Both,
-                    Clock = new FramedClock(MenuMusic.Value ? Track : null),
+                    Clock = new FramedClock(UsingThemedIntro ? Track : null),
                     LoadMenu = LoadMenu
                 }, t =>
                 {
                     AddInternal(t);
-                    welcome?.Play();
+                    if (!UsingThemedIntro)
+                        welcome?.Play();
 
                     StartTrack();
                 });
@@ -88,7 +87,7 @@ namespace osu.Game.Screens.Menu
             private RulesetFlow rulesets;
             private Container rulesetsScale;
             private Container logoContainerSecondary;
-            private Drawable lazerLogo;
+            private LazerLogo lazerLogo;
 
             private GlitchingTriangles triangles;
 
@@ -139,10 +138,10 @@ namespace osu.Game.Screens.Menu
                         RelativeSizeAxes = Axes.Both,
                         Anchor = Anchor.Centre,
                         Origin = Anchor.Centre,
-                        Child = lazerLogo = new LazerLogo(textures.GetStream("Menu/logo-triangles.mp4"))
+                        Child = lazerLogo = new LazerLogo
                         {
                             Anchor = Anchor.Centre,
-                            Origin = Anchor.Centre,
+                            Origin = Anchor.Centre
                         }
                     },
                 };
@@ -218,6 +217,9 @@ namespace osu.Game.Screens.Menu
 
                         // matching flyte curve y = 0.25x^2 + (max(0, x - 0.7) / 0.3) ^ 5
                         lazerLogo.FadeIn().ScaleTo(scale_start).Then().Delay(logo_scale_duration * 0.7f).ScaleTo(scale_start - scale_adjust, logo_scale_duration * 0.3f, Easing.InQuint);
+
+                        lazerLogo.TransformTo(nameof(LazerLogo.Progress), 1f, logo_scale_duration);
+
                         logoContainerSecondary.ScaleTo(scale_start).Then().ScaleTo(scale_start - scale_adjust * 0.25f, logo_scale_duration, Easing.InQuad);
                     }
 
@@ -259,20 +261,40 @@ namespace osu.Game.Screens.Menu
 
             private class LazerLogo : CompositeDrawable
             {
-                private readonly Stream videoStream;
+                private LogoAnimation highlight, background;
 
-                public LazerLogo(Stream videoStream)
+                public float Progress
+                {
+                    get => background.AnimationProgress;
+                    set
+                    {
+                        background.AnimationProgress = value;
+                        highlight.AnimationProgress = value;
+                    }
+                }
+
+                public LazerLogo()
                 {
-                    this.videoStream = videoStream;
                     Size = new Vector2(960);
                 }
 
                 [BackgroundDependencyLoader]
-                private void load()
+                private void load(TextureStore textures)
                 {
-                    InternalChild = new Video(videoStream)
+                    InternalChildren = new Drawable[]
                     {
-                        RelativeSizeAxes = Axes.Both,
+                        highlight = new LogoAnimation
+                        {
+                            RelativeSizeAxes = Axes.Both,
+                            Texture = textures.Get(@"Intro/Triangles/logo-highlight"),
+                            Colour = Color4.White,
+                        },
+                        background = new LogoAnimation
+                        {
+                            RelativeSizeAxes = Axes.Both,
+                            Texture = textures.Get(@"Intro/Triangles/logo-background"),
+                            Colour = OsuColour.Gray(0.6f),
+                        },
                     };
                 }
             }

osu.Game/Screens/Menu/IntroWelcome.cs

@@ -0,0 +1,152 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osuTK;
+using osu.Framework.Allocation;
+using osu.Framework.Audio;
+using osu.Framework.Audio.Sample;
+using osu.Framework.Screens;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Graphics.Sprites;
+using osu.Framework.Graphics.Textures;
+using osu.Game.Screens.Backgrounds;
+using osuTK.Graphics;
+
+namespace osu.Game.Screens.Menu
+{
+    public class IntroWelcome : IntroScreen
+    {
+        protected override string BeatmapHash => "64e00d7022195959bfa3109d09c2e2276c8f12f486b91fcf6175583e973b48f2";
+        protected override string BeatmapFile => "welcome.osz";
+        private const double delay_step_two = 2142;
+        private SampleChannel welcome;
+        private SampleChannel pianoReverb;
+        protected override string SeeyaSampleName => "Intro/Welcome/seeya";
+
+        protected override BackgroundScreen CreateBackground() => background = new BackgroundScreenDefault(false)
+        {
+            Alpha = 0,
+        };
+
+        private BackgroundScreenDefault background;
+
+        [BackgroundDependencyLoader]
+        private void load(AudioManager audio)
+        {
+            if (MenuVoice.Value)
+                welcome = audio.Samples.Get(@"Intro/Welcome/welcome");
+
+            pianoReverb = audio.Samples.Get(@"Intro/Welcome/welcome_piano");
+        }
+
+        protected override void LogoArriving(OsuLogo logo, bool resuming)
+        {
+            base.LogoArriving(logo, resuming);
+
+            if (!resuming)
+            {
+                Track.Looping = true;
+
+                LoadComponentAsync(new WelcomeIntroSequence
+                {
+                    RelativeSizeAxes = Axes.Both
+                }, intro =>
+                {
+                    PrepareMenuLoad();
+
+                    intro.LogoVisualisation.AddAmplitudeSource(pianoReverb);
+
+                    AddInternal(intro);
+
+                    welcome?.Play();
+                    pianoReverb?.Play();
+
+                    Scheduler.AddDelayed(() =>
+                    {
+                        StartTrack();
+
+                        const float fade_in_time = 200;
+
+                        logo.ScaleTo(1);
+                        logo.FadeIn(fade_in_time);
+
+                        background.FadeIn(fade_in_time);
+
+                        LoadMenu();
+                    }, delay_step_two);
+                });
+            }
+        }
+
+        public override void OnResuming(IScreen last)
+        {
+            base.OnResuming(last);
+            background.FadeOut(100);
+        }
+
+        private class WelcomeIntroSequence : Container
+        {
+            private Sprite welcomeText;
+            private Container scaleContainer;
+
+            public LogoVisualisation LogoVisualisation { get; private set; }
+
+            [BackgroundDependencyLoader]
+            private void load(TextureStore textures)
+            {
+                Origin = Anchor.Centre;
+                Anchor = Anchor.Centre;
+
+                Children = new Drawable[]
+                {
+                    scaleContainer = new Container
+                    {
+                        AutoSizeAxes = Axes.Both,
+                        Anchor = Anchor.Centre,
+                        Origin = Anchor.Centre,
+                        Children = new Drawable[]
+                        {
+                            LogoVisualisation = new LogoVisualisation
+                            {
+                                RelativeSizeAxes = Axes.Both,
+                                Anchor = Anchor.Centre,
+                                Origin = Anchor.Centre,
+                                Alpha = 0.5f,
+                                AccentColour = Color4.DarkBlue,
+                                Size = new Vector2(0.96f)
+                            },
+                            new Circle
+                            {
+                                Anchor = Anchor.Centre,
+                                Origin = Anchor.Centre,
+                                Size = new Vector2(480),
+                                Colour = Color4.Black
+                            },
+                            welcomeText = new Sprite
+                            {
+                                Anchor = Anchor.Centre,
+                                Origin = Anchor.Centre,
+                                Texture = textures.Get(@"Intro/Welcome/welcome_text")
+                            },
+                        }
+                    },
+                };
+            }
+
+            protected override void LoadComplete()
+            {
+                base.LoadComplete();
+
+                using (BeginDelayedSequence(0, true))
+                {
+                    scaleContainer.ScaleTo(0.9f).ScaleTo(1, delay_step_two).OnComplete(_ => Expire());
+                    scaleContainer.FadeInFromZero(1800);
+
+                    welcomeText.ScaleTo(new Vector2(1, 0)).ScaleTo(Vector2.One, 400, Easing.Out);
+                }
+            }
+        }
+    }
+}

osu.Game/Screens/Menu/LogoVisualisation.cs

@@ -12,17 +12,20 @@ using osu.Framework.Graphics.Shaders;
 using osu.Framework.Graphics.Textures;
 using osu.Game.Beatmaps;
 using osu.Game.Graphics;
-using osu.Game.Skinning;
-using osu.Game.Online.API;
-using osu.Game.Users;
 using System;
+using System.Collections.Generic;
+using JetBrains.Annotations;
 using osu.Framework.Allocation;
+using osu.Framework.Audio;
+using osu.Framework.Audio.Track;
 using osu.Framework.Bindables;
-using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Utils;
 
 namespace osu.Game.Screens.Menu
 {
+    /// <summary>
+    /// A visualiser that reacts to music coming from beatmaps.
+    /// </summary>
     public class LogoVisualisation : Drawable, IHasAccentColour
     {
         private readonly IBindable<WorkingBeatmap> beatmap = new Bindable<WorkingBeatmap>();
@@ -66,68 +69,63 @@ namespace osu.Game.Screens.Menu
 
         public Color4 AccentColour { get; set; }
 
+        /// <summary>
+        /// The relative movement of bars based on input amplification. Defaults to 1.
+        /// </summary>
+        public float Magnitude { get; set; } = 1;
+
         private readonly float[] frequencyAmplitudes = new float[256];
 
         private IShader shader;
         private readonly Texture texture;
 
-        private Bindable<User> user;
-        private Bindable<Skin> skin;
-
         public LogoVisualisation()
         {
             texture = Texture.WhitePixel;
             Blending = BlendingParameters.Additive;
         }
 
+        private readonly List<IHasAmplitudes> amplitudeSources = new List<IHasAmplitudes>();
+
+        public void AddAmplitudeSource(IHasAmplitudes amplitudeSource)
+        {
+            amplitudeSources.Add(amplitudeSource);
+        }
+
         [BackgroundDependencyLoader]
-        private void load(ShaderManager shaders, IBindable<WorkingBeatmap> beatmap, IAPIProvider api, SkinManager skinManager)
+        private void load(ShaderManager shaders, IBindable<WorkingBeatmap> beatmap)
         {
             this.beatmap.BindTo(beatmap);
             shader = shaders.Load(VertexShaderDescriptor.TEXTURE_2, FragmentShaderDescriptor.TEXTURE_ROUNDED);
-            user = api.LocalUser.GetBoundCopy();
-            skin = skinManager.CurrentSkin.GetBoundCopy();
-
-            user.ValueChanged += _ => updateColour();
-            skin.BindValueChanged(_ => updateColour(), true);
         }
 
+        private readonly float[] temporalAmplitudes = new float[ChannelAmplitudes.AMPLITUDES_SIZE];
+
         private void updateAmplitudes()
         {
-            var track = beatmap.Value.TrackLoaded ? beatmap.Value.Track : null;
-            var effect = beatmap.Value.BeatmapLoaded ? beatmap.Value.Beatmap?.ControlPointInfo.EffectPointAt(track?.CurrentTime ?? Time.Current) : null;
+            var effect = beatmap.Value.BeatmapLoaded && beatmap.Value.TrackLoaded
+                ? beatmap.Value.Beatmap?.ControlPointInfo.EffectPointAt(beatmap.Value.Track.CurrentTime)
+                : null;
 
-            float[] temporalAmplitudes = track?.CurrentAmplitudes.FrequencyAmplitudes;
+            for (int i = 0; i < temporalAmplitudes.Length; i++)
+                temporalAmplitudes[i] = 0;
+
+            if (beatmap.Value.TrackLoaded)
+                addAmplitudesFromSource(beatmap.Value.Track);
+
+            foreach (var source in amplitudeSources)
+                addAmplitudesFromSource(source);
 
             for (int i = 0; i < bars_per_visualiser; i++)
             {
-                if (track?.IsRunning ?? false)
-                {
-                    float targetAmplitude = (temporalAmplitudes?[(i + indexOffset) % bars_per_visualiser] ?? 0) * (effect?.KiaiMode == true ? 1 : 0.5f);
-                    if (targetAmplitude > frequencyAmplitudes[i])
-                        frequencyAmplitudes[i] = targetAmplitude;
-                }
-                else
-                {
-                    int index = (i + index_change) % bars_per_visualiser;
-                    if (frequencyAmplitudes[index] > frequencyAmplitudes[i])
-                        frequencyAmplitudes[i] = frequencyAmplitudes[index];
-                }
+                float targetAmplitude = (temporalAmplitudes[(i + indexOffset) % bars_per_visualiser]) * (effect?.KiaiMode == true ? 1 : 0.5f);
+                if (targetAmplitude > frequencyAmplitudes[i])
+                    frequencyAmplitudes[i] = targetAmplitude;
             }
 
             indexOffset = (indexOffset + index_change) % bars_per_visualiser;
         }
 
-        private void updateColour()
-        {
-            Color4 defaultColour = Color4.White.Opacity(0.2f);
-
-            if (user.Value?.IsSupporter ?? false)
-                AccentColour = skin.Value.GetConfig<GlobalSkinColours, Color4>(GlobalSkinColours.MenuGlow)?.Value ?? defaultColour;
-            else
-                AccentColour = defaultColour;
-        }
-
         protected override void LoadComplete()
         {
             base.LoadComplete();
@@ -155,6 +153,19 @@ namespace osu.Game.Screens.Menu
 
         protected override DrawNode CreateDrawNode() => new VisualisationDrawNode(this);
 
+        private void addAmplitudesFromSource([NotNull] IHasAmplitudes source)
+        {
+            if (source == null) throw new ArgumentNullException(nameof(source));
+
+            var amplitudes = source.CurrentAmplitudes.FrequencyAmplitudes.Span;
+
+            for (int i = 0; i < amplitudes.Length; i++)
+            {
+                if (i < temporalAmplitudes.Length)
+                    temporalAmplitudes[i] += amplitudes[i];
+            }
+        }
+
         private class VisualisationDrawNode : DrawNode
         {
             protected new LogoVisualisation Source => (LogoVisualisation)base.Source;

osu.Game/Screens/Menu/MainMenu.cs

@@ -1,22 +1,20 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-using System;
 using System.Linq;
 using osuTK;
 using osuTK.Graphics;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
-using osu.Framework.Graphics.Sprites;
 using osu.Framework.Platform;
 using osu.Framework.Screens;
 using osu.Game.Configuration;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Containers;
+using osu.Game.IO;
 using osu.Game.Online.API;
 using osu.Game.Overlays;
-using osu.Game.Overlays.Dialog;
 using osu.Game.Screens.Backgrounds;
 using osu.Game.Screens.Edit;
 using osu.Game.Screens.Multi;
@@ -47,8 +45,8 @@ namespace osu.Game.Screens.Menu
         [Resolved]
         private GameHost host { get; set; }
 
-        [Resolved(canBeNull: true)]
-        private MusicController music { get; set; }
+        [Resolved]
+        private MusicController musicController { get; set; }
 
         [Resolved(canBeNull: true)]
         private LoginOverlay login { get; set; }
@@ -100,7 +98,11 @@ namespace osu.Game.Screens.Menu
                     {
                         buttons = new ButtonSystem
                         {
-                            OnEdit = delegate { this.Push(new Editor()); },
+                            OnEdit = delegate
+                            {
+                                Beatmap.SetDefault();
+                                this.Push(new Editor());
+                            },
                             OnSolo = onSolo,
                             OnMulti = delegate { this.Push(new Multiplayer()); },
                             OnExit = confirmAndExit,
@@ -168,22 +170,27 @@ namespace osu.Game.Screens.Menu
             return s;
         }
 
+        [Resolved]
+        private Storage storage { get; set; }
+
         public override void OnEntering(IScreen last)
         {
             base.OnEntering(last);
             buttons.FadeInFromZero(500);
 
-            var track = Beatmap.Value.Track;
             var metadata = Beatmap.Value.Metadata;
 
-            if (last is IntroScreen && track != null)
+            if (last is IntroScreen && musicController.TrackLoaded)
             {
-                if (!track.IsRunning)
+                if (!musicController.CurrentTrack.IsRunning)
                 {
-                    track.Seek(metadata.PreviewTime != -1 ? metadata.PreviewTime : 0.4f * track.Length);
-                    track.Start();
+                    musicController.CurrentTrack.Seek(metadata.PreviewTime != -1 ? metadata.PreviewTime : 0.4f * musicController.CurrentTrack.Length);
+                    musicController.CurrentTrack.Start();
                 }
             }
+
+            if (storage is OsuStorage osuStorage && osuStorage.Error != OsuStorageError.None)
+                dialogOverlay?.Push(new StorageErrorDialog(osuStorage, osuStorage.Error));
         }
 
         private bool exitConfirmed;
@@ -253,8 +260,7 @@ namespace osu.Game.Screens.Menu
             // we may have consumed our preloaded instance, so let's make another.
             preloadSongSelect();
 
-            if (Beatmap.Value.Track != null && music?.IsUserPaused != true)
-                Beatmap.Value.Track.Start();
+            musicController.EnsurePlayingSomething();
         }
 
         public override bool OnExiting(IScreen next)
@@ -274,36 +280,12 @@ namespace osu.Game.Screens.Menu
             }
 
             buttons.State = ButtonSystemState.Exit;
+            OverlayActivationMode.Value = OverlayActivation.Disabled;
 
             songTicker.Hide();
 
             this.FadeOut(3000);
             return base.OnExiting(next);
         }
-
-        private class ConfirmExitDialog : PopupDialog
-        {
-            public ConfirmExitDialog(Action confirm, Action cancel)
-            {
-                HeaderText = "Are you sure you want to exit?";
-                BodyText = "Last chance to back out.";
-
-                Icon = FontAwesome.Solid.ExclamationTriangle;
-
-                Buttons = new PopupDialogButton[]
-                {
-                    new PopupDialogOkButton
-                    {
-                        Text = @"Goodbye",
-                        Action = confirm
-                    },
-                    new PopupDialogCancelButton
-                    {
-                        Text = @"Just a little more",
-                        Action = cancel
-                    },
-                };
-            }
-        }
     }
 }

osu.Game/Screens/Menu/MenuLogoVisualisation.cs

@@ -0,0 +1,39 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osuTK.Graphics;
+using osu.Game.Skinning;
+using osu.Game.Online.API;
+using osu.Game.Users;
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Extensions.Color4Extensions;
+
+namespace osu.Game.Screens.Menu
+{
+    internal class MenuLogoVisualisation : LogoVisualisation
+    {
+        private Bindable<User> user;
+        private Bindable<Skin> skin;
+
+        [BackgroundDependencyLoader]
+        private void load(IAPIProvider api, SkinManager skinManager)
+        {
+            user = api.LocalUser.GetBoundCopy();
+            skin = skinManager.CurrentSkin.GetBoundCopy();
+
+            user.ValueChanged += _ => updateColour();
+            skin.BindValueChanged(_ => updateColour(), true);
+        }
+
+        private void updateColour()
+        {
+            Color4 defaultColour = Color4.White.Opacity(0.2f);
+
+            if (user.Value?.IsSupporter ?? false)
+                AccentColour = skin.Value.GetConfig<GlobalSkinColours, Color4>(GlobalSkinColours.MenuGlow)?.Value ?? defaultColour;
+            else
+                AccentColour = defaultColour;
+        }
+    }
+}

osu.Game/Screens/Menu/MenuSideFlashes.cs

@@ -3,7 +3,6 @@
 
 using osuTK.Graphics;
 using osu.Framework.Allocation;
-using osu.Framework.Audio.Track;
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Colour;
@@ -16,6 +15,7 @@ using osu.Game.Skinning;
 using osu.Game.Online.API;
 using osu.Game.Users;
 using System;
+using osu.Framework.Audio.Track;
 using osu.Framework.Bindables;
 
 namespace osu.Game.Screens.Menu
@@ -89,7 +89,7 @@ namespace osu.Game.Screens.Menu
             skin.BindValueChanged(_ => updateColour(), true);
         }
 
-        protected override void OnNewBeat(int beatIndex, TimingControlPoint timingPoint, EffectControlPoint effectPoint, TrackAmplitudes amplitudes)
+        protected override void OnNewBeat(int beatIndex, TimingControlPoint timingPoint, EffectControlPoint effectPoint, ChannelAmplitudes amplitudes)
         {
             if (beatIndex < 0)
                 return;
@@ -100,7 +100,7 @@ namespace osu.Game.Screens.Menu
                 flash(rightBox, timingPoint.BeatLength, effectPoint.KiaiMode, amplitudes);
         }
 
-        private void flash(Drawable d, double beatLength, bool kiai, TrackAmplitudes amplitudes)
+        private void flash(Drawable d, double beatLength, bool kiai, ChannelAmplitudes amplitudes)
         {
             d.FadeTo(Math.Max(0, ((ReferenceEquals(d, leftBox) ? amplitudes.LeftChannel : amplitudes.RightChannel) - amplitude_dead_zone) / (kiai ? kiai_multiplier : alpha_multiplier)), box_fade_in_time)
              .Then()

osu.Game/Screens/Menu/OsuLogo.cs

@@ -17,6 +17,7 @@ using osu.Framework.Utils;
 using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Graphics.Backgrounds;
 using osu.Game.Graphics.Containers;
+using osu.Game.Overlays;
 using osuTK;
 using osuTK.Graphics;
 using osuTK.Input;
@@ -38,7 +39,7 @@ namespace osu.Game.Screens.Menu
         private readonly Container logoBeatContainer;
         private readonly Container logoAmplitudeContainer;
         private readonly Container logoHoverContainer;
-        private readonly LogoVisualisation visualizer;
+        private readonly MenuLogoVisualisation visualizer;
 
         private readonly IntroSequence intro;
 
@@ -46,7 +47,6 @@ namespace osu.Game.Screens.Menu
         private SampleChannel sampleBeat;
 
         private readonly Container colourAndTriangles;
-
         private readonly Triangles triangles;
 
         /// <summary>
@@ -139,7 +139,7 @@ namespace osu.Game.Screens.Menu
                                             AutoSizeAxes = Axes.Both,
                                             Children = new Drawable[]
                                             {
-                                                visualizer = new LogoVisualisation
+                                                visualizer = new MenuLogoVisualisation
                                                 {
                                                     RelativeSizeAxes = Axes.Both,
                                                     Origin = Anchor.Centre,
@@ -264,7 +264,7 @@ namespace osu.Game.Screens.Menu
 
         private int lastBeatIndex;
 
-        protected override void OnNewBeat(int beatIndex, TimingControlPoint timingPoint, EffectControlPoint effectPoint, TrackAmplitudes amplitudes)
+        protected override void OnNewBeat(int beatIndex, TimingControlPoint timingPoint, EffectControlPoint effectPoint, ChannelAmplitudes amplitudes)
         {
             base.OnNewBeat(beatIndex, timingPoint, effectPoint, amplitudes);
 
@@ -319,6 +319,9 @@ namespace osu.Game.Screens.Menu
             intro.Delay(length + fade).FadeOut();
         }
 
+        [Resolved]
+        private MusicController musicController { get; set; }
+
         protected override void Update()
         {
             base.Update();
@@ -327,10 +330,10 @@ namespace osu.Game.Screens.Menu
             const float velocity_adjust_cutoff = 0.98f;
             const float paused_velocity = 0.5f;
 
-            if (Beatmap.Value.Track.IsRunning)
+            if (musicController.CurrentTrack.IsRunning)
             {
-                var maxAmplitude = lastBeatIndex >= 0 ? Beatmap.Value.Track.CurrentAmplitudes.Maximum : 0;
-                logoAmplitudeContainer.ScaleTo(1 - Math.Max(0, maxAmplitude - scale_adjust_cutoff) * 0.04f, 75, Easing.OutQuint);
+                var maxAmplitude = lastBeatIndex >= 0 ? musicController.CurrentTrack.CurrentAmplitudes.Maximum : 0;
+                logoAmplitudeContainer.Scale = new Vector2((float)Interpolation.Damp(logoAmplitudeContainer.Scale.X, 1 - Math.Max(0, maxAmplitude - scale_adjust_cutoff) * 0.04f, 0.9f, Time.Elapsed));
 
                 if (maxAmplitude > velocity_adjust_cutoff)
                     triangles.Velocity = 1 + Math.Max(0, maxAmplitude - velocity_adjust_cutoff) * 50;

osu.Game/Screens/Menu/StorageErrorDialog.cs

@@ -0,0 +1,79 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Collections.Generic;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics.Sprites;
+using osu.Game.IO;
+using osu.Game.Overlays;
+using osu.Game.Overlays.Dialog;
+
+namespace osu.Game.Screens.Menu
+{
+    public class StorageErrorDialog : PopupDialog
+    {
+        [Resolved]
+        private DialogOverlay dialogOverlay { get; set; }
+
+        [Resolved]
+        private OsuGameBase osuGame { get; set; }
+
+        public StorageErrorDialog(OsuStorage storage, OsuStorageError error)
+        {
+            HeaderText = "osu! storage error";
+            Icon = FontAwesome.Solid.ExclamationTriangle;
+
+            var buttons = new List<PopupDialogButton>();
+
+            switch (error)
+            {
+                case OsuStorageError.NotAccessible:
+                    BodyText = $"The specified osu! data location (\"{storage.CustomStoragePath}\") is not accessible. If it is on external storage, please reconnect the device and try again.";
+
+                    buttons.AddRange(new PopupDialogButton[]
+                    {
+                        new PopupDialogCancelButton
+                        {
+                            Text = "Try again",
+                            Action = () =>
+                            {
+                                if (!storage.TryChangeToCustomStorage(out var nextError))
+                                    dialogOverlay.Push(new StorageErrorDialog(storage, nextError));
+                            }
+                        },
+                        new PopupDialogCancelButton
+                        {
+                            Text = "Use default location until restart",
+                        },
+                        new PopupDialogOkButton
+                        {
+                            Text = "Reset to default location",
+                            Action = storage.ResetCustomStoragePath
+                        },
+                    });
+                    break;
+
+                case OsuStorageError.AccessibleButEmpty:
+                    BodyText = $"The specified osu! data location (\"{storage.CustomStoragePath}\") is empty. If you have moved the files, please close osu! and move them back.";
+
+                    // Todo: Provide the option to search for the files similar to migration.
+                    buttons.AddRange(new PopupDialogButton[]
+                    {
+                        new PopupDialogCancelButton
+                        {
+                            Text = "Start fresh at specified location"
+                        },
+                        new PopupDialogOkButton
+                        {
+                            Text = "Reset to default location",
+                            Action = storage.ResetCustomStoragePath
+                        },
+                    });
+
+                    break;
+            }
+
+            Buttons = buttons;
+        }
+    }
+}

osu.Game/Screens/Multi/Components/ModeTypeInfo.cs

@@ -60,7 +60,7 @@ namespace osu.Game.Screens.Multi.Components
             if (item?.Beatmap != null)
             {
                 drawableRuleset.FadeIn(transition_duration);
-                drawableRuleset.Child = new DifficultyIcon(item.Beatmap.Value, item.Ruleset.Value) { Size = new Vector2(height) };
+                drawableRuleset.Child = new DifficultyIcon(item.Beatmap.Value, item.Ruleset.Value, item.RequiredMods) { Size = new Vector2(height) };
             }
             else
                 drawableRuleset.FadeOut(transition_duration);

osu.Game/Screens/Multi/Components/OverlinedDisplay.cs

@@ -1,116 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-using osu.Framework.Allocation;
-using osu.Framework.Graphics;
-using osu.Framework.Graphics.Containers;
-using osu.Framework.Graphics.Shapes;
-using osu.Game.Graphics;
-using osu.Game.Graphics.Sprites;
-using osuTK;
-
-namespace osu.Game.Screens.Multi.Components
-{
-    public abstract class OverlinedDisplay : MultiplayerComposite
-    {
-        protected readonly Container Content;
-
-        public override Axes RelativeSizeAxes
-        {
-            get => base.RelativeSizeAxes;
-            set
-            {
-                base.RelativeSizeAxes = value;
-                updateDimensions();
-            }
-        }
-
-        public override Axes AutoSizeAxes
-        {
-            get => base.AutoSizeAxes;
-            protected set
-            {
-                base.AutoSizeAxes = value;
-                updateDimensions();
-            }
-        }
-
-        protected string Details
-        {
-            set => details.Text = value;
-        }
-
-        private readonly Circle line;
-        private readonly OsuSpriteText details;
-        private readonly GridContainer grid;
-
-        protected OverlinedDisplay(string title)
-        {
-            InternalChild = grid = new GridContainer
-            {
-                Content = new[]
-                {
-                    new Drawable[]
-                    {
-                        line = new Circle
-                        {
-                            RelativeSizeAxes = Axes.X,
-                            Height = 2,
-                            Margin = new MarginPadding { Bottom = 2 }
-                        },
-                    },
-                    new Drawable[]
-                    {
-                        new FillFlowContainer
-                        {
-                            AutoSizeAxes = Axes.Both,
-                            Direction = FillDirection.Horizontal,
-                            Margin = new MarginPadding { Top = 5 },
-                            Spacing = new Vector2(10, 0),
-                            Children = new Drawable[]
-                            {
-                                new OsuSpriteText
-                                {
-                                    Text = title,
-                                    Font = OsuFont.GetFont(size: 14)
-                                },
-                                details = new OsuSpriteText { Font = OsuFont.GetFont(size: 14) },
-                            }
-                        },
-                    },
-                    new Drawable[]
-                    {
-                        Content = new Container { Margin = new MarginPadding { Top = 5 } }
-                    }
-                }
-            };
-
-            updateDimensions();
-        }
-
-        [BackgroundDependencyLoader]
-        private void load(OsuColour colours)
-        {
-            line.Colour = colours.Yellow;
-            details.Colour = colours.Yellow;
-        }
-
-        private void updateDimensions()
-        {
-            grid.RowDimensions = new[]
-            {
-                new Dimension(GridSizeMode.AutoSize),
-                new Dimension(GridSizeMode.AutoSize),
-                new Dimension(AutoSizeAxes.HasFlag(Axes.Y) ? GridSizeMode.AutoSize : GridSizeMode.Distributed),
-            };
-
-            // Assigning to none is done so that setting auto and relative size modes doesn't cause exceptions to be thrown
-            grid.AutoSizeAxes = Content.AutoSizeAxes = Axes.None;
-            grid.RelativeSizeAxes = Content.RelativeSizeAxes = Axes.None;
-
-            // Auto-size when required, otherwise eagerly relative-size
-            grid.AutoSizeAxes = Content.AutoSizeAxes = AutoSizeAxes;
-            grid.RelativeSizeAxes = Content.RelativeSizeAxes = ~AutoSizeAxes;
-        }
-    }
-}

osu.Game/Screens/Multi/Components/OverlinedHeader.cs

@@ -0,0 +1,89 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Game.Graphics;
+using osu.Game.Graphics.Sprites;
+using osuTK;
+
+namespace osu.Game.Screens.Multi.Components
+{
+    /// <summary>
+    /// A header used in the multiplayer interface which shows text / details beneath a line.
+    /// </summary>
+    public class OverlinedHeader : MultiplayerComposite
+    {
+        private bool showLine = true;
+
+        public bool ShowLine
+        {
+            get => showLine;
+            set
+            {
+                showLine = value;
+                line.Alpha = value ? 1 : 0;
+            }
+        }
+
+        public Bindable<string> Details = new Bindable<string>();
+
+        private readonly Circle line;
+        private readonly OsuSpriteText details;
+
+        public OverlinedHeader(string title)
+        {
+            RelativeSizeAxes = Axes.X;
+            AutoSizeAxes = Axes.Y;
+
+            Margin = new MarginPadding { Bottom = 5 };
+
+            InternalChild = new FillFlowContainer
+            {
+                RelativeSizeAxes = Axes.X,
+                AutoSizeAxes = Axes.Y,
+                Direction = FillDirection.Vertical,
+                Children = new Drawable[]
+                {
+                    line = new Circle
+                    {
+                        RelativeSizeAxes = Axes.X,
+                        Height = 2,
+                        Margin = new MarginPadding { Bottom = 2 }
+                    },
+                    new FillFlowContainer
+                    {
+                        AutoSizeAxes = Axes.Both,
+                        Direction = FillDirection.Horizontal,
+                        Margin = new MarginPadding { Top = 5 },
+                        Spacing = new Vector2(10, 0),
+                        Children = new Drawable[]
+                        {
+                            new OsuSpriteText
+                            {
+                                Text = title,
+                                Font = OsuFont.GetFont(size: 14, weight: FontWeight.SemiBold)
+                            },
+                            details = new OsuSpriteText
+                            {
+                                Font = OsuFont.GetFont(size: 14, weight: FontWeight.SemiBold)
+                            },
+                        }
+                    },
+                }
+            };
+
+            Details.BindValueChanged(val => details.Text = val.NewValue);
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(OsuColour colours)
+        {
+            line.Colour = colours.Yellow;
+            details.Colour = colours.Yellow;
+        }
+    }
+}

osu.Game/Screens/Multi/Components/OverlinedPlaylist.cs

@@ -1,33 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-using osu.Framework.Allocation;
-using osu.Framework.Bindables;
-using osu.Framework.Graphics;
-using osu.Game.Online.Multiplayer;
-
-namespace osu.Game.Screens.Multi.Components
-{
-    public class OverlinedPlaylist : OverlinedDisplay
-    {
-        public readonly Bindable<PlaylistItem> SelectedItem = new Bindable<PlaylistItem>();
-
-        private readonly DrawableRoomPlaylist playlist;
-
-        public OverlinedPlaylist(bool allowSelection)
-            : base("Playlist")
-        {
-            Content.Add(playlist = new DrawableRoomPlaylist(false, allowSelection)
-            {
-                RelativeSizeAxes = Axes.Both,
-                SelectedItem = { BindTarget = SelectedItem }
-            });
-        }
-
-        [BackgroundDependencyLoader]
-        private void load()
-        {
-            playlist.Items.BindTo(Playlist);
-        }
-    }
-}

osu.Game/Screens/Multi/Components/ParticipantsDisplay.cs

@@ -2,26 +2,22 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using osu.Framework.Allocation;
+using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Game.Graphics.Containers;
 
 namespace osu.Game.Screens.Multi.Components
 {
-    public class OverlinedParticipants : OverlinedDisplay
+    public class ParticipantsDisplay : MultiplayerComposite
     {
-        public new Axes AutoSizeAxes
-        {
-            get => base.AutoSizeAxes;
-            set => base.AutoSizeAxes = value;
-        }
+        public Bindable<string> Details = new Bindable<string>();
 
-        public OverlinedParticipants(Direction direction)
-            : base("Recent participants")
+        public ParticipantsDisplay(Direction direction)
         {
             OsuScrollContainer scroll;
             ParticipantsList list;
 
-            Content.Add(scroll = new OsuScrollContainer(direction)
+            AddInternal(scroll = new OsuScrollContainer(direction)
             {
                 Child = list = new ParticipantsList()
             });
@@ -29,13 +25,21 @@ namespace osu.Game.Screens.Multi.Components
             switch (direction)
             {
                 case Direction.Horizontal:
+                    AutoSizeAxes = Axes.Y;
+                    RelativeSizeAxes = Axes.X;
+
                     scroll.RelativeSizeAxes = Axes.X;
                     scroll.Height = ParticipantsList.TILE_SIZE + OsuScrollContainer.SCROLL_BAR_HEIGHT + OsuScrollContainer.SCROLL_BAR_PADDING * 2;
-                    list.AutoSizeAxes = Axes.Both;
+
+                    list.RelativeSizeAxes = Axes.Y;
+                    list.AutoSizeAxes = Axes.X;
                     break;
 
                 case Direction.Vertical:
+                    RelativeSizeAxes = Axes.Both;
+
                     scroll.RelativeSizeAxes = Axes.Both;
+
                     list.RelativeSizeAxes = Axes.X;
                     list.AutoSizeAxes = Axes.Y;
                     break;
@@ -46,11 +50,10 @@ namespace osu.Game.Screens.Multi.Components
         private void load()
         {
             ParticipantCount.BindValueChanged(_ => setParticipantCount());
-            MaxParticipants.BindValueChanged(_ => setParticipantCount());
-
-            setParticipantCount();
+            MaxParticipants.BindValueChanged(_ => setParticipantCount(), true);
         }
 
-        private void setParticipantCount() => Details = MaxParticipants.Value != null ? $"{ParticipantCount.Value}/{MaxParticipants.Value}" : ParticipantCount.Value.ToString();
+        private void setParticipantCount() =>
+            Details.Value = MaxParticipants.Value != null ? $"{ParticipantCount.Value}/{MaxParticipants.Value}" : ParticipantCount.Value.ToString();
     }
 }

osu.Game/Screens/Multi/Components/ParticipantsList.cs

@@ -79,7 +79,7 @@ namespace osu.Game.Screens.Multi.Components
                     Direction = Direction,
                     AutoSizeAxes = AutoSizeAxes,
                     RelativeSizeAxes = RelativeSizeAxes,
-                    Spacing = new Vector2(10)
+                    Spacing = Vector2.One
                 };
 
                 for (int i = 0; i < RecentParticipants.Count; i++)

osu.Game/Screens/Multi/Components/StatusColouredContainer.cs

@@ -17,6 +17,9 @@ namespace osu.Game.Screens.Multi.Components
         [Resolved(typeof(Room), nameof(Room.Status))]
         private Bindable<RoomStatus> status { get; set; }
 
+        [Resolved(typeof(Room), nameof(Room.Category))]
+        private Bindable<RoomCategory> category { get; set; }
+
         public StatusColouredContainer(double transitionDuration = 100)
         {
             this.transitionDuration = transitionDuration;
@@ -25,7 +28,11 @@ namespace osu.Game.Screens.Multi.Components
         [BackgroundDependencyLoader]
         private void load(OsuColour colours)
         {
-            status.BindValueChanged(s => this.FadeColour(s.NewValue.GetAppropriateColour(colours), transitionDuration), true);
+            status.BindValueChanged(s =>
+            {
+                this.FadeColour(category.Value == RoomCategory.Spotlight ? colours.Pink : s.NewValue.GetAppropriateColour(colours)
+                    , transitionDuration);
+            }, true);
         }
     }
 }

osu.Game/Screens/Multi/DrawableRoomPlaylist.cs

@@ -60,8 +60,6 @@ namespace osu.Game.Screens.Multi
             RequestDeletion = requestDeletion
         };
 
-        private void requestSelection(PlaylistItem item) => SelectedItem.Value = item;
-
         private void requestDeletion(PlaylistItem item)
         {
             if (SelectedItem.Value == item)

osu.Game/Screens/Multi/DrawableRoomPlaylistItem.cs

@@ -2,6 +2,7 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
+using System.Collections.Generic;
 using System.Linq;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
@@ -36,8 +37,6 @@ namespace osu.Game.Screens.Multi
 
         public readonly Bindable<PlaylistItem> SelectedItem = new Bindable<PlaylistItem>();
 
-        protected override bool ShowDragHandle => allowEdit;
-
         private Container maskingContainer;
         private Container difficultyIconContainer;
         private LinkFlowContainer beatmapText;
@@ -48,7 +47,8 @@ namespace osu.Game.Screens.Multi
         private readonly Bindable<RulesetInfo> ruleset = new Bindable<RulesetInfo>();
         private readonly BindableList<Mod> requiredMods = new BindableList<Mod>();
 
-        private readonly PlaylistItem item;
+        public readonly PlaylistItem Item;
+
         private readonly bool allowEdit;
         private readonly bool allowSelection;
 
@@ -57,13 +57,17 @@ namespace osu.Game.Screens.Multi
         public DrawableRoomPlaylistItem(PlaylistItem item, bool allowEdit, bool allowSelection)
             : base(item)
         {
-            this.item = item;
+            Item = item;
+
+            // TODO: edit support should be moved out into a derived class
             this.allowEdit = allowEdit;
             this.allowSelection = allowSelection;
 
             beatmap.BindTo(item.Beatmap);
             ruleset.BindTo(item.Ruleset);
             requiredMods.BindTo(item.RequiredMods);
+
+            ShowDragHandle.Value = allowEdit;
         }
 
         [BackgroundDependencyLoader]
@@ -99,17 +103,17 @@ namespace osu.Game.Screens.Multi
 
         private void refresh()
         {
-            difficultyIconContainer.Child = new DifficultyIcon(beatmap.Value, ruleset.Value) { Size = new Vector2(32) };
+            difficultyIconContainer.Child = new DifficultyIcon(beatmap.Value, ruleset.Value, requiredMods) { Size = new Vector2(32) };
 
             beatmapText.Clear();
-            beatmapText.AddLink(item.Beatmap.ToString(), LinkAction.OpenBeatmap, item.Beatmap.Value.OnlineBeatmapID.ToString());
+            beatmapText.AddLink(Item.Beatmap.ToString(), LinkAction.OpenBeatmap, Item.Beatmap.Value.OnlineBeatmapID.ToString());
 
             authorText.Clear();
 
-            if (item.Beatmap?.Value?.Metadata?.Author != null)
+            if (Item.Beatmap?.Value?.Metadata?.Author != null)
             {
                 authorText.AddText("mapped by ");
-                authorText.AddUserLink(item.Beatmap.Value?.Metadata.Author);
+                authorText.AddUserLink(Item.Beatmap.Value?.Metadata.Author);
             }
 
             modDisplay.Current.Value = requiredMods.ToArray();
@@ -180,29 +184,33 @@ namespace osu.Game.Screens.Multi
                         }
                     }
                 },
-                new Container
+                new FillFlowContainer
                 {
                     Anchor = Anchor.CentreRight,
                     Origin = Anchor.CentreRight,
+                    Direction = FillDirection.Horizontal,
                     AutoSizeAxes = Axes.Both,
                     X = -18,
-                    Children = new Drawable[]
-                    {
-                        new PlaylistDownloadButton(item.Beatmap.Value.BeatmapSet)
-                        {
-                            Size = new Vector2(50, 30)
-                        },
-                        new IconButton
-                        {
-                            Icon = FontAwesome.Solid.MinusSquare,
-                            Alpha = allowEdit ? 1 : 0,
-                            Action = () => RequestDeletion?.Invoke(Model),
-                        },
-                    }
+                    ChildrenEnumerable = CreateButtons()
                 }
             }
         };
 
+        protected virtual IEnumerable<Drawable> CreateButtons() =>
+            new Drawable[]
+            {
+                new PlaylistDownloadButton(Item)
+                {
+                    Size = new Vector2(50, 30)
+                },
+                new IconButton
+                {
+                    Icon = FontAwesome.Solid.MinusSquare,
+                    Alpha = allowEdit ? 1 : 0,
+                    Action = () => RequestDeletion?.Invoke(Model),
+                },
+            };
+
         protected override bool OnClick(ClickEvent e)
         {
             if (allowSelection)
@@ -212,9 +220,15 @@ namespace osu.Game.Screens.Multi
 
         private class PlaylistDownloadButton : BeatmapPanelDownloadButton
         {
-            public PlaylistDownloadButton(BeatmapSetInfo beatmapSet)
-                : base(beatmapSet)
+            private readonly PlaylistItem playlistItem;
+
+            [Resolved]
+            private BeatmapManager beatmapManager { get; set; }
+
+            public PlaylistDownloadButton(PlaylistItem playlistItem)
+                : base(playlistItem.Beatmap.Value.BeatmapSet)
             {
+                this.playlistItem = playlistItem;
                 Alpha = 0;
             }
 
@@ -223,11 +237,26 @@ namespace osu.Game.Screens.Multi
                 base.LoadComplete();
 
                 State.BindValueChanged(stateChanged, true);
+                FinishTransforms(true);
             }
 
             private void stateChanged(ValueChangedEvent<DownloadState> state)
             {
-                this.FadeTo(state.NewValue == DownloadState.LocallyAvailable ? 0 : 1, 500);
+                switch (state.NewValue)
+                {
+                    case DownloadState.LocallyAvailable:
+                        // Perform a local query of the beatmap by beatmap checksum, and reset the state if not matching.
+                        if (beatmapManager.QueryBeatmap(b => b.MD5Hash == playlistItem.Beatmap.Value.MD5Hash) == null)
+                            State.Value = DownloadState.NotDownloaded;
+                        else
+                            this.FadeTo(0, 500);
+
+                        break;
+
+                    default:
+                        this.FadeTo(1, 500);
+                        break;
+                }
             }
         }
 

osu.Game/Screens/Multi/DrawableRoomPlaylistWithResults.cs

@@ -0,0 +1,66 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Graphics.Sprites;
+using osu.Game.Graphics;
+using osu.Game.Graphics.Containers;
+using osu.Game.Graphics.UserInterface;
+using osu.Game.Online.Multiplayer;
+
+namespace osu.Game.Screens.Multi
+{
+    public class DrawableRoomPlaylistWithResults : DrawableRoomPlaylist
+    {
+        public Action<PlaylistItem> RequestShowResults;
+
+        public DrawableRoomPlaylistWithResults()
+            : base(false, true)
+        {
+        }
+
+        protected override OsuRearrangeableListItem<PlaylistItem> CreateOsuDrawable(PlaylistItem item) =>
+            new DrawableRoomPlaylistItemWithResults(item, false, true)
+            {
+                RequestShowResults = () => RequestShowResults(item),
+                SelectedItem = { BindTarget = SelectedItem },
+            };
+
+        private class DrawableRoomPlaylistItemWithResults : DrawableRoomPlaylistItem
+        {
+            public Action RequestShowResults;
+
+            public DrawableRoomPlaylistItemWithResults(PlaylistItem item, bool allowEdit, bool allowSelection)
+                : base(item, allowEdit, allowSelection)
+            {
+            }
+
+            protected override IEnumerable<Drawable> CreateButtons() =>
+                base.CreateButtons().Prepend(new FilledIconButton
+                {
+                    Icon = FontAwesome.Solid.ChartPie,
+                    Action = () => RequestShowResults?.Invoke(),
+                    TooltipText = "View results"
+                });
+
+            private class FilledIconButton : IconButton
+            {
+                [BackgroundDependencyLoader]
+                private void load(OsuColour colours)
+                {
+                    Add(new Box
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Depth = float.MaxValue,
+                        Colour = colours.Gray4,
+                    });
+                }
+            }
+        }
+    }
+}

osu.Game/Screens/Multi/Header.cs

@@ -1,17 +1,18 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using Humanizer;
 using osu.Framework.Allocation;
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
-using osu.Framework.Graphics.Sprites;
+using osu.Framework.Graphics.UserInterface;
 using osu.Framework.Screens;
 using osu.Game.Graphics;
 using osu.Game.Graphics.UserInterface;
-using osu.Game.Overlays.SearchableList;
 using osu.Game.Graphics.Sprites;
+using osu.Game.Overlays;
 using osuTK;
 using osuTK.Graphics;
 
@@ -19,41 +20,41 @@ namespace osu.Game.Screens.Multi
 {
     public class Header : Container
     {
-        public const float HEIGHT = 121;
-
-        private readonly HeaderBreadcrumbControl breadcrumbs;
+        public const float HEIGHT = 80;
 
         public Header(ScreenStack stack)
         {
-            MultiHeaderTitle title;
             RelativeSizeAxes = Axes.X;
             Height = HEIGHT;
 
+            HeaderBreadcrumbControl breadcrumbs;
+            MultiHeaderTitle title;
+
             Children = new Drawable[]
             {
                 new Box
                 {
                     RelativeSizeAxes = Axes.Both,
-                    Colour = Color4Extensions.FromHex(@"2f2043"),
+                    Colour = Color4Extensions.FromHex(@"#1f1921"),
                 },
                 new Container
                 {
+                    Anchor = Anchor.CentreLeft,
+                    Origin = Anchor.CentreLeft,
                     RelativeSizeAxes = Axes.Both,
-                    Padding = new MarginPadding { Horizontal = SearchableListOverlay.WIDTH_PADDING + OsuScreen.HORIZONTAL_OVERFLOW_PADDING },
+                    Padding = new MarginPadding { Left = WaveOverlayContainer.WIDTH_PADDING + OsuScreen.HORIZONTAL_OVERFLOW_PADDING },
                     Children = new Drawable[]
                     {
                         title = new MultiHeaderTitle
                         {
                             Anchor = Anchor.CentreLeft,
                             Origin = Anchor.BottomLeft,
-                            X = -MultiHeaderTitle.ICON_WIDTH,
                         },
                         breadcrumbs = new HeaderBreadcrumbControl(stack)
                         {
                             Anchor = Anchor.BottomLeft,
-                            Origin = Anchor.BottomLeft,
-                            RelativeSizeAxes = Axes.X,
-                        },
+                            Origin = Anchor.BottomLeft
+                        }
                     },
                 },
             };
@@ -67,32 +68,16 @@ namespace osu.Game.Screens.Multi
             breadcrumbs.Current.TriggerChange();
         }
 
-        [BackgroundDependencyLoader]
-        private void load(OsuColour colours)
+        private class MultiHeaderTitle : CompositeDrawable
         {
-            breadcrumbs.StripColour = colours.Green;
-        }
-
-        private class MultiHeaderTitle : CompositeDrawable, IHasAccentColour
-        {
-            public const float ICON_WIDTH = icon_size + spacing;
-
-            private const float icon_size = 25;
             private const float spacing = 6;
-            private const int text_offset = 2;
 
-            private readonly SpriteIcon iconSprite;
-            private readonly OsuSpriteText title, pageText;
+            private readonly OsuSpriteText dot;
+            private readonly OsuSpriteText pageTitle;
 
             public IMultiplayerSubScreen Screen
             {
-                set => pageText.Text = value.ShortTitle.ToLowerInvariant();
-            }
-
-            public Color4 AccentColour
-            {
-                get => pageText.Colour;
-                set => pageText.Colour = value;
+                set => pageTitle.Text = value.ShortTitle.Titleize();
             }
 
             public MultiHeaderTitle()
@@ -108,32 +93,26 @@ namespace osu.Game.Screens.Multi
                         Direction = FillDirection.Horizontal,
                         Children = new Drawable[]
                         {
-                            iconSprite = new SpriteIcon
+                            new OsuSpriteText
                             {
-                                Size = new Vector2(icon_size),
-                                Anchor = Anchor.Centre,
-                                Origin = Anchor.Centre
+                                Anchor = Anchor.CentreLeft,
+                                Origin = Anchor.CentreLeft,
+                                Font = OsuFont.GetFont(size: 24),
+                                Text = "Multiplayer"
                             },
-                            title = new OsuSpriteText
+                            dot = new OsuSpriteText
                             {
-                                Anchor = Anchor.Centre,
-                                Origin = Anchor.Centre,
-                                Font = OsuFont.GetFont(size: 20, weight: FontWeight.Bold),
-                                Margin = new MarginPadding { Bottom = text_offset }
+                                Anchor = Anchor.CentreLeft,
+                                Origin = Anchor.CentreLeft,
+                                Font = OsuFont.GetFont(size: 24),
+                                Text = "·"
                             },
-                            new Circle
+                            pageTitle = new OsuSpriteText
                             {
-                                Anchor = Anchor.Centre,
-                                Origin = Anchor.Centre,
-                                Size = new Vector2(4),
-                                Colour = Color4.Gray,
-                            },
-                            pageText = new OsuSpriteText
-                            {
-                                Anchor = Anchor.Centre,
-                                Origin = Anchor.Centre,
-                                Font = OsuFont.GetFont(size: 20),
-                                Margin = new MarginPadding { Bottom = text_offset }
+                                Anchor = Anchor.CentreLeft,
+                                Origin = Anchor.CentreLeft,
+                                Font = OsuFont.GetFont(size: 24),
+                                Text = "Lounge"
                             }
                         }
                     },
@@ -143,9 +122,7 @@ namespace osu.Game.Screens.Multi
             [BackgroundDependencyLoader]
             private void load(OsuColour colours)
             {
-                title.Text = "multi";
-                iconSprite.Icon = OsuIcon.Multi;
-                AccentColour = colours.Yellow;
+                pageTitle.Colour = dot.Colour = colours.Yellow;
             }
         }
 
@@ -154,12 +131,28 @@ namespace osu.Game.Screens.Multi
             public HeaderBreadcrumbControl(ScreenStack stack)
                 : base(stack)
             {
+                RelativeSizeAxes = Axes.X;
+                StripColour = Color4.Transparent;
             }
 
             protected override void LoadComplete()
             {
                 base.LoadComplete();
-                AccentColour = Color4.White;
+                AccentColour = Color4Extensions.FromHex("#e35c99");
+            }
+
+            protected override TabItem<IScreen> CreateTabItem(IScreen value) => new HeaderBreadcrumbTabItem(value)
+            {
+                AccentColour = AccentColour
+            };
+
+            private class HeaderBreadcrumbTabItem : BreadcrumbTabItem
+            {
+                public HeaderBreadcrumbTabItem(IScreen value)
+                    : base(value)
+                {
+                    Bar.Colour = Color4.Transparent;
+                }
             }
         }
     }

osu.Game/Screens/Multi/IRoomManager.cs

@@ -14,6 +14,11 @@ namespace osu.Game.Screens.Multi
         /// </summary>
         event Action RoomsUpdated;
 
+        /// <summary>
+        /// Whether an initial listing of rooms has been received.
+        /// </summary>
+        Bindable<bool> InitialRoomsReceived { get; }
+
         /// <summary>
         /// All the active <see cref="Room"/>s.
         /// </summary>

osu.Game/Screens/Multi/Lounge/Components/DrawableRoom.cs

@@ -21,10 +21,12 @@ using osu.Game.Online.Multiplayer;
 using osu.Game.Screens.Multi.Components;
 using osuTK;
 using osuTK.Graphics;
+using osu.Framework.Graphics.Cursor;
+using osu.Framework.Graphics.UserInterface;
 
 namespace osu.Game.Screens.Multi.Lounge.Components
 {
-    public class DrawableRoom : OsuClickableContainer, IStateful<SelectionState>, IFilterable
+    public class DrawableRoom : OsuClickableContainer, IStateful<SelectionState>, IFilterable, IHasContextMenu
     {
         public const float SELECTION_BORDER_WIDTH = 4;
         private const float corner_radius = 5;
@@ -39,6 +41,9 @@ namespace osu.Game.Screens.Multi.Lounge.Components
         private readonly Box selectionBox;
         private CachedModelDependencyContainer<Room> dependencies;
 
+        [Resolved(canBeNull: true)]
+        private Multiplayer multiplayer { get; set; }
+
         [Resolved]
         private BeatmapManager beatmaps { get; set; }
 
@@ -107,6 +112,8 @@ namespace osu.Game.Screens.Multi.Lounge.Components
         [BackgroundDependencyLoader]
         private void load(OsuColour colours)
         {
+            float stripWidth = side_strip_width * (Room.Category.Value == RoomCategory.Spotlight ? 2 : 1);
+
             Children = new Drawable[]
             {
                 new StatusColouredContainer(transition_duration)
@@ -139,7 +146,7 @@ namespace osu.Game.Screens.Multi.Lounge.Components
                             new StatusColouredContainer(transition_duration)
                             {
                                 RelativeSizeAxes = Axes.Y,
-                                Width = side_strip_width,
+                                Width = stripWidth,
                                 Child = new Box { RelativeSizeAxes = Axes.Both }
                             },
                             new Container
@@ -147,7 +154,7 @@ namespace osu.Game.Screens.Multi.Lounge.Components
                                 RelativeSizeAxes = Axes.Y,
                                 Width = cover_width,
                                 Masking = true,
-                                Margin = new MarginPadding { Left = side_strip_width },
+                                Margin = new MarginPadding { Left = stripWidth },
                                 Child = new MultiplayerBackgroundSprite(BeatmapSetCoverType.List) { RelativeSizeAxes = Axes.Both }
                             },
                             new Container
@@ -156,7 +163,7 @@ namespace osu.Game.Screens.Multi.Lounge.Components
                                 Padding = new MarginPadding
                                 {
                                     Vertical = content_padding,
-                                    Left = side_strip_width + cover_width + content_padding,
+                                    Left = stripWidth + cover_width + content_padding,
                                     Right = content_padding,
                                 },
                                 Children = new Drawable[]
@@ -217,6 +224,8 @@ namespace osu.Game.Screens.Multi.Lounge.Components
                 Alpha = 0;
         }
 
+        protected override bool ShouldBeConsideredForInput(Drawable child) => state == SelectionState.Selected;
+
         private class RoomName : OsuSpriteText
         {
             [Resolved(typeof(Room), nameof(Online.Multiplayer.Room.Name))]
@@ -228,5 +237,13 @@ namespace osu.Game.Screens.Multi.Lounge.Components
                 Current = name;
             }
         }
+
+        public MenuItem[] ContextMenuItems => new MenuItem[]
+        {
+            new OsuMenuItem("Create copy", MenuItemType.Standard, () =>
+            {
+                multiplayer?.CreateRoom(Room.CreateCopy());
+            })
+        };
     }
 }

osu.Game/Screens/Multi/Lounge/Components/FilterControl.cs

@@ -12,11 +12,11 @@ using osuTK.Graphics;
 
 namespace osu.Game.Screens.Multi.Lounge.Components
 {
-    public class FilterControl : SearchableListFilterControl<PrimaryFilter, SecondaryFilter>
+    public class FilterControl : SearchableListFilterControl<RoomStatusFilter, RoomCategoryFilter>
     {
         protected override Color4 BackgroundColour => Color4.Black.Opacity(0.5f);
-        protected override PrimaryFilter DefaultTab => PrimaryFilter.Open;
-        protected override SecondaryFilter DefaultCategory => SecondaryFilter.Public;
+        protected override RoomStatusFilter DefaultTab => RoomStatusFilter.Open;
+        protected override RoomCategoryFilter DefaultCategory => RoomCategoryFilter.Any;
 
         protected override float ContentHorizontalPadding => base.ContentHorizontalPadding + OsuScreen.HORIZONTAL_OVERFLOW_PADDING;
 
@@ -34,8 +34,7 @@ namespace osu.Game.Screens.Multi.Lounge.Components
         [BackgroundDependencyLoader]
         private void load()
         {
-            if (filter == null)
-                filter = new Bindable<FilterCriteria>();
+            filter ??= new Bindable<FilterCriteria>();
         }
 
         protected override void LoadComplete()
@@ -44,6 +43,7 @@ namespace osu.Game.Screens.Multi.Lounge.Components
 
             ruleset.BindValueChanged(_ => updateFilter());
             Search.Current.BindValueChanged(_ => scheduleUpdateFilter());
+            Dropdown.Current.BindValueChanged(_ => updateFilter());
             Tabs.Current.BindValueChanged(_ => updateFilter(), true);
         }
 
@@ -59,29 +59,33 @@ namespace osu.Game.Screens.Multi.Lounge.Components
         {
             scheduledFilterUpdate?.Cancel();
 
+            if (filter == null)
+                return;
+
             filter.Value = new FilterCriteria
             {
                 SearchString = Search.Current.Value ?? string.Empty,
-                PrimaryFilter = Tabs.Current.Value,
-                SecondaryFilter = DisplayStyleControl.Dropdown.Current.Value,
+                StatusFilter = Tabs.Current.Value,
+                RoomCategoryFilter = Dropdown.Current.Value,
                 Ruleset = ruleset.Value
             };
         }
     }
 
-    public enum PrimaryFilter
+    public enum RoomStatusFilter
     {
         Open,
 
         [Description("Recently Ended")]
-        RecentlyEnded,
+        Ended,
         Participated,
         Owned,
     }
 
-    public enum SecondaryFilter
+    public enum RoomCategoryFilter
     {
-        Public,
-        //Private,
+        Any,
+        Normal,
+        Spotlight
     }
 }

osu.Game/Screens/Multi/Lounge/Components/FilterCriteria.cs

@@ -8,8 +8,8 @@ namespace osu.Game.Screens.Multi.Lounge.Components
     public class FilterCriteria
     {
         public string SearchString;
-        public PrimaryFilter PrimaryFilter;
-        public SecondaryFilter SecondaryFilter;
+        public RoomStatusFilter StatusFilter;
+        public RoomCategoryFilter RoomCategoryFilter;
         public RulesetInfo Ruleset;
     }
 }

osu.Game/Screens/Multi/Lounge/Components/RoomInfo.cs

@@ -4,9 +4,8 @@
 using System.Collections.Generic;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
-using osu.Framework.Graphics.Sprites;
 using osu.Game.Graphics;
-using osu.Game.Graphics.Sprites;
+using osu.Game.Graphics.Containers;
 using osu.Game.Screens.Multi.Components;
 using osuTK;
 
@@ -15,7 +14,7 @@ namespace osu.Game.Screens.Multi.Lounge.Components
     public class RoomInfo : MultiplayerComposite
     {
         private readonly List<Drawable> statusElements = new List<Drawable>();
-        private readonly SpriteText roomName;
+        private readonly OsuTextFlowContainer roomName;
 
         public RoomInfo()
         {
@@ -43,18 +42,23 @@ namespace osu.Game.Screens.Multi.Lounge.Components
                             {
                                 Anchor = Anchor.CentreLeft,
                                 Origin = Anchor.CentreLeft,
-                                AutoSizeAxes = Axes.Both,
+                                RelativeSizeAxes = Axes.X,
+                                AutoSizeAxes = Axes.Y,
                                 Direction = FillDirection.Vertical,
                                 Children = new Drawable[]
                                 {
-                                    roomName = new OsuSpriteText { Font = OsuFont.GetFont(size: 30) },
+                                    roomName = new OsuTextFlowContainer(t => t.Font = OsuFont.GetFont(size: 30))
+                                    {
+                                        RelativeSizeAxes = Axes.X,
+                                        AutoSizeAxes = Axes.Y,
+                                    },
                                     statusInfo = new RoomStatusInfo(),
                                 }
                             },
                             typeInfo = new ModeTypeInfo
                             {
-                                Anchor = Anchor.CentreRight,
-                                Origin = Anchor.CentreRight
+                                Anchor = Anchor.BottomRight,
+                                Origin = Anchor.BottomRight
                             }
                         }
                     },

osu.Game/Screens/Multi/Lounge/Components/RoomInspector.cs

@@ -24,6 +24,8 @@ namespace osu.Game.Screens.Multi.Lounge.Components
         [BackgroundDependencyLoader]
         private void load(OsuColour colours)
         {
+            OverlinedHeader participantsHeader;
+
             InternalChildren = new Drawable[]
             {
                 new Box
@@ -55,22 +57,31 @@ namespace osu.Game.Screens.Multi.Lounge.Components
                                             RelativeSizeAxes = Axes.X,
                                             Margin = new MarginPadding { Vertical = 60 },
                                         },
-                                        new OverlinedParticipants(Direction.Horizontal)
+                                        participantsHeader = new OverlinedHeader("Recent Participants"),
+                                        new ParticipantsDisplay(Direction.Vertical)
                                         {
                                             RelativeSizeAxes = Axes.X,
-                                            AutoSizeAxes = Axes.Y
-                                        },
+                                            Height = ParticipantsList.TILE_SIZE * 3,
+                                            Details = { BindTarget = participantsHeader.Details }
+                                        }
                                     }
                                 }
                             },
+                            new Drawable[] { new OverlinedHeader("Playlist"), },
                             new Drawable[]
                             {
-                                new OverlinedPlaylist(false) { RelativeSizeAxes = Axes.Both },
+                                new DrawableRoomPlaylist(false, false)
+                                {
+                                    RelativeSizeAxes = Axes.Both,
+                                    Items = { BindTarget = Playlist }
+                                },
                             },
                         },
                         RowDimensions = new[]
                         {
                             new Dimension(GridSizeMode.AutoSize),
+                            new Dimension(GridSizeMode.AutoSize),
+                            new Dimension(),
                         }
                     }
                 }

osu.Game/Screens/Multi/Lounge/Components/RoomsContainer.cs

@@ -3,19 +3,25 @@
 
 using System;
 using System.Collections.Generic;
+using System.Collections.Specialized;
 using System.Linq;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Extensions.IEnumerableExtensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Input.Bindings;
+using osu.Framework.Threading;
+using osu.Game.Extensions;
 using osu.Game.Graphics.UserInterface;
+using osu.Game.Input.Bindings;
 using osu.Game.Online.Multiplayer;
 using osuTK;
+using osu.Game.Graphics.Cursor;
 
 namespace osu.Game.Screens.Multi.Lounge.Components
 {
-    public class RoomsContainer : CompositeDrawable
+    public class RoomsContainer : CompositeDrawable, IKeyBindingHandler<GlobalAction>
     {
         public Action<Room> JoinRequested;
 
@@ -33,24 +39,31 @@ namespace osu.Game.Screens.Multi.Lounge.Components
         [Resolved]
         private IRoomManager roomManager { get; set; }
 
+        [Resolved(CanBeNull = true)]
+        private LoungeSubScreen loungeSubScreen { get; set; }
+
         public RoomsContainer()
         {
             RelativeSizeAxes = Axes.X;
             AutoSizeAxes = Axes.Y;
 
-            InternalChild = roomFlow = new FillFlowContainer<DrawableRoom>
+            InternalChild = new OsuContextMenuContainer
             {
                 RelativeSizeAxes = Axes.X,
                 AutoSizeAxes = Axes.Y,
-                Direction = FillDirection.Vertical,
-                Spacing = new Vector2(2),
+                Child = roomFlow = new FillFlowContainer<DrawableRoom>
+                {
+                    RelativeSizeAxes = Axes.X,
+                    AutoSizeAxes = Axes.Y,
+                    Direction = FillDirection.Vertical,
+                    Spacing = new Vector2(2),
+                }
             };
         }
 
         protected override void LoadComplete()
         {
-            rooms.ItemsAdded += addRooms;
-            rooms.ItemsRemoved += removeRooms;
+            rooms.CollectionChanged += roomsChanged;
             roomManager.RoomsUpdated += updateSorting;
 
             rooms.BindTo(roomManager.Rooms);
@@ -71,25 +84,45 @@ namespace osu.Game.Screens.Multi.Lounge.Components
                     matchingFilter &= r.Room.Playlist.Count == 0 || r.Room.Playlist.Any(i => i.Ruleset.Value.Equals(criteria.Ruleset));
 
                     if (!string.IsNullOrEmpty(criteria.SearchString))
-                        matchingFilter &= r.FilterTerms.Any(term => term.IndexOf(criteria.SearchString, StringComparison.InvariantCultureIgnoreCase) >= 0);
-
-                    switch (criteria.SecondaryFilter)
-                    {
-                        default:
-                        case SecondaryFilter.Public:
-                            matchingFilter &= r.Room.Availability.Value == RoomAvailability.Public;
-                            break;
-                    }
+                        matchingFilter &= r.FilterTerms.Any(term => term.Contains(criteria.SearchString, StringComparison.InvariantCultureIgnoreCase));
 
                     r.MatchingFilter = matchingFilter;
                 }
             });
         }
 
+        private void roomsChanged(object sender, NotifyCollectionChangedEventArgs args)
+        {
+            switch (args.Action)
+            {
+                case NotifyCollectionChangedAction.Add:
+                    addRooms(args.NewItems.Cast<Room>());
+                    break;
+
+                case NotifyCollectionChangedAction.Remove:
+                    removeRooms(args.OldItems.Cast<Room>());
+                    break;
+            }
+        }
+
         private void addRooms(IEnumerable<Room> rooms)
         {
-            foreach (var r in rooms)
-                roomFlow.Add(new DrawableRoom(r) { Action = () => selectRoom(r) });
+            foreach (var room in rooms)
+            {
+                roomFlow.Add(new DrawableRoom(room)
+                {
+                    Action = () =>
+                    {
+                        if (room == selectedRoom.Value)
+                        {
+                            joinSelected();
+                            return;
+                        }
+
+                        selectRoom(room);
+                    }
+                });
+            }
 
             Filter(filter?.Value);
         }
@@ -115,16 +148,100 @@ namespace osu.Game.Screens.Multi.Lounge.Components
 
         private void selectRoom(Room room)
         {
-            var drawable = roomFlow.FirstOrDefault(r => r.Room == room);
-
-            if (drawable != null && drawable.State == SelectionState.Selected)
-                JoinRequested?.Invoke(room);
-            else
-                roomFlow.Children.ForEach(r => r.State = r.Room == room ? SelectionState.Selected : SelectionState.NotSelected);
-
+            roomFlow.Children.ForEach(r => r.State = r.Room == room ? SelectionState.Selected : SelectionState.NotSelected);
             selectedRoom.Value = room;
         }
 
+        private void joinSelected()
+        {
+            if (selectedRoom.Value == null) return;
+
+            JoinRequested?.Invoke(selectedRoom.Value);
+        }
+
+        #region Key selection logic (shared with BeatmapCarousel)
+
+        public bool OnPressed(GlobalAction action)
+        {
+            switch (action)
+            {
+                case GlobalAction.Select:
+                    joinSelected();
+                    return true;
+
+                case GlobalAction.SelectNext:
+                    beginRepeatSelection(() => selectNext(1), action);
+                    return true;
+
+                case GlobalAction.SelectPrevious:
+                    beginRepeatSelection(() => selectNext(-1), action);
+                    return true;
+            }
+
+            return false;
+        }
+
+        public void OnReleased(GlobalAction action)
+        {
+            switch (action)
+            {
+                case GlobalAction.SelectNext:
+                case GlobalAction.SelectPrevious:
+                    endRepeatSelection(action);
+                    break;
+            }
+        }
+
+        private ScheduledDelegate repeatDelegate;
+        private object lastRepeatSource;
+
+        /// <summary>
+        /// Begin repeating the specified selection action.
+        /// </summary>
+        /// <param name="action">The action to perform.</param>
+        /// <param name="source">The source of the action. Used in conjunction with <see cref="endRepeatSelection"/> to only cancel the correct action (most recently pressed key).</param>
+        private void beginRepeatSelection(Action action, object source)
+        {
+            endRepeatSelection();
+
+            lastRepeatSource = source;
+            repeatDelegate = this.BeginKeyRepeat(Scheduler, action);
+        }
+
+        private void endRepeatSelection(object source = null)
+        {
+            // only the most recent source should be able to cancel the current action.
+            if (source != null && !EqualityComparer<object>.Default.Equals(lastRepeatSource, source))
+                return;
+
+            repeatDelegate?.Cancel();
+            repeatDelegate = null;
+            lastRepeatSource = null;
+        }
+
+        private void selectNext(int direction)
+        {
+            var visibleRooms = Rooms.AsEnumerable().Where(r => r.IsPresent);
+
+            Room room;
+
+            if (selectedRoom.Value == null)
+                room = visibleRooms.FirstOrDefault()?.Room;
+            else
+            {
+                if (direction < 0)
+                    visibleRooms = visibleRooms.Reverse();
+
+                room = visibleRooms.SkipWhile(r => r.Room != selectedRoom.Value).Skip(1).FirstOrDefault()?.Room;
+            }
+
+            // we already have a valid selection only change selection if we still have a room to switch to.
+            if (room != null)
+                selectRoom(room);
+        }
+
+        #endregion
+
         protected override void Dispose(bool isDisposing)
         {
             base.Dispose(isDisposing);