osu-lazer/osu.Game/Rulesets/Edit/HitObjectMask.cs

// 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.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 : VisibilityContainer
    {
        /// <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> SelectionRequested;

        /// <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 == Visibility.Visible;
        public override bool HandleMouseInput => ShouldBeAlive;
        public override bool RemoveWhenNotAlive => false;

        public HitObjectMask(DrawableHitObject hitObject)
        {
            HitObject = hitObject;

            AlwaysPresent = true;
            State = Visibility.Hidden;
        }

        /// <summary>
        /// Selects this <see cref="HitObjectMask"/>, causing it to become visible.
        /// </summary>
        /// <returns>True if the <see cref="HitObjectMask"/> was selected. False if the <see cref="HitObjectMask"/> was already selected.</returns>
        public bool Select()
        {
            if (State == Visibility.Visible)
                return false;

            Show();
            Selected?.Invoke(this);
            return true;
        }

        protected override bool OnMouseDown(InputState state, MouseDownEventArgs args)
        {
            SelectionRequested?.Invoke(this);
            return base.OnMouseDown(state, args);
        }

        /// <summary>
        /// Deselects this <see cref="HitObjectMask"/>, causing it to become invisible.
        /// </summary>
        /// <returns>True if the <see cref="HitObjectMask"/> was deselected. False if the <see cref="HitObjectMask"/> was already deselected.</returns>
        public bool Deselect()
        {
            if (State == Visibility.Hidden)
                return false;

            Hide();
            Deselected?.Invoke(this);
            return true;
        }

        protected override void PopIn() => Alpha = 1;
        protected override void PopOut() => Alpha = 0;

        /// <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;
    }
}
-												Add hitobject overlays to selected hitobjects


											
										
										
											2018-02-20 17:01:45 +08:00
+								// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
 								// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
-												Rewrite the way drag + click selections happen

The general idea here is that we need the masks to handle mouse down events, as they need to handle the drag (mousedown -> drag immediately).

I've rewritten the editor selections to use events, as there are some 3 different components that handle/trigger selections in different ways.

1. All selections/deselections now propagate through `HitObjectMask.Select()`/`HitObjectMask.Deselect()`.
2. Components that react to changes in the selection bind to the masks' `Selected`/`Deselected` events, and track them/change their states locally.
3. Masks provide a `SingleSelectionRequested` event which is invoked on the mouse-down event. Various components bind to this event to perform state changes locally in this scenario.
4. `DragBox` now handles all drag input locally. It triggers `Select`/`Deselect` on the masks it needs to.
5. `SelectionBox` handles the display of itself locally.
6. `SelectionBox` handles movement of groups of masks locally.
7. `HitObjectMasks` handles movement of itself locally.

											
										
										
											2018-03-29 21:06:45 +08:00
+								using System;
-												Add hitobject overlays to selected hitobjects


											
										
										
											2018-02-20 17:01:45 +08:00
+								using osu.Framework.Graphics.Containers;
-												Rewrite the way drag + click selections happen

The general idea here is that we need the masks to handle mouse down events, as they need to handle the drag (mousedown -> drag immediately).

I've rewritten the editor selections to use events, as there are some 3 different components that handle/trigger selections in different ways.

1. All selections/deselections now propagate through `HitObjectMask.Select()`/`HitObjectMask.Deselect()`.
2. Components that react to changes in the selection bind to the masks' `Selected`/`Deselected` events, and track them/change their states locally.
3. Masks provide a `SingleSelectionRequested` event which is invoked on the mouse-down event. Various components bind to this event to perform state changes locally in this scenario.
4. `DragBox` now handles all drag input locally. It triggers `Select`/`Deselect` on the masks it needs to.
5. `SelectionBox` handles the display of itself locally.
6. `SelectionBox` handles movement of groups of masks locally.
7. `HitObjectMasks` handles movement of itself locally.

											
										
										
											2018-03-29 21:06:45 +08:00
+								using osu.Framework.Graphics.Primitives;
-												Move individual mask selection logic out of MaskSelection


											
										
										
											2018-04-04 17:21:27 +08:00
+								using osu.Framework.Input;
-												Add hitobject overlays to selected hitobjects


											
										
										
											2018-02-20 17:01:45 +08:00
+								using osu.Game.Rulesets.Objects.Drawables;
-												Rewrite the way drag + click selections happen

The general idea here is that we need the masks to handle mouse down events, as they need to handle the drag (mousedown -> drag immediately).

I've rewritten the editor selections to use events, as there are some 3 different components that handle/trigger selections in different ways.

1. All selections/deselections now propagate through `HitObjectMask.Select()`/`HitObjectMask.Deselect()`.
2. Components that react to changes in the selection bind to the masks' `Selected`/`Deselected` events, and track them/change their states locally.
3. Masks provide a `SingleSelectionRequested` event which is invoked on the mouse-down event. Various components bind to this event to perform state changes locally in this scenario.
4. `DragBox` now handles all drag input locally. It triggers `Select`/`Deselect` on the masks it needs to.
5. `SelectionBox` handles the display of itself locally.
6. `SelectionBox` handles movement of groups of masks locally.
7. `HitObjectMasks` handles movement of itself locally.

											
										
										
											2018-03-29 21:06:45 +08:00
+								using OpenTK;
-												Add hitobject overlays to selected hitobjects


											
										
										
											2018-02-20 17:01:45 +08:00
-												Rework a lot of naming and structure


											
										
										
											2018-03-14 14:18:21 +08:00
+								namespace osu.Game.Rulesets.Edit
-												Add hitobject overlays to selected hitobjects


											
										
										
											2018-02-20 17:01:45 +08:00
+								{
-												Rework a lot of naming and structure


											
										
										
											2018-03-14 14:18:21 +08:00
+								    /// <summary>
 								    /// A mask placed above a <see cref="DrawableHitObject"/> adding editing functionality.
 								    /// </summary>
-												Make HitObjectMasks VisibilityContainers


											
										
										
											2018-03-29 16:19:24 +08:00
+								    public class HitObjectMask : VisibilityContainer
-												Add hitobject overlays to selected hitobjects


											
										
										
											2018-02-20 17:01:45 +08:00
+								    {
-												Commenting  + cleanup of HitObjectMask/HitObjectMaskLayer


											
										
										
											2018-03-29 21:27:14 +08:00
+								        /// <summary>
 								        /// Invoked when this <see cref="HitObjectMask"/> has been selected.
 								        /// </summary>
-												Rewrite the way drag + click selections happen

The general idea here is that we need the masks to handle mouse down events, as they need to handle the drag (mousedown -> drag immediately).

I've rewritten the editor selections to use events, as there are some 3 different components that handle/trigger selections in different ways.

1. All selections/deselections now propagate through `HitObjectMask.Select()`/`HitObjectMask.Deselect()`.
2. Components that react to changes in the selection bind to the masks' `Selected`/`Deselected` events, and track them/change their states locally.
3. Masks provide a `SingleSelectionRequested` event which is invoked on the mouse-down event. Various components bind to this event to perform state changes locally in this scenario.
4. `DragBox` now handles all drag input locally. It triggers `Select`/`Deselect` on the masks it needs to.
5. `SelectionBox` handles the display of itself locally.
6. `SelectionBox` handles movement of groups of masks locally.
7. `HitObjectMasks` handles movement of itself locally.

											
										
										
											2018-03-29 21:06:45 +08:00
+								        public event Action<HitObjectMask> Selected;
-												Commenting  + cleanup of HitObjectMask/HitObjectMaskLayer


											
										
										
											2018-03-29 21:27:14 +08:00
 								        /// <summary>
 								        /// Invoked when this <see cref="HitObjectMask"/> has been deselected.
 								        /// </summary>
-												Rewrite the way drag + click selections happen

The general idea here is that we need the masks to handle mouse down events, as they need to handle the drag (mousedown -> drag immediately).

I've rewritten the editor selections to use events, as there are some 3 different components that handle/trigger selections in different ways.

1. All selections/deselections now propagate through `HitObjectMask.Select()`/`HitObjectMask.Deselect()`.
2. Components that react to changes in the selection bind to the masks' `Selected`/`Deselected` events, and track them/change their states locally.
3. Masks provide a `SingleSelectionRequested` event which is invoked on the mouse-down event. Various components bind to this event to perform state changes locally in this scenario.
4. `DragBox` now handles all drag input locally. It triggers `Select`/`Deselect` on the masks it needs to.
5. `SelectionBox` handles the display of itself locally.
6. `SelectionBox` handles movement of groups of masks locally.
7. `HitObjectMasks` handles movement of itself locally.

											
										
										
											2018-03-29 21:06:45 +08:00
+								        public event Action<HitObjectMask> Deselected;
-												Commenting  + cleanup of HitObjectMask/HitObjectMaskLayer


											
										
										
											2018-03-29 21:27:14 +08:00
-												Move individual mask selection logic out of MaskSelection


											
										
										
											2018-04-04 17:21:27 +08:00
+								        /// <summary>
-												Formatting fixes


											
										
										
											2018-04-04 19:02:38 +08:00
+								        /// Invoked when this <see cref="HitObjectMask"/> has requested selection.
 								        /// Will fire even if already selected. Does not actually perform selection.
-												Move individual mask selection logic out of MaskSelection


											
										
										
											2018-04-04 17:21:27 +08:00
+								        /// </summary>
 								        public event Action<HitObjectMask> SelectionRequested;
-												Commenting  + cleanup of HitObjectMask/HitObjectMaskLayer


											
										
										
											2018-03-29 21:27:14 +08:00
+								        /// <summary>
 								        /// The <see cref="DrawableHitObject"/> which this <see cref="HitObjectMask"/> applies to.
 								        /// </summary>
-												Allow dragging anywhere in a capture box to move objects


											
										
										
											2018-03-09 22:43:50 +08:00
+								        public readonly DrawableHitObject HitObject;
-												Add hitobject overlays to selected hitobjects


											
										
										
											2018-02-20 17:01:45 +08:00
-												Fix ShouldBeAlive state


											
										
										
											2018-04-04 18:51:56 +08:00
+								        protected override bool ShouldBeAlive => HitObject.IsAlive && HitObject.IsPresent || State == Visibility.Visible;
-												Move individual mask selection logic out of MaskSelection


											
										
										
											2018-04-04 17:21:27 +08:00
+								        public override bool HandleMouseInput => ShouldBeAlive;
-												Fix ShouldBeAlive state


											
										
										
											2018-04-04 18:51:56 +08:00
+								        public override bool RemoveWhenNotAlive => false;
-												Rewrite the way drag + click selections happen

The general idea here is that we need the masks to handle mouse down events, as they need to handle the drag (mousedown -> drag immediately).

I've rewritten the editor selections to use events, as there are some 3 different components that handle/trigger selections in different ways.

1. All selections/deselections now propagate through `HitObjectMask.Select()`/`HitObjectMask.Deselect()`.
2. Components that react to changes in the selection bind to the masks' `Selected`/`Deselected` events, and track them/change their states locally.
3. Masks provide a `SingleSelectionRequested` event which is invoked on the mouse-down event. Various components bind to this event to perform state changes locally in this scenario.
4. `DragBox` now handles all drag input locally. It triggers `Select`/`Deselect` on the masks it needs to.
5. `SelectionBox` handles the display of itself locally.
6. `SelectionBox` handles movement of groups of masks locally.
7. `HitObjectMasks` handles movement of itself locally.

											
										
										
											2018-03-29 21:06:45 +08:00
-												Rework a lot of naming and structure


											
										
										
											2018-03-14 14:18:21 +08:00
+								        public HitObjectMask(DrawableHitObject hitObject)
-												Add hitobject overlays to selected hitobjects


											
										
										
											2018-02-20 17:01:45 +08:00
+								        {
-												Allow dragging anywhere in a capture box to move objects


											
										
										
											2018-03-09 22:43:50 +08:00
+								            HitObject = hitObject;
-												Rewrite the way drag + click selections happen

The general idea here is that we need the masks to handle mouse down events, as they need to handle the drag (mousedown -> drag immediately).

I've rewritten the editor selections to use events, as there are some 3 different components that handle/trigger selections in different ways.

1. All selections/deselections now propagate through `HitObjectMask.Select()`/`HitObjectMask.Deselect()`.
2. Components that react to changes in the selection bind to the masks' `Selected`/`Deselected` events, and track them/change their states locally.
3. Masks provide a `SingleSelectionRequested` event which is invoked on the mouse-down event. Various components bind to this event to perform state changes locally in this scenario.
4. `DragBox` now handles all drag input locally. It triggers `Select`/`Deselect` on the masks it needs to.
5. `SelectionBox` handles the display of itself locally.
6. `SelectionBox` handles movement of groups of masks locally.
7. `HitObjectMasks` handles movement of itself locally.

											
										
										
											2018-03-29 21:06:45 +08:00
 								            AlwaysPresent = true;
-												Make HitObjectMasks VisibilityContainers


											
										
										
											2018-03-29 16:19:24 +08:00
+								            State = Visibility.Hidden;
-												Make hitobject positions adjustable


											
										
										
											2018-03-09 22:12:34 +08:00
+								        }
-												Make HitObjectMasks VisibilityContainers


											
										
										
											2018-03-29 16:19:24 +08:00
-												Rewrite the way drag + click selections happen

The general idea here is that we need the masks to handle mouse down events, as they need to handle the drag (mousedown -> drag immediately).

I've rewritten the editor selections to use events, as there are some 3 different components that handle/trigger selections in different ways.

1. All selections/deselections now propagate through `HitObjectMask.Select()`/`HitObjectMask.Deselect()`.
2. Components that react to changes in the selection bind to the masks' `Selected`/`Deselected` events, and track them/change their states locally.
3. Masks provide a `SingleSelectionRequested` event which is invoked on the mouse-down event. Various components bind to this event to perform state changes locally in this scenario.
4. `DragBox` now handles all drag input locally. It triggers `Select`/`Deselect` on the masks it needs to.
5. `SelectionBox` handles the display of itself locally.
6. `SelectionBox` handles movement of groups of masks locally.
7. `HitObjectMasks` handles movement of itself locally.

											
										
										
											2018-03-29 21:06:45 +08:00
+								        /// <summary>
 								        /// Selects this <see cref="HitObjectMask"/>, causing it to become visible.
 								        /// </summary>
 								        /// <returns>True if the <see cref="HitObjectMask"/> was selected. False if the <see cref="HitObjectMask"/> was already selected.</returns>
 								        public bool Select()
 								        {
 								            if (State == Visibility.Visible)
 								                return false;
 								            Show();
 								            Selected?.Invoke(this);
 								            return true;
 								        }
-												Move individual mask selection logic out of MaskSelection


											
										
										
											2018-04-04 17:21:27 +08:00
+								        protected override bool OnMouseDown(InputState state, MouseDownEventArgs args)
 								        {
 								            SelectionRequested?.Invoke(this);
 								            return base.OnMouseDown(state, args);
 								        }
-												Rewrite the way drag + click selections happen

The general idea here is that we need the masks to handle mouse down events, as they need to handle the drag (mousedown -> drag immediately).

I've rewritten the editor selections to use events, as there are some 3 different components that handle/trigger selections in different ways.

1. All selections/deselections now propagate through `HitObjectMask.Select()`/`HitObjectMask.Deselect()`.
2. Components that react to changes in the selection bind to the masks' `Selected`/`Deselected` events, and track them/change their states locally.
3. Masks provide a `SingleSelectionRequested` event which is invoked on the mouse-down event. Various components bind to this event to perform state changes locally in this scenario.
4. `DragBox` now handles all drag input locally. It triggers `Select`/`Deselect` on the masks it needs to.
5. `SelectionBox` handles the display of itself locally.
6. `SelectionBox` handles movement of groups of masks locally.
7. `HitObjectMasks` handles movement of itself locally.

											
										
										
											2018-03-29 21:06:45 +08:00
+								        /// <summary>
 								        /// Deselects this <see cref="HitObjectMask"/>, causing it to become invisible.
 								        /// </summary>
 								        /// <returns>True if the <see cref="HitObjectMask"/> was deselected. False if the <see cref="HitObjectMask"/> was already deselected.</returns>
 								        public bool Deselect()
 								        {
 								            if (State == Visibility.Hidden)
 								                return false;
 								            Hide();
 								            Deselected?.Invoke(this);
 								            return true;
 								        }
-												Make HitObjectMasks VisibilityContainers


											
										
										
											2018-03-29 16:19:24 +08:00
+								        protected override void PopIn() => Alpha = 1;
 								        protected override void PopOut() => Alpha = 0;
-												Rewrite the way drag + click selections happen

The general idea here is that we need the masks to handle mouse down events, as they need to handle the drag (mousedown -> drag immediately).

I've rewritten the editor selections to use events, as there are some 3 different components that handle/trigger selections in different ways.

1. All selections/deselections now propagate through `HitObjectMask.Select()`/`HitObjectMask.Deselect()`.
2. Components that react to changes in the selection bind to the masks' `Selected`/`Deselected` events, and track them/change their states locally.
3. Masks provide a `SingleSelectionRequested` event which is invoked on the mouse-down event. Various components bind to this event to perform state changes locally in this scenario.
4. `DragBox` now handles all drag input locally. It triggers `Select`/`Deselect` on the masks it needs to.
5. `SelectionBox` handles the display of itself locally.
6. `SelectionBox` handles movement of groups of masks locally.
7. `HitObjectMasks` handles movement of itself locally.

											
										
										
											2018-03-29 21:06:45 +08:00
 								        /// <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;
-												Add hitobject overlays to selected hitobjects


											
										
										
											2018-02-20 17:01:45 +08:00
+								    }
 								}