Refactor to command pattern for change handling

osu.Game.Rulesets.Osu/Edit/Blueprints/Sliders/Components/PathControlPointVisualiser.cs

@@ -26,6 +26,7 @@
 using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Screens.Edit;
+using osu.Game.Screens.Edit.Commands.Proxies;
 using osuTK;
 using osuTK.Input;
 
@@ -42,6 +43,8 @@ public partial class PathControlPointVisualiser<T> : CompositeDrawable, IKeyBind
         private readonly T hitObject;
         private readonly bool allowSelection;
 
+        private CommandProxy<T> proxy => hitObject.AsCommandProxy(commandHandler);
+
         private InputManager inputManager;
 
         public Action<List<PathControlPoint>> RemoveControlPointsRequested;
@@ -113,15 +116,15 @@ private void ensureValidPathType(IReadOnlyList<PathControlPoint> segment)
                 return;
 
             if (segment.Count > 3)
-                first.Type = PathType.BEZIER;
+                first.AsCommandProxy(commandHandler).SetType(PathType.BEZIER);
 
             if (segment.Count != 3)
                 return;
 
             ReadOnlySpan<Vector2> points = segment.Select(p => p.Position).ToArray();
             RectangleF boundingBox = PathApproximator.CircularArcBoundingBox(points);
             if (boundingBox.Width >= 640 || boundingBox.Height >= 480)
-                first.Type = PathType.BEZIER;
+                first.AsCommandProxy(commandHandler).SetType(PathType.BEZIER);
         }
 
         /// <summary>
@@ -146,9 +149,9 @@ public bool DeleteSelected()
             if (toRemove.Count == 0)
                 return false;
 
-            changeHandler?.BeginChange();
+            commandHandler?.BeginChange();
             RemoveControlPointsRequested?.Invoke(toRemove);
-            changeHandler?.EndChange();
+            commandHandler?.EndChange();
 
             // Since pieces are re-used, they will not point to the deleted control points while remaining selected
             foreach (var piece in Pieces)
@@ -165,9 +168,9 @@ private bool splitSelected()
             if (controlPointsToSplitAt.Count == 0)
                 return false;
 
-            changeHandler?.BeginChange();
+            commandHandler?.BeginChange();
             SplitControlPointsRequested?.Invoke(controlPointsToSplitAt);
-            changeHandler?.EndChange();
+            commandHandler?.EndChange();
 
             // Since pieces are re-used, they will not point to the deleted control points while remaining selected
             foreach (var piece in Pieces)
@@ -286,7 +289,7 @@ protected override bool OnKeyDown(KeyDownEvent e)
                     if (currentTypeIndex < 0 && e.ShiftPressed)
                         currentTypeIndex = 0;
 
-                    changeHandler?.BeginChange();
+                    commandHandler?.BeginChange();
 
                     do
                     {
@@ -295,7 +298,7 @@ protected override bool OnKeyDown(KeyDownEvent e)
                         updatePathTypeOfSelectedPieces(validTypes[currentTypeIndex]);
                     } while (selectedPoint.Type != validTypes[currentTypeIndex]);
 
-                    changeHandler?.EndChange();
+                    commandHandler?.EndChange();
 
                     return true;
                 }
@@ -351,13 +354,13 @@ private void selectionRequested(PathControlPointPiece<T> piece, MouseButtonEvent
         /// <param name="type">The path type we want to assign to the given control point piece.</param>
         private void updatePathTypeOfSelectedPieces(PathType? type)
         {
-            changeHandler?.BeginChange();
+            commandHandler?.BeginChange();
 
             double originalDistance = hitObject.Path.Distance;
 
             foreach (var p in Pieces.Where(p => p.IsSelected.Value))
             {
-                List<PathControlPoint> pointsInSegment = hitObject.Path.PointsInSegment(p.ControlPoint);
+                var pointsInSegment = hitObject.Path.PointsInSegment(p.ControlPoint).AsListCommandProxy(commandHandler);
                 int indexInSegment = pointsInSegment.IndexOf(p.ControlPoint);
 
                 if (type?.Type == SplineType.PerfectCurve)
@@ -368,26 +371,23 @@ private void updatePathTypeOfSelectedPieces(PathType? type)
                     int thirdPointIndex = indexInSegment + 2;
 
                     if (pointsInSegment.Count > thirdPointIndex + 1)
-                        pointsInSegment[thirdPointIndex].Type = pointsInSegment[0].Type;
+                        pointsInSegment[thirdPointIndex].SetType(pointsInSegment[0].Type());
                 }
 
-                hitObject.Path.ExpectedDistance.Value = null;
-                p.ControlPoint.Type = type;
+                proxy.Path().SetExpectedDistance(null);
+                p.ControlPoint.AsCommandProxy(commandHandler).SetType(type);
             }
 
             EnsureValidPathTypes();
 
             if (hitObject.Path.Distance < originalDistance)
-                hitObject.SnapTo(distanceSnapProvider);
+                proxy.SnapTo(distanceSnapProvider);
             else
-                hitObject.Path.ExpectedDistance.Value = originalDistance;
+                proxy.Path().SetExpectedDistance(originalDistance);
 
-            changeHandler?.EndChange();
+            commandHandler?.EndChange();
         }
 
-        [Resolved(CanBeNull = true)]
-        private IEditorChangeHandler changeHandler { get; set; }
-
         #region Drag handling
 
         private Vector2[] dragStartPositions;
@@ -406,11 +406,15 @@ public void DragStarted(PathControlPoint controlPoint)
 
             Debug.Assert(draggedControlPointIndex >= 0);
 
-            changeHandler?.BeginChange();
+            commandHandler?.BeginChange();
         }
 
+        [Resolved(CanBeNull = true)]
+        private EditorCommandHandler commandHandler { get; set; }
+
         public void DragInProgress(DragEvent e)
         {
+            var controlPointsProxy = proxy.Path().ControlPoints();
             Vector2[] oldControlPoints = hitObject.Path.ControlPoints.Select(cp => cp.Position).ToArray();
             Vector2 oldPosition = hitObject.Position;
             double oldStartTime = hitObject.StartTime;
@@ -423,18 +427,18 @@ public void DragInProgress(DragEvent e)
 
                 Vector2 movementDelta = Parent!.ToLocalSpace(result?.ScreenSpacePosition ?? newHeadPosition) - hitObject.Position;
 
-                hitObject.Position += movementDelta;
-                hitObject.StartTime = result?.Time ?? hitObject.StartTime;
+                proxy.SetPosition(hitObject.Position + movementDelta);
+                proxy.SetStartTime(result?.Time ?? hitObject.StartTime);
 
-                for (int i = 1; i < hitObject.Path.ControlPoints.Count; i++)
+                for (int i = 1; i < controlPointsProxy.Count; i++)
                 {
-                    PathControlPoint controlPoint = hitObject.Path.ControlPoints[i];
+                    var controlPointProxy = controlPointsProxy[i];
                     // Since control points are relative to the position of the hit object, all points that are _not_ selected
                     // need to be offset _back_ by the delta corresponding to the movement of the head point.
                     // All other selected control points (if any) will move together with the head point
                     // (and so they will not move at all, relative to each other).
-                    if (!selectedControlPoints.Contains(controlPoint))
-                        controlPoint.Position -= movementDelta;
+                    if (!selectedControlPoints.Contains(controlPointProxy.Target))
+                        controlPointProxy.SetPosition(controlPointProxy.Position() - movementDelta);
                 }
             }
             else
@@ -443,37 +447,37 @@ public void DragInProgress(DragEvent e)
 
                 Vector2 movementDelta = Parent!.ToLocalSpace(result?.ScreenSpacePosition ?? Parent!.ToScreenSpace(e.MousePosition)) - dragStartPositions[draggedControlPointIndex] - hitObject.Position;
 
-                for (int i = 0; i < controlPoints.Count; ++i)
+                for (int i = 0; i < controlPointsProxy.Count; ++i)
                 {
-                    PathControlPoint controlPoint = controlPoints[i];
-                    if (selectedControlPoints.Contains(controlPoint))
-                        controlPoint.Position = dragStartPositions[i] + movementDelta;
+                    var controlPointProxy = controlPointsProxy[i];
+                    if (selectedControlPoints.Contains(controlPointProxy.Target))
+                        controlPointProxy.SetPosition(dragStartPositions[i] + movementDelta);
                 }
             }
 
             // Snap the path to the current beat divisor before checking length validity.
-            hitObject.SnapTo(distanceSnapProvider);
+            proxy.SnapTo(distanceSnapProvider);
 
             if (!hitObject.Path.HasValidLength)
             {
-                for (int i = 0; i < hitObject.Path.ControlPoints.Count; i++)
-                    hitObject.Path.ControlPoints[i].Position = oldControlPoints[i];
+                for (int i = 0; i < controlPointsProxy.Count; i++)
+                    controlPointsProxy[i].SetPosition(oldControlPoints[i]);
 
-                hitObject.Position = oldPosition;
-                hitObject.StartTime = oldStartTime;
+                proxy.SetPosition(oldPosition);
+                proxy.SetStartTime(oldStartTime);
                 // Snap the path length again to undo the invalid length.
-                hitObject.SnapTo(distanceSnapProvider);
+                proxy.SnapTo(distanceSnapProvider);
                 return;
             }
 
             // Maintain the path types in case they got defaulted to bezier at some point during the drag.
-            for (int i = 0; i < hitObject.Path.ControlPoints.Count; i++)
-                hitObject.Path.ControlPoints[i].Type = dragPathTypes[i];
+            for (int i = 0; i < controlPointsProxy.Count; i++)
+                controlPointsProxy[i].SetType(dragPathTypes[i]);
 
             EnsureValidPathTypes();
         }
 
-        public void DragEnded() => changeHandler?.EndChange();
+        public void DragEnded() => commandHandler?.EndChange();
 
         #endregion