Merge master into editor-clock

osu.Game/Rulesets/Edit/HitObjectComposer.cs

@@ -53,9 +53,6 @@ namespace osu.Game.Rulesets.Edit
                 return;
             }
 
-            HitObjectMaskLayer hitObjectMaskLayer = new HitObjectMaskLayer(this);
-            SelectionLayer selectionLayer = new SelectionLayer(rulesetContainer.Playfield);
-
             var layerBelowRuleset = new BorderLayer
             {
                 RelativeSizeAxes = Axes.Both,
@@ -63,12 +60,7 @@ namespace osu.Game.Rulesets.Edit
             };
 
             var layerAboveRuleset = CreateLayerContainer();
-            layerAboveRuleset.Children = new Drawable[]
-            {
-                selectionLayer, // Below object overlays for input
-                hitObjectMaskLayer,
-                selectionLayer.CreateProxy() // Proxy above object overlays for selections
-            };
+            layerAboveRuleset.Child = new HitObjectMaskLayer(rulesetContainer.Playfield, this);
 
             layerContainers.Add(layerBelowRuleset);
             layerContainers.Add(layerAboveRuleset);
@@ -110,11 +102,6 @@ namespace osu.Game.Rulesets.Edit
                 }
             };
 
-            selectionLayer.ObjectSelected += hitObjectMaskLayer.AddOverlay;
-            selectionLayer.ObjectDeselected += hitObjectMaskLayer.RemoveOverlay;
-            selectionLayer.SelectionCleared += hitObjectMaskLayer.RemoveSelectionOverlay;
-            selectionLayer.SelectionFinished += hitObjectMaskLayer.AddSelectionOverlay;
-
             toolboxCollection.Items =
                 CompositionTools.Select(t => new RadioButton(t.Name, () => setCompositionTool(t)))
                 .Prepend(new RadioButton("Select", () => setCompositionTool(null)))
@@ -149,11 +136,10 @@ namespace osu.Game.Rulesets.Edit
         public virtual HitObjectMask CreateMaskFor(DrawableHitObject hitObject) => null;
 
         /// <summary>
-        /// Creates a <see cref="SelectionBox"/> which outlines <see cref="DrawableHitObject"/>s
-        /// and handles all hitobject movement/pattern adjustments.
+        /// Creates a <see cref="MaskSelection"/> which outlines <see cref="DrawableHitObject"/>s
+        /// and handles hitobject pattern adjustments.
         /// </summary>
-        /// <param name="overlays">The <see cref="DrawableHitObject"/> overlays.</param>
-        public virtual SelectionBox CreateSelectionOverlay(IReadOnlyList<HitObjectMask> overlays) => new SelectionBox(overlays);
+        public virtual MaskSelection CreateMaskSelection() => new MaskSelection();
 
         /// <summary>
         /// Creates a <see cref="ScalableContainer"/> which provides a layer above or below the <see cref="Playfield"/>.

osu.Game/Rulesets/Edit/HitObjectMask.cs

@@ -1,21 +1,146 @@
 // 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;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Primitives;
+using osu.Framework.Input;
 using osu.Game.Rulesets.Objects.Drawables;
+using OpenTK;
 
 namespace osu.Game.Rulesets.Edit
 {
     /// <summary>
     /// A mask placed above a <see cref="DrawableHitObject"/> adding editing functionality.
     /// </summary>
-    public class HitObjectMask : Container
+    public class HitObjectMask : CompositeDrawable, IStateful<SelectionState>
     {
+        /// <summary>
+        /// Invoked when this <see cref="HitObjectMask"/> has been selected.
+        /// </summary>
+        public event Action<HitObjectMask> Selected;
+
+        /// <summary>
+        /// Invoked when this <see cref="HitObjectMask"/> has been deselected.
+        /// </summary>
+        public event Action<HitObjectMask> Deselected;
+
+        /// <summary>
+        /// Invoked when this <see cref="HitObjectMask"/> has requested selection.
+        /// Will fire even if already selected. Does not actually perform selection.
+        /// </summary>
+        public event Action<HitObjectMask, InputState> SelectionRequested;
+
+        /// <summary>
+        /// Invoked when this <see cref="HitObjectMask"/> has requested drag.
+        /// </summary>
+        public event Action<HitObjectMask, InputState> DragRequested;
+
+        /// <summary>
+        /// The <see cref="DrawableHitObject"/> which this <see cref="HitObjectMask"/> applies to.
+        /// </summary>
         public readonly DrawableHitObject HitObject;
 
+        protected override bool ShouldBeAlive => HitObject.IsAlive && HitObject.IsPresent || State == SelectionState.Selected;
+        public override bool HandleMouseInput => ShouldBeAlive;
+        public override bool RemoveWhenNotAlive => false;
+
         public HitObjectMask(DrawableHitObject hitObject)
         {
             HitObject = hitObject;
+
+            AlwaysPresent = true;
+            Alpha = 0;
         }
+
+        private SelectionState state;
+
+        public event Action<SelectionState> StateChanged;
+
+        public SelectionState State
+        {
+            get => state;
+            set
+            {
+                if (state == value) return;
+
+                state = value;
+                switch (state)
+                {
+                    case SelectionState.Selected:
+                        Show();
+                        Selected?.Invoke(this);
+                        break;
+                    case SelectionState.NotSelected:
+                        Hide();
+                        Deselected?.Invoke(this);
+                        break;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Selects this <see cref="HitObjectMask"/>, causing it to become visible.
+        /// </summary>
+        public void Select() => State = SelectionState.Selected;
+
+        /// <summary>
+        /// Deselects this <see cref="HitObjectMask"/>, causing it to become invisible.
+        /// </summary>
+        public void Deselect() => State = SelectionState.NotSelected;
+
+        public bool IsSelected => State == SelectionState.Selected;
+
+        private bool selectionRequested;
+
+        protected override bool OnMouseDown(InputState state, MouseDownEventArgs args)
+        {
+            selectionRequested = false;
+
+            if (State == SelectionState.NotSelected)
+            {
+                SelectionRequested?.Invoke(this, state);
+                selectionRequested = true;
+            }
+
+            return IsSelected;
+        }
+
+        protected override bool OnClick(InputState state)
+        {
+            if (State == SelectionState.Selected && !selectionRequested)
+            {
+                selectionRequested = true;
+                SelectionRequested?.Invoke(this, state);
+                return true;
+            }
+
+            return base.OnClick(state);
+        }
+
+        protected override bool OnDragStart(InputState state) => true;
+
+        protected override bool OnDrag(InputState state)
+        {
+            DragRequested?.Invoke(this, state);
+            return true;
+        }
+
+        /// <summary>
+        /// The screen-space point that causes this <see cref="HitObjectMask"/> to be selected.
+        /// </summary>
+        public virtual Vector2 SelectionPoint => ScreenSpaceDrawQuad.Centre;
+
+        /// <summary>
+        /// The screen-space quad that outlines this <see cref="HitObjectMask"/> for selections.
+        /// </summary>
+        public virtual Quad SelectionQuad => ScreenSpaceDrawQuad;
+    }
+
+    public enum SelectionState
+    {
+        NotSelected,
+        Selected
     }
 }