Remove intermediate Screens namespace

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

@@ -0,0 +1,397 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using System;
+using System.Linq;
+using osu.Framework.Allocation;
+using osu.Framework.Configuration;
+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.Framework.Graphics.Sprites;
+using osu.Framework.Graphics.UserInterface;
+using osu.Framework.Input.Events;
+using osu.Game.Graphics;
+using osu.Game.Graphics.UserInterface;
+using OpenTK;
+using OpenTK.Graphics;
+using OpenTK.Input;
+
+namespace osu.Game.Screens.Edit.Compose.Components
+{
+    public class BeatDivisorControl : CompositeDrawable
+    {
+        private readonly BindableBeatDivisor beatDivisor = new BindableBeatDivisor();
+
+        public BeatDivisorControl(BindableBeatDivisor beatDivisor)
+        {
+            this.beatDivisor.BindTo(beatDivisor);
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(OsuColour colours)
+        {
+            Masking = true;
+            CornerRadius = 5;
+
+            InternalChildren = new Drawable[]
+            {
+                new Box
+                {
+                    Name = "Gray Background",
+                    RelativeSizeAxes = Axes.Both,
+                    Colour = colours.Gray4
+                },
+                new GridContainer
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Content = new[]
+                    {
+                        new Drawable[]
+                        {
+                            new Container
+                            {
+                                RelativeSizeAxes = Axes.Both,
+                                Children = new Drawable[]
+                                {
+                                    new Box
+                                    {
+                                        Name = "Black Background",
+                                        RelativeSizeAxes = Axes.Both,
+                                        Colour = Color4.Black
+                                    },
+                                    new TickSliderBar(beatDivisor, BindableBeatDivisor.VALID_DIVISORS)
+                                    {
+                                        RelativeSizeAxes = Axes.Both,
+                                    }
+                                }
+                            }
+                        },
+                        new Drawable[]
+                        {
+                            new Container
+                            {
+                                RelativeSizeAxes = Axes.Both,
+                                Children = new Drawable[]
+                                {
+                                    new Box
+                                    {
+                                        RelativeSizeAxes = Axes.Both,
+                                        Colour = colours.Gray4
+                                    },
+                                    new Container
+                                    {
+                                        RelativeSizeAxes = Axes.Both,
+                                        Padding = new MarginPadding { Horizontal = 5 },
+                                        Child = new GridContainer
+                                        {
+                                            RelativeSizeAxes = Axes.Both,
+                                            Content = new[]
+                                            {
+                                                new Drawable[]
+                                                {
+                                                    new DivisorButton
+                                                    {
+                                                        Icon = FontAwesome.fa_chevron_left,
+                                                        Action = beatDivisor.Previous
+                                                    },
+                                                    new DivisorText(beatDivisor),
+                                                    new DivisorButton
+                                                    {
+                                                        Icon = FontAwesome.fa_chevron_right,
+                                                        Action = beatDivisor.Next
+                                                    }
+                                                },
+                                            },
+                                            ColumnDimensions = new[]
+                                            {
+                                                new Dimension(GridSizeMode.Absolute, 20),
+                                                new Dimension(),
+                                                new Dimension(GridSizeMode.Absolute, 20)
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        },
+                        new Drawable[]
+                        {
+                            new TextFlowContainer(s => s.TextSize = 14)
+                            {
+                                Padding = new MarginPadding { Horizontal = 15 },
+                                Text = "beat snap divisor",
+                                RelativeSizeAxes = Axes.X,
+                                TextAnchor = Anchor.TopCentre
+                            },
+                        }
+                    },
+                    RowDimensions = new[]
+                    {
+                        new Dimension(GridSizeMode.Absolute, 30),
+                        new Dimension(GridSizeMode.Absolute, 25),
+                    }
+                }
+            };
+        }
+
+        private class DivisorText : SpriteText
+        {
+            private readonly Bindable<int> beatDivisor = new Bindable<int>();
+
+            public DivisorText(BindableBeatDivisor beatDivisor)
+            {
+                this.beatDivisor.BindTo(beatDivisor);
+
+                Anchor = Anchor.Centre;
+                Origin = Anchor.Centre;
+            }
+
+            [BackgroundDependencyLoader]
+            private void load(OsuColour colours)
+            {
+                Colour = colours.BlueLighter;
+            }
+
+            protected override void LoadComplete()
+            {
+                base.LoadComplete();
+
+                beatDivisor.ValueChanged += v => updateText();
+                updateText();
+            }
+
+            private void updateText() => Text = $"1/{beatDivisor.Value}";
+        }
+
+        private class DivisorButton : IconButton
+        {
+            public DivisorButton()
+            {
+                Anchor = Anchor.Centre;
+                Origin = Anchor.Centre;
+
+                // Small offset to look a bit better centered along with the divisor text
+                Y = 1;
+
+                ButtonSize = new Vector2(20);
+                IconScale = new Vector2(0.6f);
+            }
+
+            [BackgroundDependencyLoader]
+            private void load(OsuColour colours)
+            {
+                IconColour = Color4.Black;
+                HoverColour = colours.Gray7;
+                FlashColour = colours.Gray9;
+            }
+        }
+
+        private class TickSliderBar : SliderBar<int>
+        {
+            private Marker marker;
+
+            private readonly BindableBeatDivisor beatDivisor;
+            private readonly int[] availableDivisors;
+
+            public TickSliderBar(BindableBeatDivisor beatDivisor, params int[] divisors)
+            {
+                CurrentNumber.BindTo(this.beatDivisor = beatDivisor);
+                availableDivisors = divisors;
+
+                Padding = new MarginPadding { Horizontal = 5 };
+            }
+
+            [BackgroundDependencyLoader]
+            private void load()
+            {
+                foreach (var t in availableDivisors)
+                {
+                    AddInternal(new Tick(t)
+                    {
+                        Anchor = Anchor.TopLeft,
+                        Origin = Anchor.TopCentre,
+                        RelativePositionAxes = Axes.X,
+                        X = getMappedPosition(t)
+                    });
+                }
+
+                AddInternal(marker = new Marker());
+
+                CurrentNumber.ValueChanged += v =>
+                {
+                    marker.MoveToX(getMappedPosition(v), 100, Easing.OutQuint);
+                    marker.Flash();
+                };
+            }
+
+            protected override void UpdateValue(float value)
+            {
+            }
+
+            public override bool HandleNonPositionalInput => IsHovered && !CurrentNumber.Disabled;
+
+            protected override bool OnKeyDown(KeyDownEvent e)
+            {
+                switch (e.Key)
+                {
+                    case Key.Right:
+                        beatDivisor.Next();
+                        OnUserChange();
+                        return true;
+                    case Key.Left:
+                        beatDivisor.Previous();
+                        OnUserChange();
+                        return true;
+                    default:
+                        return false;
+                }
+            }
+
+            protected override bool OnMouseDown(MouseDownEvent e)
+            {
+                marker.Active = true;
+                return base.OnMouseDown(e);
+            }
+
+            protected override bool OnMouseUp(MouseUpEvent e)
+            {
+                marker.Active = false;
+                return base.OnMouseUp(e);
+            }
+
+            protected override bool OnClick(ClickEvent e)
+            {
+                handleMouseInput(e.ScreenSpaceMousePosition);
+                return true;
+            }
+
+            protected override bool OnDrag(DragEvent e)
+            {
+                handleMouseInput(e.ScreenSpaceMousePosition);
+                return true;
+            }
+
+            private void handleMouseInput(Vector2 screenSpaceMousePosition)
+            {
+                // copied from SliderBar so we can do custom spacing logic.
+                var xPosition = (ToLocalSpace(screenSpaceMousePosition).X - RangePadding) / UsableWidth;
+
+                CurrentNumber.Value = availableDivisors.OrderBy(d => Math.Abs(getMappedPosition(d) - xPosition)).First();
+                OnUserChange();
+            }
+
+            private float getMappedPosition(float divisor) => (float)Math.Pow((divisor - 1) / (availableDivisors.Last() - 1), 0.90f);
+
+            private class Tick : CompositeDrawable
+            {
+                private readonly int divisor;
+
+                public Tick(int divisor)
+                {
+                    this.divisor = divisor;
+                    Size = new Vector2(2.5f, 10);
+
+                    InternalChild = new Box { RelativeSizeAxes = Axes.Both };
+
+                    CornerRadius = 0.5f;
+                    Masking = true;
+                }
+
+                [BackgroundDependencyLoader]
+                private void load(OsuColour colours)
+                {
+                    Colour = getColourForDivisor(divisor, colours);
+                }
+
+                private ColourInfo getColourForDivisor(int divisor, OsuColour colours)
+                {
+                    switch (divisor)
+                    {
+                        case 2:
+                            return colours.BlueLight;
+                        case 4:
+                            return colours.Blue;
+                        case 8:
+                            return colours.BlueDarker;
+                        case 16:
+                            return colours.PurpleDark;
+                        case 3:
+                            return colours.YellowLight;
+                        case 6:
+                            return colours.Yellow;
+                        case 12:
+                            return colours.YellowDarker;
+                        default:
+                            return Color4.White;
+                    }
+                }
+            }
+
+            private class Marker : CompositeDrawable
+            {
+                private Color4 defaultColour;
+
+                private const float size = 7;
+
+                [BackgroundDependencyLoader]
+                private void load(OsuColour colours)
+                {
+                    Colour = defaultColour = colours.Gray4;
+                    Anchor = Anchor.TopLeft;
+                    Origin = Anchor.TopCentre;
+
+                    Width = size;
+                    RelativeSizeAxes = Axes.Y;
+                    RelativePositionAxes = Axes.X;
+
+                    InternalChildren = new Drawable[]
+                    {
+                        new Box
+                        {
+                            Width = 2,
+                            RelativeSizeAxes = Axes.Y,
+                            Origin = Anchor.BottomCentre,
+                            Anchor = Anchor.BottomCentre,
+                            Colour = ColourInfo.GradientVertical(Color4.White.Opacity(0.2f), Color4.White),
+                            Blending = BlendingMode.Additive,
+                        },
+                        new EquilateralTriangle
+                        {
+                            Origin = Anchor.BottomCentre,
+                            Anchor = Anchor.BottomCentre,
+                            Height = size,
+                            EdgeSmoothness = new Vector2(1),
+                            Colour = Color4.White,
+                        }
+                    };
+                }
+
+                private bool active;
+
+                public bool Active
+                {
+                    get => active;
+                    set
+                    {
+                        this.FadeColour(value ? Color4.White : defaultColour, 500, Easing.OutQuint);
+                        active = value;
+                    }
+                }
+
+                public void Flash()
+                {
+                    bool wasActive = active;
+
+                    Active = true;
+
+                    if (wasActive) return;
+
+                    using (BeginDelayedSequence(50))
+                        Active = false;
+                }
+            }
+        }
+    }
+}

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

@@ -0,0 +1,192 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using System.Collections.Generic;
+using System.Linq;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Primitives;
+using osu.Framework.Input.Events;
+using osu.Framework.Input.States;
+using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Edit.Tools;
+using osu.Game.Rulesets.Objects.Drawables;
+using OpenTK;
+
+namespace osu.Game.Screens.Edit.Compose.Components
+{
+    public class BlueprintContainer : CompositeDrawable
+    {
+        private SelectionBlueprintContainer selectionBlueprints;
+        private Container<PlacementBlueprint> placementBlueprintContainer;
+        private SelectionBox selectionBox;
+
+        private IEnumerable<SelectionBlueprint> selections => selectionBlueprints.Children.Where(c => c.IsAlive);
+
+        [Resolved]
+        private HitObjectComposer composer { get; set; }
+
+        public BlueprintContainer()
+        {
+            RelativeSizeAxes = Axes.Both;
+        }
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            selectionBox = composer.CreateSelectionBox();
+            selectionBox.DeselectAll = deselectAll;
+
+            var dragBox = new DragBox(select);
+            dragBox.DragEnd += () => selectionBox.UpdateVisibility();
+
+            InternalChildren = new[]
+            {
+                dragBox,
+                selectionBox,
+                selectionBlueprints = new SelectionBlueprintContainer { RelativeSizeAxes = Axes.Both },
+                placementBlueprintContainer = new Container<PlacementBlueprint> { RelativeSizeAxes = Axes.Both },
+                dragBox.CreateProxy()
+            };
+
+            foreach (var obj in composer.HitObjects)
+                AddBlueprintFor(obj);
+        }
+
+        private HitObjectCompositionTool currentTool;
+
+        /// <summary>
+        /// The current placement tool.
+        /// </summary>
+        public HitObjectCompositionTool CurrentTool
+        {
+            get => currentTool;
+            set
+            {
+                if (currentTool == value)
+                    return;
+                currentTool = value;
+
+                refreshTool();
+            }
+        }
+
+        /// <summary>
+        /// Adds a blueprint for a <see cref="DrawableHitObject"/> which adds movement support.
+        /// </summary>
+        /// <param name="hitObject">The <see cref="DrawableHitObject"/> to create a blueprint for.</param>
+        public void AddBlueprintFor(DrawableHitObject hitObject)
+        {
+            refreshTool();
+
+            var blueprint = composer.CreateBlueprintFor(hitObject);
+            if (blueprint == null)
+                return;
+
+            blueprint.Selected += onBlueprintSelected;
+            blueprint.Deselected += onBlueprintDeselected;
+            blueprint.SelectionRequested += onSelectionRequested;
+            blueprint.DragRequested += onDragRequested;
+
+            selectionBlueprints.Add(blueprint);
+        }
+
+        /// <summary>
+        /// Removes a blueprint for a <see cref="DrawableHitObject"/>.
+        /// </summary>
+        /// <param name="hitObject">The <see cref="DrawableHitObject"/> for which to remove the blueprint.</param>
+        public void RemoveBlueprintFor(DrawableHitObject hitObject)
+        {
+            var blueprint = selectionBlueprints.Single(m => m.HitObject == hitObject);
+            if (blueprint == null)
+                return;
+
+            blueprint.Deselect();
+
+            blueprint.Selected -= onBlueprintSelected;
+            blueprint.Deselected -= onBlueprintDeselected;
+            blueprint.SelectionRequested -= onSelectionRequested;
+            blueprint.DragRequested -= onDragRequested;
+
+            selectionBlueprints.Remove(blueprint);
+        }
+
+        protected override bool OnClick(ClickEvent e)
+        {
+            deselectAll();
+            return true;
+        }
+
+        /// <summary>
+        /// Refreshes the current placement tool.
+        /// </summary>
+        private void refreshTool()
+        {
+            placementBlueprintContainer.Clear();
+
+            var blueprint = CurrentTool?.CreatePlacementBlueprint();
+            if (blueprint != null)
+                placementBlueprintContainer.Child = blueprint;
+        }
+
+
+        /// <summary>
+        /// 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)
+        {
+            foreach (var blueprint in selections.ToList())
+            {
+                if (blueprint.IsPresent && rect.Contains(blueprint.SelectionPoint))
+                    blueprint.Select();
+                else
+                    blueprint.Deselect();
+            }
+        }
+
+        /// <summary>
+        /// Deselects all selected <see cref="SelectionBlueprint"/>s.
+        /// </summary>
+        private void deselectAll() => selections.ToList().ForEach(m => m.Deselect());
+
+        private void onBlueprintSelected(SelectionBlueprint blueprint)
+        {
+            selectionBox.HandleSelected(blueprint);
+            selectionBlueprints.ChangeChildDepth(blueprint, 1);
+        }
+
+        private void onBlueprintDeselected(SelectionBlueprint blueprint)
+        {
+            selectionBox.HandleDeselected(blueprint);
+            selectionBlueprints.ChangeChildDepth(blueprint, 0);
+        }
+
+        private void onSelectionRequested(SelectionBlueprint blueprint, InputState state) => selectionBox.HandleSelectionRequested(blueprint, state);
+
+        private void onDragRequested(SelectionBlueprint blueprint, Vector2 delta, InputState state) => selectionBox.HandleDrag(blueprint, delta, state);
+
+        private class SelectionBlueprintContainer : Container<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.HitObject.HitObject.StartTime.CompareTo(x.HitObject.HitObject.StartTime);
+                return i == 0 ? CompareReverseChildID(x, y) : i;
+            }
+        }
+    }
+}

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

@@ -0,0 +1,91 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using System;
+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 OpenTK.Graphics;
+
+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
+    {
+        private readonly Action<RectangleF> performSelection;
+
+        /// <summary>
+        /// Invoked when the drag selection has finished.
+        /// </summary>
+        public event Action DragEnd;
+
+        private Drawable box;
+
+        /// <summary>
+        /// Creates a new <see cref="DragBox"/>.
+        /// </summary>
+        /// <param name="performSelection">A delegate that performs drag selection.</param>
+        public DragBox(Action<RectangleF> performSelection)
+        {
+            this.performSelection = performSelection;
+
+            RelativeSizeAxes = Axes.Both;
+            AlwaysPresent = true;
+            Alpha = 0;
+        }
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            InternalChild = box = new Container
+            {
+                Masking = true,
+                BorderColour = Color4.White,
+                BorderThickness = SelectionBox.BORDER_RADIUS,
+                Child = new Box
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Alpha = 0.1f
+                }
+            };
+        }
+
+        protected override bool OnDragStart(DragStartEvent e)
+        {
+            this.FadeIn(250, Easing.OutQuint);
+            return true;
+        }
+
+        protected override bool OnDrag(DragEvent e)
+        {
+            var dragPosition = e.ScreenSpaceMousePosition;
+            var dragStartPosition = e.ScreenSpaceMouseDownPosition;
+
+            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 topLeft = ToLocalSpace(dragRectangle.TopLeft);
+            var bottomRight = ToLocalSpace(dragRectangle.BottomRight);
+
+            box.Position = topLeft;
+            box.Size = bottomRight - topLeft;
+
+            performSelection?.Invoke(dragRectangle);
+            return true;
+        }
+
+        protected override bool OnDragEnd(DragEndEvent e)
+        {
+            this.FadeOut(250, Easing.OutQuint);
+            DragEnd?.Invoke();
+            return true;
+        }
+    }
+}

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

@@ -0,0 +1,32 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using OpenTK.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/SelectionBox.cs

@@ -0,0 +1,186 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+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.Framework.Input.States;
+using osu.Game.Graphics;
+using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Edit.Types;
+using OpenTK;
+using OpenTK.Input;
+
+namespace osu.Game.Screens.Edit.Compose.Components
+{
+    /// <summary>
+    /// A box which surrounds <see cref="SelectionBlueprint"/>s and provides interactive handles, context menus etc.
+    /// </summary>
+    public class SelectionBox : CompositeDrawable
+    {
+        public const float BORDER_RADIUS = 2;
+
+        private readonly List<SelectionBlueprint> selectedBlueprints;
+
+        private Drawable outline;
+
+        [Resolved]
+        private IPlacementHandler placementHandler { get; set; }
+
+        public SelectionBox()
+        {
+            selectedBlueprints = new List<SelectionBlueprint>();
+
+            RelativeSizeAxes = Axes.Both;
+            AlwaysPresent = true;
+            Alpha = 0;
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(OsuColour colours)
+        {
+            InternalChild = outline = new Container
+            {
+                Masking = true,
+                BorderThickness = BORDER_RADIUS,
+                BorderColour = colours.Yellow,
+                Child = new Box
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    AlwaysPresent = true,
+                    Alpha = 0
+                }
+            };
+        }
+
+        #region User Input Handling
+
+        public void HandleDrag(SelectionBlueprint m, Vector2 delta, InputState state)
+        {
+            // Todo: Various forms of snapping
+
+            foreach (var blueprint in selectedBlueprints)
+            {
+                switch (blueprint.HitObject.HitObject)
+                {
+                    case IHasEditablePosition editablePosition:
+                        editablePosition.OffsetPosition(delta);
+                        break;
+                }
+            }
+        }
+
+        protected override bool OnKeyDown(KeyDownEvent e)
+        {
+            if (e.Repeat)
+                return base.OnKeyDown(e);
+
+            switch (e.Key)
+            {
+                case Key.Delete:
+                    foreach (var h in selectedBlueprints.ToList())
+                        placementHandler.Delete(h.HitObject.HitObject);
+                    return true;
+            }
+
+            return base.OnKeyDown(e);
+        }
+
+        #endregion
+
+        #region Selection Handling
+
+        /// <summary>
+        /// Bind an action to deselect all selected blueprints.
+        /// </summary>
+        public Action DeselectAll { private get; set; }
+
+        /// <summary>
+        /// Handle a blueprint becoming selected.
+        /// </summary>
+        /// <param name="blueprint">The blueprint.</param>
+        public void HandleSelected(SelectionBlueprint blueprint) => selectedBlueprints.Add(blueprint);
+
+        /// <summary>
+        /// Handle a blueprint becoming deselected.
+        /// </summary>
+        /// <param name="blueprint">The blueprint.</param>
+        public void HandleDeselected(SelectionBlueprint blueprint)
+        {
+            selectedBlueprints.Remove(blueprint);
+
+            // We don't want to update visibility if > 0, since we may be deselecting blueprints during drag-selection
+            if (selectedBlueprints.Count == 0)
+                UpdateVisibility();
+        }
+
+        /// <summary>
+        /// Handle a blueprint requesting selection.
+        /// </summary>
+        /// <param name="blueprint">The blueprint.</param>
+        public void HandleSelectionRequested(SelectionBlueprint blueprint, InputState state)
+        {
+            if (state.Keyboard.ControlPressed)
+            {
+                if (blueprint.IsSelected)
+                    blueprint.Deselect();
+                else
+                    blueprint.Select();
+            }
+            else
+            {
+                if (blueprint.IsSelected)
+                    return;
+
+                DeselectAll?.Invoke();
+                blueprint.Select();
+            }
+
+            UpdateVisibility();
+        }
+
+        #endregion
+
+        /// <summary>
+        /// Updates whether this <see cref="SelectionBox"/> is visible.
+        /// </summary>
+        internal void UpdateVisibility()
+        {
+            if (selectedBlueprints.Count > 0)
+                Show();
+            else
+                Hide();
+        }
+
+        protected override void Update()
+        {
+            base.Update();
+
+            if (selectedBlueprints.Count == 0)
+                return;
+
+            // Move the rectangle to cover the hitobjects
+            var topLeft = new Vector2(float.MaxValue, float.MaxValue);
+            var bottomRight = new Vector2(float.MinValue, float.MinValue);
+
+            bool hasSelection = false;
+
+            foreach (var blueprint in selectedBlueprints)
+            {
+                topLeft = Vector2.ComponentMin(topLeft, ToLocalSpace(blueprint.SelectionQuad.TopLeft));
+                bottomRight = Vector2.ComponentMax(bottomRight, ToLocalSpace(blueprint.SelectionQuad.BottomRight));
+            }
+
+            topLeft -= new Vector2(5);
+            bottomRight += new Vector2(5);
+
+            outline.Size = bottomRight - topLeft;
+            outline.Position = topLeft;
+        }
+    }
+}

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

@@ -0,0 +1,52 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Game.Graphics;
+using OpenTK;
+
+namespace osu.Game.Screens.Edit.Compose.Components.Timeline
+{
+    public class CentreMarker : CompositeDrawable
+    {
+        private const float triangle_width = 20;
+        private const float triangle_height = 10;
+        private const float bar_width = 2;
+
+        public CentreMarker()
+        {
+            RelativeSizeAxes = Axes.Y;
+            Size = new Vector2(20, 1);
+
+            Anchor = Anchor.Centre;
+            Origin = Anchor.Centre;
+
+            InternalChildren = new Drawable[]
+            {
+                new Box
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    RelativeSizeAxes = Axes.Y,
+                    Width = bar_width,
+                },
+                new Triangle
+                {
+                    Anchor = Anchor.TopCentre,
+                    Origin = Anchor.BottomCentre,
+                    Size = new Vector2(triangle_width, triangle_height),
+                    Scale = new Vector2(1, -1)
+                }
+            };
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(OsuColour colours)
+        {
+            Colour = colours.Red;
+        }
+    }
+}

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

@@ -0,0 +1,166 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Framework.Allocation;
+using osu.Framework.Audio.Track;
+using osu.Framework.Configuration;
+using osu.Framework.Extensions.Color4Extensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Audio;
+using osu.Framework.Input.Events;
+using osu.Framework.Timing;
+using osu.Game.Beatmaps;
+using osu.Game.Graphics;
+
+namespace osu.Game.Screens.Edit.Compose.Components.Timeline
+{
+    public class Timeline : ZoomableScrollContainer
+    {
+        public readonly Bindable<bool> WaveformVisible = new Bindable<bool>();
+        public readonly IBindable<WorkingBeatmap> Beatmap = new Bindable<WorkingBeatmap>();
+
+        private IAdjustableClock adjustableClock;
+
+        public Timeline()
+        {
+            ZoomDuration = 200;
+            ZoomEasing = Easing.OutQuint;
+            Zoom = 10;
+            ScrollbarVisible = false;
+        }
+
+        private WaveformGraph waveform;
+
+        [BackgroundDependencyLoader]
+        private void load(IBindableBeatmap beatmap, IAdjustableClock adjustableClock, OsuColour colours)
+        {
+            this.adjustableClock = adjustableClock;
+
+            Child = 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());
+
+            WaveformVisible.ValueChanged += visible => waveform.FadeTo(visible ? 1 : 0, 200, Easing.OutQuint);
+
+            Beatmap.BindTo(beatmap);
+            Beatmap.BindValueChanged(b =>
+            {
+                waveform.Waveform = b.Waveform;
+                track = b.Track;
+            }, true);
+        }
+
+        /// <summary>
+        /// The timeline's scroll position in the last frame.
+        /// </summary>
+        private float lastScrollPosition;
+
+        /// <summary>
+        /// The track time in the last frame.
+        /// </summary>
+        private double lastTrackTime;
+
+        /// <summary>
+        /// Whether the user is currently dragging the timeline.
+        /// </summary>
+        private bool handlingDragInput;
+
+        /// <summary>
+        /// Whether the track was playing before a user drag event.
+        /// </summary>
+        private bool trackWasPlaying;
+
+        private Track track;
+
+        protected override void Update()
+        {
+            base.Update();
+
+            // The extrema of track time should be positioned at the centre of the container when scrolled to the start or end
+            Content.Margin = new MarginPadding { Horizontal = DrawWidth / 2 };
+
+            // This needs to happen after transforms are updated, but before the scroll position is updated in base.UpdateAfterChildren
+            if (adjustableClock.IsRunning)
+                scrollToTrackTime();
+        }
+
+        protected override void UpdateAfterChildren()
+        {
+            base.UpdateAfterChildren();
+
+            if (handlingDragInput)
+                seekTrackToCurrent();
+            else if (!adjustableClock.IsRunning)
+            {
+                // The track isn't running. There are two cases we have to be wary of:
+                // 1) The user flick-drags on this timeline: We want the track to follow us
+                // 2) The user changes the track time through some other means (scrolling in the editor or overview timeline): We want to follow the track time
+
+                // The simplest way to cover both cases is by checking whether the scroll position has changed and the audio hasn't been changed externally
+                if (Current != lastScrollPosition && adjustableClock.CurrentTime == lastTrackTime)
+                    seekTrackToCurrent();
+                else
+                    scrollToTrackTime();
+            }
+
+            lastScrollPosition = Current;
+            lastTrackTime = adjustableClock.CurrentTime;
+        }
+
+        private void seekTrackToCurrent()
+        {
+            if (!track.IsLoaded)
+                return;
+
+            adjustableClock.Seek(Current / Content.DrawWidth * track.Length);
+        }
+
+        private void scrollToTrackTime()
+        {
+            if (!track.IsLoaded)
+                return;
+
+            ScrollTo((float)(adjustableClock.CurrentTime / track.Length) * Content.DrawWidth, false);
+        }
+
+        protected override bool OnMouseDown(MouseDownEvent e)
+        {
+            if (base.OnMouseDown(e))
+            {
+                beginUserDrag();
+                return true;
+            }
+
+            return false;
+        }
+
+        protected override bool OnMouseUp(MouseUpEvent e)
+        {
+            endUserDrag();
+            return base.OnMouseUp(e);
+        }
+
+        private void beginUserDrag()
+        {
+            handlingDragInput = true;
+            trackWasPlaying = adjustableClock.IsRunning;
+            adjustableClock.Stop();
+        }
+
+        private void endUserDrag()
+        {
+            handlingDragInput = false;
+            if (trackWasPlaying)
+                adjustableClock.Start();
+        }
+    }
+}

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

@@ -0,0 +1,128 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Game.Graphics;
+using osu.Game.Graphics.UserInterface;
+using OpenTK;
+
+namespace osu.Game.Screens.Edit.Compose.Components.Timeline
+{
+    public class TimelineArea : CompositeDrawable
+    {
+        private readonly Timeline timeline;
+
+        public TimelineArea()
+        {
+            Masking = true;
+            CornerRadius = 5;
+
+            OsuCheckbox hitObjectsCheckbox;
+            OsuCheckbox hitSoundsCheckbox;
+            OsuCheckbox waveformCheckbox;
+
+            InternalChildren = new Drawable[]
+            {
+                new Box
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Colour = OsuColour.FromHex("111")
+                },
+                new GridContainer
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Content = new[]
+                    {
+                        new Drawable[]
+                        {
+                            new Container
+                            {
+                                RelativeSizeAxes = Axes.Y,
+                                AutoSizeAxes = Axes.X,
+                                Children = new Drawable[]
+                                {
+                                    new Box
+                                    {
+                                        RelativeSizeAxes = Axes.Both,
+                                        Colour = OsuColour.FromHex("222")
+                                    },
+                                    new FillFlowContainer
+                                    {
+                                        Anchor = Anchor.CentreLeft,
+                                        Origin = Anchor.CentreLeft,
+                                        AutoSizeAxes = Axes.Y,
+                                        Width = 160,
+                                        Padding = new MarginPadding { Horizontal = 15 },
+                                        Direction = FillDirection.Vertical,
+                                        Spacing = new Vector2(0, 4),
+                                        Children = new[]
+                                        {
+                                            hitObjectsCheckbox = new OsuCheckbox { LabelText = "Hit objects" },
+                                            hitSoundsCheckbox = new OsuCheckbox { LabelText = "Hit sounds" },
+                                            waveformCheckbox = new OsuCheckbox { LabelText = "Waveform" }
+                                        }
+                                    }
+                                }
+                            },
+                            new Container
+                            {
+                                RelativeSizeAxes = Axes.Y,
+                                AutoSizeAxes = Axes.X,
+                                Children = new Drawable[]
+                                {
+                                    new Box
+                                    {
+                                        RelativeSizeAxes = Axes.Both,
+                                        Colour = OsuColour.FromHex("333")
+                                    },
+                                    new Container<TimelineButton>
+                                    {
+                                        Anchor = Anchor.CentreLeft,
+                                        Origin = Anchor.CentreLeft,
+                                        RelativeSizeAxes = Axes.Y,
+                                        AutoSizeAxes = Axes.X,
+                                        Masking = true,
+                                        Children = new[]
+                                        {
+                                            new TimelineButton
+                                            {
+                                                RelativeSizeAxes = Axes.Y,
+                                                Height = 0.5f,
+                                                Icon = FontAwesome.fa_search_plus,
+                                                Action = () => timeline.Zoom++
+                                            },
+                                            new TimelineButton
+                                            {
+                                                Anchor = Anchor.BottomLeft,
+                                                Origin = Anchor.BottomLeft,
+                                                RelativeSizeAxes = Axes.Y,
+                                                Height = 0.5f,
+                                                Icon = FontAwesome.fa_search_minus,
+                                                Action = () => timeline.Zoom--
+                                            },
+                                        }
+                                    }
+                                }
+                            },
+                            timeline = new Timeline { RelativeSizeAxes = Axes.Both }
+                        },
+                    },
+                    ColumnDimensions = new[]
+                    {
+                        new Dimension(GridSizeMode.AutoSize),
+                        new Dimension(GridSizeMode.AutoSize),
+                        new Dimension(GridSizeMode.Distributed),
+                    }
+                }
+            };
+
+            hitObjectsCheckbox.Current.Value = true;
+            hitSoundsCheckbox.Current.Value = true;
+            waveformCheckbox.Current.Value = true;
+
+            timeline.WaveformVisible.BindTo(waveformCheckbox.Current);
+        }
+    }
+}

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

@@ -0,0 +1,56 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using System;
+using osu.Framework.Configuration;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Game.Graphics;
+using osu.Game.Graphics.UserInterface;
+using OpenTK;
+using OpenTK.Graphics;
+
+namespace osu.Game.Screens.Edit.Compose.Components.Timeline
+{
+    public class TimelineButton : CompositeDrawable
+    {
+        public Action Action;
+        public readonly BindableBool Enabled = new BindableBool(true);
+
+        public FontAwesome Icon
+        {
+            get { return button.Icon; }
+            set { button.Icon = value; }
+        }
+
+        private readonly IconButton button;
+
+        public TimelineButton()
+        {
+            InternalChild = button = new TimelineIconButton { Action = () => Action?.Invoke() };
+
+            button.Enabled.BindTo(Enabled);
+            Width = button.ButtonSize.X;
+        }
+
+        protected override void Update()
+        {
+            base.Update();
+
+            button.ButtonSize = new Vector2(button.ButtonSize.X, DrawHeight);
+        }
+
+        private class TimelineIconButton : IconButton
+        {
+            public TimelineIconButton()
+            {
+                Anchor = Anchor.Centre;
+                Origin = Anchor.Centre;
+                IconColour = OsuColour.Gray(0.35f);
+                IconHoverColour = Color4.White;
+                HoverColour = OsuColour.Gray(0.25f);
+                FlashColour = OsuColour.Gray(0.5f);
+            }
+        }
+    }
+}

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

@@ -0,0 +1,175 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using System;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Transforms;
+using osu.Framework.Input.Events;
+using osu.Framework.MathUtils;
+using OpenTK;
+
+namespace osu.Game.Screens.Edit.Compose.Components.Timeline
+{
+    public class ZoomableScrollContainer : ScrollContainer
+    {
+        /// <summary>
+        /// The time to zoom into/out of a point.
+        /// All user scroll input will be overwritten during the zoom transform.
+        /// </summary>
+        public double ZoomDuration;
+
+        /// <summary>
+        /// The easing with which to transform the zoom.
+        /// </summary>
+        public Easing ZoomEasing;
+
+        private readonly Container zoomedContent;
+        protected override Container<Drawable> Content => zoomedContent;
+
+        private float currentZoom = 1;
+
+        public ZoomableScrollContainer()
+            : base(Direction.Horizontal)
+        {
+            base.Content.Add(zoomedContent = new Container { RelativeSizeAxes = Axes.Y });
+        }
+
+        private int minZoom = 1;
+
+        /// <summary>
+        /// The minimum zoom level allowed.
+        /// </summary>
+        public int MinZoom
+        {
+            get => minZoom;
+            set
+            {
+                if (value < 1)
+                    throw new ArgumentException($"{nameof(MinZoom)} must be >= 1.", nameof(value));
+                minZoom = value;
+
+                if (Zoom < value)
+                    Zoom = value;
+            }
+        }
+
+        private int maxZoom = 60;
+
+        /// <summary>
+        /// The maximum zoom level allowed.
+        /// </summary>
+        public int MaxZoom
+        {
+            get => maxZoom;
+            set
+            {
+                if (value < 1)
+                    throw new ArgumentException($"{nameof(MaxZoom)} must be >= 1.", nameof(value));
+                maxZoom = value;
+
+                if (Zoom > value)
+                    Zoom = value;
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets the content zoom level of this <see cref="ZoomableScrollContainer"/>.
+        /// </summary>
+        public float Zoom
+        {
+            get => zoomTarget;
+            set
+            {
+                value = MathHelper.Clamp(value, MinZoom, MaxZoom);
+
+                if (IsLoaded)
+                    setZoomTarget(value, ToSpaceOfOtherDrawable(new Vector2(DrawWidth / 2, 0), zoomedContent).X);
+                else
+                    currentZoom = zoomTarget = value;
+            }
+        }
+
+        protected override void Update()
+        {
+            base.Update();
+
+            zoomedContent.Width = DrawWidth * currentZoom;
+        }
+
+        protected override bool OnScroll(ScrollEvent e)
+        {
+            if (e.IsPrecise)
+                // for now, we don't support zoom when using a precision scroll device. this needs gesture support.
+                return base.OnScroll(e);
+
+            setZoomTarget(zoomTarget + e.ScrollDelta.Y, zoomedContent.ToLocalSpace(e.ScreenSpaceMousePosition).X);
+            return true;
+        }
+
+        private float zoomTarget = 1;
+        private void setZoomTarget(float newZoom, float focusPoint)
+        {
+            zoomTarget = MathHelper.Clamp(newZoom, MinZoom, MaxZoom);
+            transformZoomTo(zoomTarget, focusPoint, ZoomDuration, ZoomEasing);
+        }
+
+        private void transformZoomTo(float newZoom, float focusPoint, double duration = 0, Easing easing = Easing.None)
+            => this.TransformTo(this.PopulateTransform(new TransformZoom(focusPoint, zoomedContent.DrawWidth, Current), newZoom, duration, easing));
+
+        private class TransformZoom : Transform<float, ZoomableScrollContainer>
+        {
+            /// <summary>
+            /// The focus point in absolute coordinates local to the content.
+            /// </summary>
+            private readonly float focusPoint;
+
+            /// <summary>
+            /// The size of the content.
+            /// </summary>
+            private readonly float contentSize;
+
+            /// <summary>
+            /// The scroll offset at the start of the transform.
+            /// </summary>
+            private readonly float scrollOffset;
+
+            /// <summary>
+            /// Transforms <see cref="TimeTimelinem"/> to a new value.
+            /// </summary>
+            /// <param name="focusPoint">The focus point in absolute coordinates local to the content.</param>
+            /// <param name="contentSize">The size of the content.</param>
+            /// <param name="scrollOffset">The scroll offset at the start of the transform.</param>
+            public TransformZoom(float focusPoint, float contentSize, float scrollOffset)
+            {
+                this.focusPoint = focusPoint;
+                this.contentSize = contentSize;
+                this.scrollOffset = scrollOffset;
+            }
+
+            public override string TargetMember => nameof(currentZoom);
+
+            private float 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 Apply(ZoomableScrollContainer d, double time)
+            {
+                float newZoom = valueAt(time);
+
+                float focusOffset = focusPoint - scrollOffset;
+                float expectedWidth = d.DrawWidth * newZoom;
+                float targetOffset = expectedWidth * (focusPoint / contentSize) - focusOffset;
+
+                d.currentZoom = newZoom;
+                d.ScrollTo(targetOffset, false);
+            }
+
+            protected override void ReadIntoStartValue(ZoomableScrollContainer d) => StartValue = d.currentZoom;
+        }
+    }
+}

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

@@ -0,0 +1,129 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using JetBrains.Annotations;
+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.Logging;
+using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Screens.Edit.Compose.Components;
+using osu.Game.Screens.Edit.Compose.Components.Timeline;
+using OpenTK.Graphics;
+
+namespace osu.Game.Screens.Edit.Compose
+{
+    [Cached(Type = typeof(IPlacementHandler))]
+    public class Compose : EditorScreen, IPlacementHandler
+    {
+        private const float vertical_margins = 10;
+        private const float horizontal_margins = 20;
+
+        private readonly BindableBeatDivisor beatDivisor = new BindableBeatDivisor();
+
+        private HitObjectComposer composer;
+
+        [BackgroundDependencyLoader(true)]
+        private void load([CanBeNull] BindableBeatDivisor beatDivisor)
+        {
+            if (beatDivisor != null)
+                this.beatDivisor.BindTo(beatDivisor);
+
+            Container composerContainer;
+
+            Children = new Drawable[]
+            {
+                new GridContainer
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Content = new[]
+                    {
+                        new Drawable[]
+                        {
+                            new Container
+                            {
+                                Name = "Timeline",
+                                RelativeSizeAxes = Axes.Both,
+                                Children = new Drawable[]
+                                {
+                                    new Box
+                                    {
+                                        RelativeSizeAxes = Axes.Both,
+                                        Colour = Color4.Black.Opacity(0.5f)
+                                    },
+                                    new Container
+                                    {
+                                        Name = "Timeline content",
+                                        RelativeSizeAxes = Axes.Both,
+                                        Padding = new MarginPadding { Horizontal = horizontal_margins, Vertical = vertical_margins },
+                                        Child = new GridContainer
+                                        {
+                                            RelativeSizeAxes = Axes.Both,
+                                            Content = new[]
+                                            {
+                                                new Drawable[]
+                                                {
+                                                    new Container
+                                                    {
+                                                        RelativeSizeAxes = Axes.Both,
+                                                        Padding = new MarginPadding { Right = 5 },
+                                                        Child = new TimelineArea { RelativeSizeAxes = Axes.Both }
+                                                    },
+                                                    new BeatDivisorControl(beatDivisor) { RelativeSizeAxes = Axes.Both }
+                                                },
+                                            },
+                                            ColumnDimensions = new[]
+                                            {
+                                                new Dimension(),
+                                                new Dimension(GridSizeMode.Absolute, 90),
+                                            }
+                                        },
+                                    }
+                                }
+                            }
+                        },
+                        new Drawable[]
+                        {
+                            composerContainer = new Container
+                            {
+                                Name = "Composer content",
+                                RelativeSizeAxes = Axes.Both,
+                                Padding = new MarginPadding { Horizontal = horizontal_margins, Vertical = vertical_margins },
+                            }
+                        }
+                    },
+                    RowDimensions = new[] { new Dimension(GridSizeMode.Absolute, 110) }
+                },
+            };
+
+            var ruleset = Beatmap.Value.BeatmapInfo.Ruleset?.CreateInstance();
+            if (ruleset == null)
+            {
+                Logger.Log("Beatmap doesn't have a ruleset assigned.");
+                // ExitRequested?.Invoke();
+                return;
+            }
+
+            composer = ruleset.CreateHitObjectComposer();
+            if (composer == null)
+            {
+                Logger.Log($"Ruleset {ruleset.Description} doesn't support hitobject composition.");
+                // ExitRequested?.Invoke();
+                return;
+            }
+
+            composerContainer.Child = composer;
+        }
+
+        public void BeginPlacement(HitObject hitObject)
+        {
+        }
+
+        public void EndPlacement(HitObject hitObject) => composer.Add(hitObject);
+
+        public void Delete(HitObject hitObject) => composer.Remove(hitObject);
+    }
+}

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

@@ -0,0 +1,28 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Game.Rulesets.Objects;
+
+namespace osu.Game.Screens.Edit.Compose
+{
+    public interface IPlacementHandler
+    {
+        /// <summary>
+        /// Notifies that a placement has begun.
+        /// </summary>
+        /// <param name="hitObject">The <see cref="HitObject"/> being placed.</param>
+        void BeginPlacement(HitObject hitObject);
+
+        /// <summary>
+        /// Notifies that a placement has finished.
+        /// </summary>
+        /// <param name="hitObject">The <see cref="HitObject"/> that has been placed.</param>
+        void EndPlacement(HitObject hitObject);
+
+        /// <summary>
+        /// Deletes a <see cref="HitObject"/>.
+        /// </summary>
+        /// <param name="hitObject">The <see cref="HitObject"/> to delete.</param>
+        void Delete(HitObject hitObject);
+    }
+}