Merge pull request #7589 from peppy/timeline-maybe

Expand editor timeline functionality

osu.Game.Rulesets.Mania/Edit/Blueprints/ManiaSelectionBlueprint.cs

@@ -13,7 +13,7 @@ using osuTK;
 
 namespace osu.Game.Rulesets.Mania.Edit.Blueprints
 {
-    public class ManiaSelectionBlueprint : SelectionBlueprint
+    public class ManiaSelectionBlueprint : OverlaySelectionBlueprint
     {
         public Vector2 ScreenSpaceDragPosition { get; private set; }
         public Vector2 DragPosition { get; private set; }

osu.Game.Rulesets.Mania/Edit/ManiaBlueprintContainer.cs

@@ -17,7 +17,7 @@ namespace osu.Game.Rulesets.Mania.Edit
         {
         }
 
-        public override SelectionBlueprint CreateBlueprintFor(DrawableHitObject hitObject)
+        public override OverlaySelectionBlueprint CreateBlueprintFor(DrawableHitObject hitObject)
         {
             switch (hitObject)
             {

osu.Game.Rulesets.Mania/Edit/ManiaSelectionHandler.cs

@@ -5,6 +5,7 @@ using System;
 using System.Linq;
 using osu.Framework.Allocation;
 using osu.Framework.Timing;
+using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Mania.Edit.Blueprints;
 using osu.Game.Rulesets.Mania.Objects;
 using osu.Game.Rulesets.UI;
@@ -70,10 +71,12 @@ namespace osu.Game.Rulesets.Mania.Edit
             // When scrolling downwards the anchor position is at the bottom of the screen, however the movement event assumes the anchor is at the top of the screen.
             // This causes the delta to assume a positive hitobject position, and which can be corrected for by subtracting the parent height.
             if (scrollingInfo.Direction.Value == ScrollingDirection.Down)
-                delta -= moveEvent.Blueprint.DrawableObject.Parent.DrawHeight;
+                delta -= moveEvent.Blueprint.Parent.DrawHeight; // todo: probably wrong
 
-            foreach (var b in SelectedBlueprints)
+            foreach (var selectionBlueprint in SelectedBlueprints)
             {
+                var b = (OverlaySelectionBlueprint)selectionBlueprint;
+
                 var hitObject = b.DrawableObject;
                 var objectParent = (HitObjectContainer)hitObject.Parent;
 

osu.Game.Rulesets.Mania/Edit/Masks/ManiaSelectionBlueprint.cs

@@ -7,7 +7,7 @@ using osu.Game.Rulesets.Objects.Drawables;
 
 namespace osu.Game.Rulesets.Mania.Edit.Masks
 {
-    public abstract class ManiaSelectionBlueprint : SelectionBlueprint
+    public abstract class ManiaSelectionBlueprint : OverlaySelectionBlueprint
     {
         protected ManiaSelectionBlueprint(DrawableHitObject drawableObject)
             : base(drawableObject)

osu.Game.Rulesets.Osu/Edit/Blueprints/OsuSelectionBlueprint.cs

@@ -7,10 +7,10 @@ using osu.Game.Rulesets.Osu.Objects;
 
 namespace osu.Game.Rulesets.Osu.Edit.Blueprints
 {
-    public abstract class OsuSelectionBlueprint<T> : SelectionBlueprint
+    public abstract class OsuSelectionBlueprint<T> : OverlaySelectionBlueprint
         where T : OsuHitObject
     {
-        protected T HitObject => (T)DrawableObject.HitObject;
+        protected new T HitObject => (T)DrawableObject.HitObject;
 
         protected OsuSelectionBlueprint(DrawableHitObject drawableObject)
             : base(drawableObject)

osu.Game.Rulesets.Osu/Edit/Blueprints/Sliders/SliderCircleSelectionBlueprint.cs

@@ -17,6 +17,7 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders
             : base(slider)
         {
             this.position = position;
+
             InternalChild = CirclePiece = new HitCirclePiece();
 
             Select();

osu.Game.Rulesets.Osu/Edit/Blueprints/Sliders/SliderSelectionBlueprint.cs

@@ -170,7 +170,7 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders
             new OsuMenuItem("Add control point", MenuItemType.Standard, () => addControlPoint(rightClickPosition)),
         };
 
-        public override Vector2 SelectionPoint => HeadBlueprint.SelectionPoint;
+        public override Vector2 SelectionPoint => ((DrawableSlider)DrawableObject).HeadCircle.ScreenSpaceDrawQuad.Centre;
 
         public override bool ReceivePositionalInputAt(Vector2 screenSpacePos) => BodyPiece.ReceivePositionalInputAt(screenSpacePos);
 

osu.Game.Rulesets.Osu/Edit/OsuBlueprintContainer.cs

@@ -21,7 +21,7 @@ namespace osu.Game.Rulesets.Osu.Edit
 
         protected override SelectionHandler CreateSelectionHandler() => new OsuSelectionHandler();
 
-        public override SelectionBlueprint CreateBlueprintFor(DrawableHitObject hitObject)
+        public override OverlaySelectionBlueprint CreateBlueprintFor(DrawableHitObject hitObject)
         {
             switch (hitObject)
             {

osu.Game.Tests/Visual/Editor/TestSceneTimelineBlueprintContainer.cs

@@ -13,6 +13,7 @@ using osu.Framework.Graphics.Shapes;
 using osu.Framework.Timing;
 using osu.Game.Beatmaps;
 using osu.Game.Graphics.UserInterface;
+using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Screens.Edit;
 using osu.Game.Screens.Edit.Compose.Components.Timeline;
@@ -22,12 +23,11 @@ using osuTK.Graphics;
 namespace osu.Game.Tests.Visual.Editor
 {
     [TestFixture]
-    public class TestSceneEditorComposeTimeline : EditorClockTestScene
+    public class TestSceneTimelineBlueprintContainer : EditorClockTestScene
     {
         public override IReadOnlyList<Type> RequiredTypes => new[]
         {
             typeof(TimelineArea),
-            typeof(TimelineHitObjectDisplay),
             typeof(Timeline),
             typeof(TimelineButton),
             typeof(CentreMarker)
@@ -38,9 +38,10 @@ namespace osu.Game.Tests.Visual.Editor
         {
             Beatmap.Value = new WaveformTestBeatmap(audio);
 
-            var editorBeatmap = new EditorBeatmap((Beatmap<HitObject>)Beatmap.Value.Beatmap);
+            var editorBeatmap = new EditorBeatmap((Beatmap<HitObject>)Beatmap.Value.Beatmap, BeatDivisor);
 
             Dependencies.Cache(editorBeatmap);
+            Dependencies.CacheAs<IBeatSnapProvider>(editorBeatmap);
 
             Children = new Drawable[]
             {
@@ -57,7 +58,7 @@ namespace osu.Game.Tests.Visual.Editor
                 },
                 new TimelineArea
                 {
-                    Child = new TimelineHitObjectDisplay(editorBeatmap),
+                    Child = new TimelineBlueprintContainer(),
                     Anchor = Anchor.Centre,
                     Origin = Anchor.Centre,
                     RelativeSizeAxes = Axes.X,

osu.Game/Rulesets/Edit/OverlaySelectionBlueprint.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 osu.Framework.Graphics.Primitives;
+using osu.Game.Graphics.UserInterface;
+using osu.Game.Rulesets.Objects.Drawables;
+using osuTK;
+
+namespace osu.Game.Rulesets.Edit
+{
+    public abstract class OverlaySelectionBlueprint : SelectionBlueprint
+    {
+        /// <summary>
+        /// The <see cref="DrawableHitObject"/> which this <see cref="OverlaySelectionBlueprint"/> applies to.
+        /// </summary>
+        public readonly DrawableHitObject DrawableObject;
+
+        protected override bool ShouldBeAlive => (DrawableObject.IsAlive && DrawableObject.IsPresent) || State == SelectionState.Selected;
+
+        protected OverlaySelectionBlueprint(DrawableHitObject drawableObject)
+            : base(drawableObject.HitObject)
+        {
+            DrawableObject = drawableObject;
+        }
+
+        public override bool ReceivePositionalInputAt(Vector2 screenSpacePos) => DrawableObject.ReceivePositionalInputAt(screenSpacePos);
+
+        public override Vector2 SelectionPoint => DrawableObject.ScreenSpaceDrawQuad.Centre;
+
+        public override Quad SelectionQuad => DrawableObject.ScreenSpaceDrawQuad;
+
+        public override Vector2 GetInstantDelta(Vector2 screenSpacePosition) => DrawableObject.Parent.ToLocalSpace(screenSpacePosition) - DrawableObject.Position;
+    }
+}

osu.Game/Rulesets/Edit/SelectionBlueprint.cs

@@ -1,4 +1,4 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// 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;
@@ -20,6 +20,8 @@ namespace osu.Game.Rulesets.Edit
     /// </summary>
     public abstract class SelectionBlueprint : CompositeDrawable, IStateful<SelectionState>
     {
+        public readonly HitObject HitObject;
+
         /// <summary>
         /// Invoked when this <see cref="SelectionBlueprint"/> has been selected.
         /// </summary>
@@ -30,26 +32,24 @@ namespace osu.Game.Rulesets.Edit
         /// </summary>
         public event Action<SelectionBlueprint> Deselected;
 
-        /// <summary>
-        /// The <see cref="DrawableHitObject"/> which this <see cref="SelectionBlueprint"/> applies to.
-        /// </summary>
-        public readonly DrawableHitObject DrawableObject;
-
-        protected override bool ShouldBeAlive => (DrawableObject.IsAlive && DrawableObject.IsPresent) || State == SelectionState.Selected;
         public override bool HandlePositionalInput => ShouldBeAlive;
         public override bool RemoveWhenNotAlive => false;
 
         [Resolved(CanBeNull = true)]
         private HitObjectComposer composer { get; set; }
 
-        protected SelectionBlueprint(DrawableHitObject drawableObject)
+        protected SelectionBlueprint(HitObject hitObject)
         {
-            DrawableObject = drawableObject;
+            HitObject = hitObject;
 
             RelativeSizeAxes = Axes.Both;
-
             AlwaysPresent = true;
-            Alpha = 0;
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+            updateState();
         }
 
         private SelectionState state;
@@ -66,58 +66,68 @@ namespace osu.Game.Rulesets.Edit
 
                 state = value;
 
-                switch (state)
+                if (IsLoaded)
-                {
+                    updateState();
-                    case SelectionState.Selected:
-                        Show();
-                        Selected?.Invoke(this);
-                        break;
-
-                    case SelectionState.NotSelected:
-                        Hide();
-                        Deselected?.Invoke(this);
-                        break;
-                }
 
                 StateChanged?.Invoke(state);
             }
         }
 
+        private void updateState()
+        {
+            switch (state)
+            {
+                case SelectionState.Selected:
+                    OnSelected();
+                    Selected?.Invoke(this);
+                    break;
+
+                case SelectionState.NotSelected:
+                    OnDeselected();
+                    Deselected?.Invoke(this);
+                    break;
+            }
+        }
+
+        protected virtual void OnDeselected() => Hide();
+
+        protected virtual void OnSelected() => Show();
+
         // When not selected, input is only required for the blueprint itself to receive IsHovering
         protected override bool ShouldBeConsideredForInput(Drawable child) => State == SelectionState.Selected;
 
         /// <summary>
-        /// Selects this <see cref="SelectionBlueprint"/>, causing it to become visible.
+        /// Selects this <see cref="OverlaySelectionBlueprint"/>, causing it to become visible.
         /// </summary>
         public void Select() => State = SelectionState.Selected;
 
         /// <summary>
-        /// Deselects this <see cref="SelectionBlueprint"/>, causing it to become invisible.
+        /// Deselects this <see cref="OverlaySelectionBlueprint"/>, causing it to become invisible.
         /// </summary>
         public void Deselect() => State = SelectionState.NotSelected;
 
         public bool IsSelected => State == SelectionState.Selected;
 
         /// <summary>
-        /// Updates the <see cref="HitObject"/>, invoking <see cref="HitObject.ApplyDefaults"/> and re-processing the beatmap.
+        /// Updates the <see cref="Objects.HitObject"/>, invoking <see cref="Objects.HitObject.ApplyDefaults"/> and re-processing the beatmap.
         /// </summary>
-        protected void UpdateHitObject() => composer?.UpdateHitObject(DrawableObject.HitObject);
+        protected void UpdateHitObject() => composer?.UpdateHitObject(HitObject);
-
-        public override bool ReceivePositionalInputAt(Vector2 screenSpacePos) => DrawableObject.ReceivePositionalInputAt(screenSpacePos);
 
         /// <summary>
-        /// The <see cref="MenuItem"/>s to be displayed in the context menu for this <see cref="SelectionBlueprint"/>.
+        /// The <see cref="MenuItem"/>s to be displayed in the context menu for this <see cref="OverlaySelectionBlueprint"/>.
         /// </summary>
         public virtual MenuItem[] ContextMenuItems => Array.Empty<MenuItem>();
 
         /// <summary>
-        /// The screen-space point that causes this <see cref="SelectionBlueprint"/> to be selected.
+        /// The screen-space point that causes this <see cref="OverlaySelectionBlueprint"/> to be selected.
         /// </summary>
-        public virtual Vector2 SelectionPoint => DrawableObject.ScreenSpaceDrawQuad.Centre;
+        public virtual Vector2 SelectionPoint => ScreenSpaceDrawQuad.Centre;
 
         /// <summary>
-        /// The screen-space quad that outlines this <see cref="SelectionBlueprint"/> for selections.
+        /// The screen-space quad that outlines this <see cref="OverlaySelectionBlueprint"/> for selections.
         /// </summary>
-        public virtual Quad SelectionQuad => DrawableObject.ScreenSpaceDrawQuad;
+        public virtual Quad SelectionQuad => ScreenSpaceDrawQuad;
+
+        public virtual Vector2 GetInstantDelta(Vector2 screenSpacePosition) => Parent.ToLocalSpace(screenSpacePosition) - Position;
     }
 }

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

@@ -11,20 +11,24 @@ using osu.Game.Beatmaps;
 
 namespace osu.Game.Screens.Edit.Components.Timelines.Summary.Parts
 {
+    public class TimelinePart : TimelinePart<Drawable>
+    {
+    }
+
     /// <summary>
     /// Represents a part of the summary timeline..
     /// </summary>
-    public class TimelinePart : Container
+    public class TimelinePart<T> : Container<T> where T : Drawable
     {
         protected readonly IBindable<WorkingBeatmap> Beatmap = new Bindable<WorkingBeatmap>();
 
-        private readonly Container timeline;
+        private readonly Container<T> content;
 
-        protected override Container<Drawable> Content => timeline;
+        protected override Container<T> Content => content;
 
-        public TimelinePart()
+        public TimelinePart(Container<T> content = null)
         {
-            AddInternal(timeline = new Container { RelativeSizeAxes = Axes.Both });
+            AddInternal(this.content = content ?? new Container<T> { RelativeSizeAxes = Axes.Both });
 
             Beatmap.ValueChanged += b =>
             {
@@ -44,17 +48,17 @@ namespace osu.Game.Screens.Edit.Components.Timelines.Summary.Parts
             // the track may not be loaded completely (only has a length once it is).
             if (!Beatmap.Value.Track.IsLoaded)
             {
-                timeline.RelativeChildSize = Vector2.One;
+                content.RelativeChildSize = Vector2.One;
                 Schedule(updateRelativeChildSize);
                 return;
             }
 
-            timeline.RelativeChildSize = new Vector2((float)Math.Max(1, Beatmap.Value.Track.Length), 1);
+            content.RelativeChildSize = new Vector2((float)Math.Max(1, Beatmap.Value.Track.Length), 1);
         }
 
         protected virtual void LoadBeatmap(WorkingBeatmap beatmap)
         {
-            timeline.Clear();
+            content.Clear();
         }
     }
 }

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

@@ -6,6 +6,7 @@ using System.Collections.Generic;
 using System.Diagnostics;
 using System.Linq;
 using osu.Framework.Allocation;
+using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Primitives;
@@ -31,7 +32,7 @@ namespace osu.Game.Screens.Edit.Compose.Components
 
         protected DragBox DragBox { get; private set; }
 
-        private SelectionBlueprintContainer selectionBlueprints;
+        private Container<SelectionBlueprint> selectionBlueprints;
 
         private SelectionHandler selectionHandler;
 
@@ -41,6 +42,8 @@ namespace osu.Game.Screens.Edit.Compose.Components
         [Resolved]
         private EditorBeatmap beatmap { get; set; }
 
+        private readonly BindableList<HitObject> selectedHitObjects = new BindableList<HitObject>();
+
         [Resolved(canBeNull: true)]
         private IDistanceSnapProvider snapProvider { get; set; }
 
@@ -59,12 +62,25 @@ namespace osu.Game.Screens.Edit.Compose.Components
             {
                 DragBox = CreateDragBox(select),
                 selectionHandler,
-                selectionBlueprints = new SelectionBlueprintContainer { RelativeSizeAxes = Axes.Both },
+                selectionBlueprints = CreateSelectionBlueprintContainer(),
                 DragBox.CreateProxy().With(p => p.Depth = float.MinValue)
             });
 
             foreach (var obj in beatmap.HitObjects)
                 AddBlueprintFor(obj);
+
+            selectedHitObjects.BindTo(beatmap.SelectedHitObjects);
+            selectedHitObjects.ItemsAdded += objects =>
+            {
+                foreach (var o in objects)
+                    selectionBlueprints.FirstOrDefault(b => b.HitObject == o)?.Select();
+            };
+
+            selectedHitObjects.ItemsRemoved += objects =>
+            {
+                foreach (var o in objects)
+                    selectionBlueprints.FirstOrDefault(b => b.HitObject == o)?.Deselect();
+            };
         }
 
         protected override void LoadComplete()
@@ -75,6 +91,9 @@ namespace osu.Game.Screens.Edit.Compose.Components
             beatmap.HitObjectRemoved += removeBlueprintFor;
         }
 
+        protected virtual Container<SelectionBlueprint> CreateSelectionBlueprintContainer() =>
+            new Container<SelectionBlueprint> { RelativeSizeAxes = Axes.Both };
+
         /// <summary>
         /// Creates a <see cref="SelectionHandler"/> which outlines <see cref="DrawableHitObject"/>s and handles movement of selections.
         /// </summary>
@@ -91,6 +110,8 @@ namespace osu.Game.Screens.Edit.Compose.Components
         protected override bool OnMouseDown(MouseDownEvent e)
         {
             beginClickSelection(e);
+            prepareSelectionMovement();
+
             return e.Button == MouseButton.Left;
         }
 
@@ -118,7 +139,7 @@ namespace osu.Game.Screens.Edit.Compose.Components
             if (clickedBlueprint == null)
                 return false;
 
-            adjustableClock?.Seek(clickedBlueprint.DrawableObject.HitObject.StartTime);
+            adjustableClock?.Seek(clickedBlueprint.HitObject.StartTime);
             return true;
         }
 
@@ -126,6 +147,8 @@ namespace osu.Game.Screens.Edit.Compose.Components
         {
             // Special case for when a drag happened instead of a click
             Schedule(() => endClickSelection());
+
+            finishSelectionMovement();
         }
 
         protected override bool OnDragStart(DragStartEvent e)
@@ -133,15 +156,16 @@ namespace osu.Game.Screens.Edit.Compose.Components
             if (e.Button == MouseButton.Right)
                 return false;
 
-            if (!beginSelectionMovement())
+            if (movementBlueprint != null)
-            {
+                return true;
-                if (!DragBox.UpdateDrag(e))
-                    return false;
 
-                DragBox.FadeIn(250, Easing.OutQuint);
+            if (DragBox.HandleDrag(e))
+            {
+                DragBox.Show();
+                return true;
             }
 
-            return true;
+            return false;
         }
 
         protected override void OnDrag(DragEvent e)
@@ -149,8 +173,10 @@ namespace osu.Game.Screens.Edit.Compose.Components
             if (e.Button == MouseButton.Right)
                 return;
 
-            if (!moveCurrentSelection(e))
+            if (DragBox.State == Visibility.Visible)
-                DragBox.UpdateDrag(e);
+                DragBox.HandleDrag(e);
+
+            moveCurrentSelection(e);
         }
 
         protected override void OnDragEnd(DragEndEvent e)
@@ -158,9 +184,9 @@ namespace osu.Game.Screens.Edit.Compose.Components
             if (e.Button == MouseButton.Right)
                 return;
 
-            if (!finishSelectionMovement())
+            if (DragBox.State == Visibility.Visible)
             {
-                DragBox.FadeOut(250, Easing.OutQuint);
+                DragBox.Hide();
                 selectionHandler.UpdateVisibility();
             }
         }
@@ -200,7 +226,7 @@ namespace osu.Game.Screens.Edit.Compose.Components
 
         private void removeBlueprintFor(HitObject hitObject)
         {
-            var blueprint = selectionBlueprints.SingleOrDefault(m => m.DrawableObject.HitObject == hitObject);
+            var blueprint = selectionBlueprints.SingleOrDefault(m => m.HitObject == hitObject);
             if (blueprint == null)
                 return;
 
@@ -248,7 +274,7 @@ namespace osu.Game.Screens.Edit.Compose.Components
             if (!allowDeselection && selectionHandler.SelectedBlueprints.Any(s => s.IsHovered))
                 return;
 
-            foreach (SelectionBlueprint blueprint in selectionBlueprints.AliveBlueprints)
+            foreach (SelectionBlueprint blueprint in selectionBlueprints.AliveChildren)
             {
                 if (blueprint.IsHovered)
                 {
@@ -305,6 +331,7 @@ namespace osu.Game.Screens.Edit.Compose.Components
         {
             selectionHandler.HandleSelected(blueprint);
             selectionBlueprints.ChangeChildDepth(blueprint, 1);
+            beatmap.SelectedHitObjects.Add(blueprint.HitObject);
 
             SelectionChanged?.Invoke(selectionHandler.SelectedHitObjects);
         }
@@ -313,6 +340,7 @@ namespace osu.Game.Screens.Edit.Compose.Components
         {
             selectionHandler.HandleDeselected(blueprint);
             selectionBlueprints.ChangeChildDepth(blueprint, 0);
+            beatmap.SelectedHitObjects.Remove(blueprint.HitObject);
 
             SelectionChanged?.Invoke(selectionHandler.SelectedHitObjects);
         }
@@ -321,27 +349,25 @@ namespace osu.Game.Screens.Edit.Compose.Components
 
         #region Selection Movement
 
-        private Vector2? screenSpaceMovementStartPosition;
+        private Vector2? movementBlueprintOriginalPosition;
         private SelectionBlueprint movementBlueprint;
 
         /// <summary>
         /// Attempts to begin the movement of any selected blueprints.
         /// </summary>
-        /// <returns>Whether movement began.</returns>
+        private void prepareSelectionMovement()
-        private bool beginSelectionMovement()
         {
-            Debug.Assert(movementBlueprint == null);
+            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))
-                return false;
+                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.DrawableObject.HitObject.StartTime).First();
+            movementBlueprint = selectionHandler.SelectedBlueprints.OrderBy(b => b.HitObject.StartTime).First();
-            screenSpaceMovementStartPosition = movementBlueprint.DrawableObject.ToScreenSpace(movementBlueprint.DrawableObject.OriginPosition);
+            movementBlueprintOriginalPosition = movementBlueprint.SelectionPoint; // todo: unsure if correct
-
-            return true;
         }
 
         /// <summary>
@@ -354,17 +380,17 @@ namespace osu.Game.Screens.Edit.Compose.Components
             if (movementBlueprint == null)
                 return false;
 
-            Debug.Assert(screenSpaceMovementStartPosition != null);
+            Debug.Assert(movementBlueprintOriginalPosition != null);
 
-            Vector2 startPosition = screenSpaceMovementStartPosition.Value;
+            HitObject draggedObject = movementBlueprint.HitObject;
-            HitObject draggedObject = movementBlueprint.DrawableObject.HitObject;
 
             // The final movement position, relative to screenSpaceMovementStartPosition
-            Vector2 movePosition = startPosition + e.ScreenSpaceMousePosition - e.ScreenSpaceMouseDownPosition;
+            Vector2 movePosition = movementBlueprintOriginalPosition.Value + e.ScreenSpaceMousePosition - e.ScreenSpaceMouseDownPosition;
+
             (Vector2 snappedPosition, double snappedTime) = snapProvider.GetSnappedPosition(ToLocalSpace(movePosition), draggedObject.StartTime);
 
             // Move the hitobjects
-            if (!selectionHandler.HandleMovement(new MoveSelectionEvent(movementBlueprint, startPosition, ToScreenSpace(snappedPosition))))
+            if (!selectionHandler.HandleMovement(new MoveSelectionEvent(movementBlueprint, ToScreenSpace(snappedPosition))))
                 return true;
 
             // Apply the start time at the newly snapped-to position
@@ -384,7 +410,7 @@ namespace osu.Game.Screens.Edit.Compose.Components
             if (movementBlueprint == null)
                 return false;
 
-            screenSpaceMovementStartPosition = null;
+            movementBlueprintOriginalPosition = null;
             movementBlueprint = null;
 
             return true;
@@ -402,30 +428,5 @@ namespace osu.Game.Screens.Edit.Compose.Components
                 beatmap.HitObjectRemoved -= removeBlueprintFor;
             }
         }
-
-        private class SelectionBlueprintContainer : Container<SelectionBlueprint>
-        {
-            public IEnumerable<SelectionBlueprint> AliveBlueprints => AliveInternalChildren.Cast<SelectionBlueprint>();
-
-            protected override int Compare(Drawable x, Drawable y)
-            {
-                if (!(x is SelectionBlueprint xBlueprint) || !(y is SelectionBlueprint yBlueprint))
-                    return base.Compare(x, y);
-
-                return Compare(xBlueprint, yBlueprint);
-            }
-
-            public int Compare(SelectionBlueprint x, SelectionBlueprint y)
-            {
-                // dpeth is used to denote selected status (we always want selected blueprints to handle input first).
-                int d = x.Depth.CompareTo(y.Depth);
-                if (d != 0)
-                    return d;
-
-                // Put earlier hitobjects towards the end of the list, so they handle input first
-                int i = y.DrawableObject.HitObject.StartTime.CompareTo(x.DrawableObject.HitObject.StartTime);
-                return i == 0 ? CompareReverseChildID(x, y) : i;
-            }
-        }
     }
 }

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

@@ -119,7 +119,7 @@ namespace osu.Game.Screens.Edit.Compose.Components
             return CreateBlueprintFor(drawable);
         }
 
-        public virtual SelectionBlueprint CreateBlueprintFor(DrawableHitObject hitObject) => null;
+        public virtual OverlaySelectionBlueprint CreateBlueprintFor(DrawableHitObject hitObject) => null;
 
         protected override void AddBlueprintFor(HitObject hitObject)
         {

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

@@ -2,6 +2,7 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
+using osu.Framework;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
@@ -15,11 +16,11 @@ namespace osu.Game.Screens.Edit.Compose.Components
     /// <summary>
     /// A box that displays the drag selection and provides selection events for users to handle.
     /// </summary>
-    public class DragBox : CompositeDrawable
+    public class DragBox : CompositeDrawable, IStateful<Visibility>
     {
-        private readonly Action<RectangleF> performSelection;
+        protected readonly Action<RectangleF> PerformSelection;
 
-        private Drawable box;
+        protected Drawable Box;
 
         /// <summary>
         /// Creates a new <see cref="DragBox"/>.
@@ -27,7 +28,7 @@ namespace osu.Game.Screens.Edit.Compose.Components
         /// <param name="performSelection">A delegate that performs drag selection.</param>
         public DragBox(Action<RectangleF> performSelection)
         {
-            this.performSelection = performSelection;
+            PerformSelection = performSelection;
 
             RelativeSizeAxes = Axes.Both;
             AlwaysPresent = true;
@@ -37,25 +38,27 @@ namespace osu.Game.Screens.Edit.Compose.Components
         [BackgroundDependencyLoader]
         private void load()
         {
-            InternalChild = box = new Container
+            InternalChild = Box = CreateBox();
-            {
-                Masking = true,
-                BorderColour = Color4.White,
-                BorderThickness = SelectionHandler.BORDER_RADIUS,
-                Child = new Box
-                {
-                    RelativeSizeAxes = Axes.Both,
-                    Alpha = 0.1f
-                }
-            };
         }
 
+        protected virtual Drawable CreateBox() => new Container
+        {
+            Masking = true,
+            BorderColour = Color4.White,
+            BorderThickness = SelectionHandler.BORDER_RADIUS,
+            Child = new Box
+            {
+                RelativeSizeAxes = Axes.Both,
+                Alpha = 0.1f
+            }
+        };
+
         /// <summary>
         /// Handle a forwarded mouse event.
         /// </summary>
         /// <param name="e">The mouse event.</param>
         /// <returns>Whether the event should be handled and blocking.</returns>
-        public virtual bool UpdateDrag(MouseButtonEvent e)
+        public virtual bool HandleDrag(MouseButtonEvent e)
         {
             var dragPosition = e.ScreenSpaceMousePosition;
             var dragStartPosition = e.ScreenSpaceMouseDownPosition;
@@ -68,11 +71,32 @@ namespace osu.Game.Screens.Edit.Compose.Components
             var topLeft = ToLocalSpace(dragRectangle.TopLeft);
             var bottomRight = ToLocalSpace(dragRectangle.BottomRight);
 
-            box.Position = topLeft;
+            Box.Position = topLeft;
-            box.Size = bottomRight - topLeft;
+            Box.Size = bottomRight - topLeft;
 
-            performSelection?.Invoke(dragRectangle);
+            PerformSelection?.Invoke(dragRectangle);
             return true;
         }
+
+        private Visibility state;
+
+        public Visibility State
+        {
+            get => state;
+            set
+            {
+                if (value == state) return;
+
+                state = value;
+                this.FadeTo(state == Visibility.Hidden ? 0 : 1, 250, Easing.OutQuint);
+                StateChanged?.Invoke(state);
+            }
+        }
+
+        public override void Hide() => State = Visibility.Hidden;
+
+        public override void Show() => State = Visibility.Visible;
+
+        public event Action<Visibility> StateChanged;
     }
 }

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

@@ -7,7 +7,7 @@ using osuTK;
 namespace osu.Game.Screens.Edit.Compose.Components
 {
     /// <summary>
-    /// An event which occurs when a <see cref="SelectionBlueprint"/> is moved.
+    /// An event which occurs when a <see cref="OverlaySelectionBlueprint"/> is moved.
     /// </summary>
     public class MoveSelectionEvent
     {
@@ -16,11 +16,6 @@ namespace osu.Game.Screens.Edit.Compose.Components
         /// </summary>
         public readonly SelectionBlueprint Blueprint;
 
-        /// <summary>
-        /// The starting screen-space position of the hitobject.
-        /// </summary>
-        public readonly Vector2 ScreenSpaceStartPosition;
-
         /// <summary>
         /// The expected screen-space position of the hitobject at the current cursor position.
         /// </summary>
@@ -29,18 +24,14 @@ namespace osu.Game.Screens.Edit.Compose.Components
         /// <summary>
         /// The distance between <see cref="ScreenSpacePosition"/> and the hitobject's current position, in the coordinate-space of the hitobject's parent.
         /// </summary>
-        /// <remarks>
-        /// This does not use <see cref="ScreenSpaceStartPosition"/> and does not represent the cumulative movement distance.
-        /// </remarks>
         public readonly Vector2 InstantDelta;
 
-        public MoveSelectionEvent(SelectionBlueprint blueprint, Vector2 screenSpaceStartPosition, Vector2 screenSpacePosition)
+        public MoveSelectionEvent(SelectionBlueprint blueprint, Vector2 screenSpacePosition)
         {
             Blueprint = blueprint;
-            ScreenSpaceStartPosition = screenSpaceStartPosition;
             ScreenSpacePosition = screenSpacePosition;
 
-            InstantDelta = Blueprint.DrawableObject.Parent.ToLocalSpace(ScreenSpacePosition) - Blueprint.DrawableObject.Position;
+            InstantDelta = Blueprint.GetInstantDelta(ScreenSpacePosition);
         }
     }
 }

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

@@ -33,12 +33,12 @@ namespace osu.Game.Screens.Edit.Compose.Components
         public IEnumerable<SelectionBlueprint> SelectedBlueprints => selectedBlueprints;
         private readonly List<SelectionBlueprint> selectedBlueprints;
 
-        public IEnumerable<HitObject> SelectedHitObjects => selectedBlueprints.Select(b => b.DrawableObject.HitObject);
+        public IEnumerable<HitObject> SelectedHitObjects => selectedBlueprints.Select(b => b.HitObject);
 
         private Drawable outline;
 
         [Resolved(CanBeNull = true)]
-        private IPlacementHandler placementHandler { get; set; }
+        private EditorBeatmap editorBeatmap { get; set; }
 
         public SelectionHandler()
         {
@@ -104,7 +104,13 @@ namespace osu.Game.Screens.Edit.Compose.Components
         /// Handle a blueprint becoming selected.
         /// </summary>
         /// <param name="blueprint">The blueprint.</param>
-        internal void HandleSelected(SelectionBlueprint blueprint) => selectedBlueprints.Add(blueprint);
+        internal void HandleSelected(SelectionBlueprint blueprint)
+        {
+            selectedBlueprints.Add(blueprint);
+            editorBeatmap.SelectedHitObjects.Add(blueprint.HitObject);
+
+            UpdateVisibility();
+        }
 
         /// <summary>
         /// Handle a blueprint becoming deselected.
@@ -113,6 +119,7 @@ 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)
@@ -141,14 +148,12 @@ namespace osu.Game.Screens.Edit.Compose.Components
                 DeselectAll?.Invoke();
                 blueprint.Select();
             }
-
-            UpdateVisibility();
         }
 
         private void deleteSelected()
         {
             foreach (var h in selectedBlueprints.ToList())
-                placementHandler.Delete(h.DrawableObject.HitObject);
+                editorBeatmap.Remove(h.HitObject);
         }
 
         #endregion

osu.Game/Screens/Edit/Compose/Components/Timeline/Timeline.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.Framework.Allocation;
 using osu.Framework.Audio.Track;
 using osu.Framework.Bindables;
@@ -11,10 +12,14 @@ using osu.Framework.Input.Events;
 using osu.Framework.Timing;
 using osu.Game.Beatmaps;
 using osu.Game.Graphics;
+using osu.Game.Rulesets.Edit;
+using osuTK;
 
 namespace osu.Game.Screens.Edit.Compose.Components.Timeline
 {
-    public class Timeline : ZoomableScrollContainer
+    [Cached(typeof(IDistanceSnapProvider))]
+    [Cached]
+    public class Timeline : ZoomableScrollContainer, IDistanceSnapProvider
     {
         public readonly Bindable<bool> WaveformVisible = new Bindable<bool>();
         public readonly IBindable<WorkingBeatmap> Beatmap = new Bindable<WorkingBeatmap>();
@@ -162,5 +167,27 @@ namespace osu.Game.Screens.Edit.Compose.Components.Timeline
             if (trackWasPlaying)
                 adjustableClock.Start();
         }
+
+        [Resolved]
+        private EditorBeatmap beatmap { get; set; }
+
+        [Resolved]
+        private IBeatSnapProvider beatSnapProvider { get; set; }
+
+        public (Vector2 position, double time) GetSnappedPosition(Vector2 position, double time)
+        {
+            var targetTime = (position.X / Content.DrawWidth) * track.Length;
+            return (position, beatSnapProvider.SnapTime(targetTime, targetTime));
+        }
+
+        public float GetBeatSnapDistanceAt(double referenceTime) => throw new NotImplementedException();
+
+        public float DurationToDistance(double referenceTime, double duration) => throw new NotImplementedException();
+
+        public double DistanceToDuration(double referenceTime, float distance) => throw new NotImplementedException();
+
+        public double GetSnappedDurationFromDistance(double referenceTime, float distance) => throw new NotImplementedException();
+
+        public float GetSnappedDistanceFromDistance(double referenceTime, float distance) => throw new NotImplementedException();
     }
 }

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

@@ -0,0 +1,141 @@
+// 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.Primitives;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Input.Events;
+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
+{
+    internal class TimelineBlueprintContainer : BlueprintContainer
+    {
+        [Resolved(CanBeNull = true)]
+        private Timeline timeline { get; set; }
+
+        private DragEvent lastDragEvent;
+
+        public TimelineBlueprintContainer()
+        {
+            RelativeSizeAxes = Axes.Both;
+            Anchor = Anchor.Centre;
+            Origin = Anchor.Centre;
+
+            Height = 0.4f;
+
+            AddInternal(new Box
+            {
+                Colour = Color4.Black,
+                RelativeSizeAxes = Axes.Both,
+                Alpha = 0.1f,
+            });
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+            DragBox.Alpha = 0;
+        }
+
+        protected override Container<SelectionBlueprint> CreateSelectionBlueprintContainer() => new TimelineSelectionBlueprintContainer { RelativeSizeAxes = Axes.Both };
+
+        protected override void OnDrag(DragEvent e)
+        {
+            if (timeline != null)
+            {
+                var timelineQuad = timeline.ScreenSpaceDrawQuad;
+                var mouseX = e.ScreenSpaceMousePosition.X;
+
+                // scroll if in a drag and dragging outside visible extents
+                if (mouseX > timelineQuad.TopRight.X)
+                    timeline.ScrollBy((float)((mouseX - timelineQuad.TopRight.X) / 10 * Clock.ElapsedFrameTime));
+                else if (mouseX < timelineQuad.TopLeft.X)
+                    timeline.ScrollBy((float)((mouseX - timelineQuad.TopLeft.X) / 10 * Clock.ElapsedFrameTime));
+            }
+
+            base.OnDrag(e);
+            lastDragEvent = e;
+        }
+
+        protected override void OnDragEnd(DragEndEvent e)
+        {
+            base.OnDragEnd(e);
+            lastDragEvent = null;
+        }
+
+        protected override void Update()
+        {
+            // trigger every frame so drags continue to update selection while playback is scrolling the timeline.
+            if (IsDragged)
+                OnDrag(lastDragEvent);
+
+            base.Update();
+        }
+
+        protected override SelectionHandler CreateSelectionHandler() => new TimelineSelectionHandler();
+
+        protected override SelectionBlueprint CreateBlueprintFor(HitObject hitObject) => new TimelineHitObjectBlueprint(hitObject);
+
+        protected override DragBox CreateDragBox(Action<RectangleF> performSelect) => new TimelineDragBox(performSelect);
+
+        internal class TimelineSelectionHandler : SelectionHandler
+        {
+            // for now we always allow movement. snapping is provided by the Timeline's "distance" snap implementation
+            public override bool HandleMovement(MoveSelectionEvent moveEvent) => true;
+        }
+
+        private class TimelineDragBox : DragBox
+        {
+            private Vector2 lastMouseDown;
+            private float localMouseDown;
+
+            public TimelineDragBox(Action<RectangleF> performSelect)
+                : base(performSelect)
+            {
+            }
+
+            protected override Drawable CreateBox() => new Box
+            {
+                RelativeSizeAxes = Axes.Y,
+                Alpha = 0.3f
+            };
+
+            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;
+                }
+
+                float selection1 = localMouseDown;
+                float selection2 = e.MousePosition.X;
+
+                Box.X = Math.Min(selection1, selection2);
+                Box.Width = Math.Abs(selection1 - selection2);
+
+                PerformSelection?.Invoke(Box.ScreenSpaceDrawQuad.AABBFloat);
+                return true;
+            }
+        }
+
+        protected class TimelineSelectionBlueprintContainer : Container<SelectionBlueprint>
+        {
+            protected override Container<SelectionBlueprint> Content { get; }
+
+            public TimelineSelectionBlueprintContainer()
+            {
+                AddInternal(new TimelinePart<SelectionBlueprint>(Content = new Container<SelectionBlueprint> { RelativeSizeAxes = Axes.Both }) { RelativeSizeAxes = Axes.Both });
+            }
+        }
+    }
+}

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

@@ -0,0 +1,116 @@
+// 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 JetBrains.Annotations;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Primitives;
+using osu.Framework.Graphics.Shapes;
+using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Objects.Types;
+using osuTK;
+using osuTK.Graphics;
+
+namespace osu.Game.Screens.Edit.Compose.Components.Timeline
+{
+    public class TimelineHitObjectBlueprint : SelectionBlueprint
+    {
+        private readonly Circle circle;
+
+        private readonly Container extensionBar;
+
+        [UsedImplicitly]
+        private readonly Bindable<double> startTime;
+
+        public const float THICKNESS = 3;
+
+        private const float circle_size = 16;
+
+        public override bool ReceivePositionalInputAt(Vector2 screenSpacePos) => base.ReceivePositionalInputAt(screenSpacePos) || circle.ReceivePositionalInputAt(screenSpacePos);
+
+        public TimelineHitObjectBlueprint(HitObject hitObject)
+            : base(hitObject)
+        {
+            Anchor = Anchor.CentreLeft;
+            Origin = Anchor.CentreLeft;
+
+            startTime = hitObject.StartTimeBindable.GetBoundCopy();
+            startTime.BindValueChanged(time => X = (float)time.NewValue, true);
+
+            RelativePositionAxes = Axes.X;
+
+            RelativeSizeAxes = Axes.X;
+            AutoSizeAxes = Axes.Y;
+
+            if (hitObject is IHasEndTime)
+            {
+                AddInternal(extensionBar = new Container
+                {
+                    CornerRadius = 2,
+                    Masking = true,
+                    Size = new Vector2(1, THICKNESS),
+                    Anchor = Anchor.CentreLeft,
+                    Origin = Anchor.CentreLeft,
+                    RelativePositionAxes = Axes.X,
+                    RelativeSizeAxes = Axes.X,
+                    Colour = Color4.Black,
+                    Child = new Box
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                    }
+                });
+            }
+
+            AddInternal(circle = new Circle
+            {
+                Size = new Vector2(circle_size),
+                Anchor = Anchor.CentreLeft,
+                Origin = Anchor.Centre,
+                RelativePositionAxes = Axes.X,
+                AlwaysPresent = true,
+                Colour = Color4.White,
+                BorderColour = Color4.Black,
+                BorderThickness = THICKNESS,
+            });
+        }
+
+        protected override void Update()
+        {
+            base.Update();
+
+            // no bindable so we perform this every update
+            Width = (float)(HitObject.GetEndTime() - HitObject.StartTime);
+        }
+
+        protected override void OnSelected()
+        {
+            circle.BorderColour = Color4.Orange;
+            if (extensionBar != null)
+                extensionBar.Colour = Color4.Orange;
+        }
+
+        protected override void OnDeselected()
+        {
+            circle.BorderColour = Color4.Black;
+            if (extensionBar != null)
+                extensionBar.Colour = Color4.Black;
+        }
+
+        public override Quad SelectionQuad
+        {
+            get
+            {
+                // correctly include the circle in the selection quad region, as it is usually outside the blueprint itself.
+                var circleQuad = circle.ScreenSpaceDrawQuad;
+                var actualQuad = ScreenSpaceDrawQuad;
+
+                return new Quad(circleQuad.TopLeft, Vector2.ComponentMax(actualQuad.TopRight, circleQuad.TopRight),
+                    circleQuad.BottomLeft, Vector2.ComponentMax(actualQuad.BottomRight, circleQuad.BottomRight));
+            }
+        }
+
+        public override Vector2 SelectionPoint => ScreenSpaceDrawQuad.TopLeft;
+    }
+}

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

@@ -1,140 +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 System;
-using System.Linq;
-using osu.Framework.Allocation;
-using osu.Framework.Graphics;
-using osu.Framework.Graphics.Containers;
-using osu.Framework.Graphics.Primitives;
-using osu.Framework.Graphics.Shapes;
-using osu.Framework.Input.Events;
-using osu.Game.Rulesets.Objects;
-using osu.Game.Rulesets.Objects.Types;
-using osu.Game.Screens.Edit.Components.Timelines.Summary.Parts;
-using osuTK;
-using osuTK.Graphics;
-
-namespace osu.Game.Screens.Edit.Compose.Components.Timeline
-{
-    internal class TimelineHitObjectDisplay : BlueprintContainer
-    {
-        private EditorBeatmap beatmap { get; }
-
-        private readonly TimelinePart content;
-
-        public TimelineHitObjectDisplay(EditorBeatmap beatmap)
-        {
-            RelativeSizeAxes = Axes.Both;
-
-            this.beatmap = beatmap;
-
-            AddInternal(content = new TimelinePart { RelativeSizeAxes = Axes.Both });
-        }
-
-        [BackgroundDependencyLoader]
-        private void load()
-        {
-            foreach (var h in beatmap.HitObjects)
-                add(h);
-
-            beatmap.HitObjectAdded += add;
-            beatmap.HitObjectRemoved += remove;
-            beatmap.StartTimeChanged += h =>
-            {
-                remove(h);
-                add(h);
-            };
-        }
-
-        protected override void LoadComplete()
-        {
-            base.LoadComplete();
-            DragBox.Alpha = 0;
-        }
-
-        private void remove(HitObject h)
-        {
-            foreach (var d in content.OfType<TimelineHitObjectRepresentation>().Where(c => c.HitObject == h))
-                d.Expire();
-        }
-
-        private void add(HitObject h)
-        {
-            var yOffset = content.Count(d => d.X == h.StartTime);
-
-            content.Add(new TimelineHitObjectRepresentation(h) { Y = -yOffset * TimelineHitObjectRepresentation.THICKNESS });
-        }
-
-        protected override bool OnMouseDown(MouseDownEvent e)
-        {
-            base.OnMouseDown(e);
-
-            return false; // tempoerary until we correctly handle selections.
-        }
-
-        protected override DragBox CreateDragBox(Action<RectangleF> performSelect) => new NoDragDragBox(performSelect);
-
-        internal class NoDragDragBox : DragBox
-        {
-            public NoDragDragBox(Action<RectangleF> performSelect)
-                : base(performSelect)
-            {
-            }
-
-            public override bool UpdateDrag(MouseButtonEvent e) => false;
-        }
-
-        private class TimelineHitObjectRepresentation : CompositeDrawable
-        {
-            public const float THICKNESS = 3;
-
-            public readonly HitObject HitObject;
-
-            public TimelineHitObjectRepresentation(HitObject hitObject)
-            {
-                HitObject = hitObject;
-                Anchor = Anchor.CentreLeft;
-                Origin = Anchor.CentreLeft;
-
-                Width = (float)(hitObject.GetEndTime() - hitObject.StartTime);
-
-                X = (float)hitObject.StartTime;
-
-                RelativePositionAxes = Axes.X;
-                RelativeSizeAxes = Axes.X;
-
-                if (hitObject is IHasEndTime)
-                {
-                    AddInternal(new Container
-                    {
-                        CornerRadius = 2,
-                        Masking = true,
-                        Size = new Vector2(1, THICKNESS),
-                        Anchor = Anchor.CentreLeft,
-                        Origin = Anchor.CentreLeft,
-                        RelativePositionAxes = Axes.X,
-                        RelativeSizeAxes = Axes.X,
-                        Colour = Color4.Black,
-                        Child = new Box
-                        {
-                            RelativeSizeAxes = Axes.Both,
-                        }
-                    });
-                }
-
-                AddInternal(new Circle
-                {
-                    Size = new Vector2(16),
-                    Anchor = Anchor.CentreLeft,
-                    Origin = Anchor.Centre,
-                    RelativePositionAxes = Axes.X,
-                    AlwaysPresent = true,
-                    Colour = Color4.White,
-                    BorderColour = Color4.Black,
-                    BorderThickness = THICKNESS,
-                });
-            }
-        }
-    }
-}

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

@@ -32,6 +32,6 @@ namespace osu.Game.Screens.Edit.Compose
             return beatmapSkinProvider.WithChild(rulesetSkinProvider.WithChild(composer));
         }
 
-        protected override Drawable CreateTimelineContent() => composer == null ? base.CreateTimelineContent() : new TimelineHitObjectDisplay(EditorBeatmap);
+        protected override Drawable CreateTimelineContent() => composer == null ? base.CreateTimelineContent() : new TimelineBlueprintContainer();
     }
 }

osu.Game/Screens/Edit/EditorBeatmap.cs

@@ -30,6 +30,8 @@ namespace osu.Game.Screens.Edit
         /// </summary>
         public event Action<HitObject> StartTimeChanged;
 
+        public BindableList<HitObject> SelectedHitObjects { get; } = new BindableList<HitObject>();
+
         public readonly IBeatmap PlayableBeatmap;
 
         private readonly BindableBeatDivisor beatDivisor;

osu.Game/Screens/Edit/EditorScreenWithTimeline.cs

@@ -20,7 +20,7 @@ namespace osu.Game.Screens.Edit
 
         private readonly BindableBeatDivisor beatDivisor = new BindableBeatDivisor();
 
-        private TimelineArea timelineArea;
+        private Container timelineContainer;
 
         [BackgroundDependencyLoader(true)]
         private void load([CanBeNull] BindableBeatDivisor beatDivisor)
@@ -62,11 +62,10 @@ namespace osu.Game.Screens.Edit
                                             {
                                                 new Drawable[]
                                                 {
-                                                    new Container
+                                                    timelineContainer = new Container
                                                     {
                                                         RelativeSizeAxes = Axes.Both,
                                                         Padding = new MarginPadding { Right = 5 },
-                                                        Child = timelineArea = CreateTimelineArea()
                                                     },
                                                     new BeatDivisorControl(beatDivisor) { RelativeSizeAxes = Axes.Both }
                                                 },
@@ -100,14 +99,16 @@ namespace osu.Game.Screens.Edit
                 mainContent.Add(content);
                 content.FadeInFromZero(300, Easing.OutQuint);
 
-                LoadComponentAsync(CreateTimelineContent(), timelineArea.Add);
+                LoadComponentAsync(new TimelineArea
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Child = CreateTimelineContent()
+                }, timelineContainer.Add);
             });
         }
 
         protected abstract Drawable CreateMainContent();
 
         protected virtual Drawable CreateTimelineContent() => new Container();
-
-        protected TimelineArea CreateTimelineArea() => new TimelineArea { RelativeSizeAxes = Axes.Both };
     }
 }

osu.Game/Tests/Visual/SelectionBlueprintTestScene.cs

@@ -22,7 +22,7 @@ namespace osu.Game.Tests.Visual
             });
         }
 
-        protected void AddBlueprint(SelectionBlueprint blueprint)
+        protected void AddBlueprint(OverlaySelectionBlueprint blueprint)
         {
             Add(blueprint.With(d =>
             {