Handles reworked, LineToolOverlay converted

src/PixiEditor.AvaloniaUI/Views/Overlays/Handles.cs

@@ -1,16 +0,0 @@
-using Avalonia.Media;
-using PixiEditor.AvaloniaUI.Views.Overlays.TransformOverlay;
-using PixiEditor.DrawingApi.Core.Numerics;
-
-namespace PixiEditor.AvaloniaUI.Views.Overlays;
-
-public static class Handles
-{
-    //TODO: Contextual handles
-    public static void DrawRectangleHandle(this DrawingContext context, IBrush brush, IPen pen, VecD point, double scale)
-    {
-        float scaleMultiplier = (float)(1.0 / scale);
-        float radius = 2.5f * scaleMultiplier;
-        context.DrawRectangle(brush, pen, TransformHelper.ToAnchorRect(point, scale), radius, radius);
-    }
-}

src/PixiEditor.AvaloniaUI/Views/Overlays/Handles/Handle.cs

@@ -0,0 +1,133 @@
+using Avalonia;
+using Avalonia.Controls;
+using Avalonia.Controls.Shapes;
+using Avalonia.Input;
+using Avalonia.Media;
+using PixiEditor.AvaloniaUI.Helpers;
+using PixiEditor.AvaloniaUI.Views.Overlays.TransformOverlay;
+using PixiEditor.DrawingApi.Core.Numerics;
+using PixiEditor.Extensions.UI.Overlays;
+
+namespace PixiEditor.AvaloniaUI.Views.Overlays.Handles;
+
+public delegate void HandleDrag(VecD newPosition);
+public abstract class Handle : IHandle
+{
+    public IBrush HandleBrush { get; set; } = GetBrush("HandleBackgroundBrush");
+    public IPen? HandlePen { get; set; }
+    public double ZoomboxScale { get; set; } = 1.0;
+    public Control Owner { get; set; } = null!;
+    public VecD Position { get; set; }
+    public VecD Size { get; set; }
+    public RectD HandleRect => new(Position, Size);
+
+    public event Action OnPress;
+    public event HandleDrag OnDrag;
+    public event Action OnRelease;
+    public event Action OnHover;
+    public event Action OnExit;
+
+    private bool isPressed;
+    private bool isHovered;
+
+    public Handle(Control owner, VecD position, VecD size)
+    {
+        Owner = owner;
+        Position = position;
+        Size = size;
+
+        Owner.PointerPressed += OnPointerPressed;
+        Owner.PointerMoved += OnPointerMoved;
+        Owner.PointerReleased += OnPointerReleased;
+    }
+
+    public abstract void Draw(DrawingContext context);
+
+    public virtual void OnPressed(PointerPressedEventArgs args) { }
+
+    protected virtual bool IsWithinHandle(VecD handlePos, VecD pos, double zoomboxScale)
+    {
+        return TransformHelper.IsWithinHandle(handlePos, pos, zoomboxScale, Size);
+    }
+
+    protected static Geometry GetHandleGeometry(string handleName)
+    {
+        if (Application.Current.Styles.TryGetResource(handleName, null, out object shape))
+        {
+            return ((Path)shape).Data.Clone();
+        }
+
+        return Geometry.Parse("M 0 0 L 1 0 M 0 0 L 0 1");
+    }
+
+    protected static IBrush GetBrush(string key)
+    {
+        if (Application.Current.Styles.TryGetResource(key, null, out object brush))
+        {
+            return (IBrush)brush;
+        }
+
+        return Brushes.Black;
+    }
+
+    private void OnPointerPressed(object? sender, PointerPressedEventArgs e)
+    {
+        if (e.GetMouseButton(Owner) != MouseButton.Left)
+        {
+            return;
+        }
+
+        VecD pos = TransformHelper.ToVecD(e.GetPosition(Owner));
+        VecD handlePos = Position;
+
+        if (IsWithinHandle(handlePos, pos, ZoomboxScale))
+        {
+            e.Handled = true;
+            OnPressed(e);
+            OnPress?.Invoke();
+            isPressed = true;
+            e.Pointer.Capture(Owner);
+        }
+    }
+
+    private void OnPointerMoved(object? sender, PointerEventArgs e)
+    {
+        VecD pos = TransformHelper.ToVecD(e.GetPosition(Owner));
+        VecD handlePos = Position;
+
+        bool isWithinHandle = IsWithinHandle(handlePos, pos, ZoomboxScale);
+
+        if (!isHovered && isWithinHandle)
+        {
+            isHovered = true;
+            OnHover?.Invoke();
+        }
+        else if (isHovered && isWithinHandle)
+        {
+            isHovered = false;
+            OnExit?.Invoke();
+        }
+
+        if (!isPressed)
+        {
+            return;
+        }
+
+        OnDrag?.Invoke(pos);
+    }
+
+    private void OnPointerReleased(object? sender, PointerReleasedEventArgs e)
+    {
+        if (e.InitialPressMouseButton != MouseButton.Left)
+        {
+            return;
+        }
+
+        if (isPressed)
+        {
+            isPressed = false;
+            OnRelease?.Invoke();
+            e.Pointer.Capture(null);
+        }
+    }
+}

src/PixiEditor.AvaloniaUI/Views/Overlays/Handles/RectangleHandle.cs

@@ -0,0 +1,21 @@
+using Avalonia.Controls;
+using Avalonia.Media;
+using PixiEditor.AvaloniaUI.Views.Overlays.TransformOverlay;
+using PixiEditor.DrawingApi.Core.Numerics;
+using PixiEditor.Extensions.UI.Overlays;
+
+namespace PixiEditor.AvaloniaUI.Views.Overlays.Handles;
+
+public class RectangleHandle : Handle
+{
+    public RectangleHandle(Control owner, VecD position, VecD size) : base(owner, position, size)
+    {
+    }
+
+    public override void Draw(DrawingContext context)
+    {
+        float scaleMultiplier = (float)(1.0 / ZoomboxScale);
+        float radius = 2.5f * scaleMultiplier;
+        context.DrawRectangle(HandleBrush, HandlePen, TransformHelper.ToHandleRect(Position, Size, ZoomboxScale), radius, radius);
+    }
+}

src/PixiEditor.AvaloniaUI/Views/Overlays/Handles/TransformHandle.cs

@@ -0,0 +1,33 @@
+using Avalonia;
+using Avalonia.Controls;
+using Avalonia.Media;
+using PixiEditor.AvaloniaUI.Views.Overlays.TransformOverlay;
+using PixiEditor.DrawingApi.Core.Numerics;
+using PixiEditor.Extensions.UI.Overlays;
+
+namespace PixiEditor.AvaloniaUI.Views.Overlays.Handles;
+
+public class TransformHandle : Handle
+{
+    public IBrush GlyphBrush { get; set; } = GetBrush("HandleGlyphBrush");
+
+    private Geometry handleGeometry = GetHandleGeometry("MoveHandle");
+
+    public TransformHandle(Control owner, VecD position, VecD size) : base(owner, position, size)
+    {
+    }
+
+    public override void Draw(DrawingContext context)
+    {
+        context.DrawRectangle(HandleBrush, HandlePen, TransformHelper.ToHandleRect(Position, Size, ZoomboxScale));
+        double crossSize = HandleRect.Size.X - 1;
+
+        handleGeometry.Transform = new MatrixTransform(
+            new Matrix(
+                0, crossSize / ZoomboxScale,
+                crossSize / ZoomboxScale, 0,
+                Position.X - crossSize / (ZoomboxScale * 2), Position.Y - crossSize / (ZoomboxScale * 2))
+        );
+        context.DrawGeometry(GlyphBrush, null, handleGeometry);
+    }
+}

src/PixiEditor.AvaloniaUI/Views/Overlays/LineToolOverlay/LineToolOverlay.cs

@@ -1,13 +1,12 @@
 using System.Windows.Input;
 using Avalonia;
-using Avalonia.Controls;
-using Avalonia.Controls.Shapes;
 using Avalonia.Input;
 using Avalonia.Interactivity;
 using Avalonia.Media;
 using ChunkyImageLib.DataHolders;
 using PixiEditor.AvaloniaUI.Helpers;
 using PixiEditor.AvaloniaUI.Models.Controllers.InputDevice;
+using PixiEditor.AvaloniaUI.Views.Overlays.Handles;
 using PixiEditor.AvaloniaUI.Views.Overlays.TransformOverlay;
 using PixiEditor.DrawingApi.Core.Numerics;
 using PixiEditor.Views.UserControls.Overlays.LineToolOverlay;
@@ -64,23 +63,39 @@ internal class LineToolOverlay : Overlay
     private VecD lineStartOnMouseDown = VecD.Zero;
     private VecD lineEndOnMouseDown = VecD.Zero;
 
-    private LineToolOverlayAnchor? capturedAnchor = null;
-    private bool dragging = false;
     private bool movedWhileMouseDown = false;
 
-    private Geometry handleGeometry = GetHandleGeometry("MoveHandle");
-
     private MouseUpdateController mouseUpdateController;
 
+    private RectangleHandle startHandle;
+    private RectangleHandle endHandle;
+    private TransformHandle moveHandle;
+
     public LineToolOverlay()
     {
         Cursor = new Cursor(StandardCursorType.Arrow);
+
+        VecD anchorSize = new(14, 14);
+
+        startHandle = new RectangleHandle(this, LineStart, anchorSize);
+        startHandle.HandlePen = blackPen;
+        startHandle.OnDrag += StartHandleOnDrag;
+
+        endHandle = new RectangleHandle(this, LineEnd, anchorSize);
+        startHandle.HandlePen = blackPen;
+        endHandle.OnDrag += EndHandleOnDrag;
+
+        moveHandle = new TransformHandle(this, LineStart, new VecD(24, 24));
+        moveHandle.HandlePen = blackPen;
+        moveHandle.OnDrag += MoveHandleOnDrag;
+
         Loaded += OnLoaded;
     }
 
     private void OnLoaded(object sender, RoutedEventArgs e)
     {
-        mouseUpdateController = new MouseUpdateController(this, MouseMoved);
+        //TODO: Ensure this bug doesn't happen in Avalonia, currently Handle classes are taking care of dragging events
+        //mouseUpdateController = new MouseUpdateController(this, MouseMoved);
     }
 
     private static void OnZoomboxScaleChanged(AvaloniaPropertyChangedEventArgs<double> args)
@@ -88,23 +103,21 @@ internal class LineToolOverlay : Overlay
         var self = (LineToolOverlay)args.Sender;
         double newScale = args.NewValue.Value;
         self.blackPen.Thickness = 1.0 / newScale;
+
+        self.startHandle.ZoomboxScale = newScale;
+        self.endHandle.ZoomboxScale = newScale;
+        self.moveHandle.ZoomboxScale = newScale;
     }
 
     public override void Render(DrawingContext context)
     {
-        context.DrawRectangleHandle(BackgroundBrush, blackPen, LineStart, ZoomboxScale);
-        context.DrawRectangleHandle(BackgroundBrush, blackPen, LineEnd, ZoomboxScale);
-
-        VecD handlePos = TransformHelper.GetDragHandlePos(new ShapeCorners(new RectD(LineStart, LineEnd - LineStart)), ZoomboxScale);
-        const double CrossSize = TransformHelper.MoveHandleSize - 1;
-        context.DrawRectangle(BackgroundBrush, blackPen, TransformHelper.ToHandleRect(handlePos, ZoomboxScale));
-        handleGeometry.Transform = new MatrixTransform(
-            new Matrix(
-            0, CrossSize / ZoomboxScale,
-            CrossSize / ZoomboxScale, 0,
-            handlePos.X - CrossSize / (ZoomboxScale * 2), handlePos.Y - CrossSize / (ZoomboxScale * 2))
-        );
-        context.DrawGeometry(HandleGlyphBrush, null, handleGeometry);
+        startHandle.Position = LineStart;
+        endHandle.Position = LineEnd;
+        moveHandle.Position = TransformHelper.GetDragHandlePos(new ShapeCorners(LineStart, LineEnd - LineStart), ZoomboxScale);
+
+        startHandle.Draw(context);
+        endHandle.Draw(context);
+        moveHandle.Draw(context);
     }
 
     protected override void OnPointerPressed(PointerPressedEventArgs e)
@@ -116,19 +129,9 @@ internal class LineToolOverlay : Overlay
         if (changedButton != MouseButton.Left)
             return;
 
-        e.Handled = true;
-
         VecD pos = TransformHelper.ToVecD(e.GetPosition(this));
-        VecD handlePos = TransformHelper.GetDragHandlePos(new ShapeCorners(new RectD(LineStart, LineEnd - LineStart)), ZoomboxScale);
-
-        if (TransformHelper.IsWithinAnchor(LineStart, pos, ZoomboxScale))
-            capturedAnchor = LineToolOverlayAnchor.Start;
-        else if (TransformHelper.IsWithinAnchor(LineEnd, pos, ZoomboxScale))
-            capturedAnchor = LineToolOverlayAnchor.End;
-        else if (TransformHelper.IsWithinTransformHandle(handlePos, pos, ZoomboxScale))
-            dragging = true;
-        movedWhileMouseDown = false;
 
+        movedWhileMouseDown = false;
         mouseDownPos = pos;
         lineStartOnMouseDown = LineStart;
         lineEndOnMouseDown = LineEnd;
@@ -136,31 +139,26 @@ internal class LineToolOverlay : Overlay
         e.Pointer.Capture(this);
     }
 
-    protected void MouseMoved(PointerEventArgs e)
+    private void StartHandleOnDrag(VecD position)
     {
-        VecD pos = TransformHelper.ToVecD(e.GetPosition(this));
-        if (capturedAnchor == LineToolOverlayAnchor.Start)
-        {
-            LineStart = pos;
-            movedWhileMouseDown = true;
-            return;
-        }
+        LineStart = position;
+        movedWhileMouseDown = true;
+    }
 
-        if (capturedAnchor == LineToolOverlayAnchor.End)
-        {
-            LineEnd = pos;
-            movedWhileMouseDown = true;
-            return;
-        }
-
-        if (dragging)
-        {
-            var delta = pos - mouseDownPos;
-            LineStart = lineStartOnMouseDown + delta;
-            LineEnd = lineEndOnMouseDown + delta;
-            movedWhileMouseDown = true;
-            return;
-        }
+    private void EndHandleOnDrag(VecD position)
+    {
+        LineEnd = position;
+        movedWhileMouseDown = true;
+    }
+
+    private void MoveHandleOnDrag(VecD position)
+    {
+        var delta = position - mouseDownPos;
+
+        LineStart = lineStartOnMouseDown + delta;
+        LineEnd = lineEndOnMouseDown + delta;
+
+        movedWhileMouseDown = true;
     }
 
     protected override void OnPointerReleased(PointerReleasedEventArgs e)
@@ -169,12 +167,7 @@ internal class LineToolOverlay : Overlay
         if (e.InitialPressMouseButton != MouseButton.Left)
             return;
 
-        e.Handled = true;
-        capturedAnchor = null;
-        dragging = false;
         if (movedWhileMouseDown && ActionCompleted is not null && ActionCompleted.CanExecute(null))
             ActionCompleted.Execute(null);
-
-        e.Pointer.Capture(null);
     }
 }

src/PixiEditor.AvaloniaUI/Views/Overlays/Overlay.cs

@@ -7,26 +7,5 @@ namespace PixiEditor.AvaloniaUI.Views.Overlays;
 
 public class Overlay : Decorator
 {
-    protected IBrush HandleGlyphBrush { get; } = GetBrush("HandleGlyphBrush");
-    protected IBrush BackgroundBrush { get; } = GetBrush("HandleBackgroundBrush");
 
-    protected static IBrush GetBrush(string key)
-    {
-        if (Application.Current.Styles.TryGetResource(key, null, out object brush))
-        {
-            return (IBrush)brush;
-        }
-
-        return Brushes.Black;
-    }
-
-    protected static Geometry GetHandleGeometry(string handleName)
-    {
-        if (Application.Current.Styles.TryGetResource(handleName, null, out object shape))
-        {
-            return ((Path)shape).Data.Clone();
-        }
-
-        return Geometry.Parse("M 0 0 L 1 0 M 0 0 L 0 1");
-    }
 }

src/PixiEditor.AvaloniaUI/Views/Overlays/SymmetryOverlay/SymmetryOverlay.cs

@@ -98,7 +98,7 @@ internal class SymmetryOverlay : Overlay
     }
 
     private const double HandleSize = 12;
-    private Geometry handleGeometry = GetHandleGeometry("MarkerHandle");
+    private Geometry handleGeometry /*= GetHandleGeometry("MarkerHandle")*/;
 
     private const double DashWidth = 10.0;
     const int RulerOffset = -35;

src/PixiEditor.AvaloniaUI/Views/Overlays/TransformOverlay/TransformHelper.cs

@@ -11,16 +11,11 @@ internal static class TransformHelper
     public const double AnchorSize = 14;
     public const double MoveHandleSize = 24;
 
-    public static Rect ToAnchorRect(VecD pos, double zoomboxScale)
+    public static Rect ToHandleRect(VecD pos, VecD size, double zoomboxScale)
     {
-        double scaled = AnchorSize / zoomboxScale;
-        return new Rect(pos.X - scaled / 2, pos.Y - scaled / 2, scaled, scaled);
-    }
-
-    public static Rect ToHandleRect(VecD pos, double zoomboxScale)
-    {
-        double scaled = MoveHandleSize / zoomboxScale;
-        return new Rect(pos.X - scaled / 2, pos.Y - scaled / 2, scaled, scaled);
+        double scaledX = size.X / zoomboxScale;
+        double scaledY = size.Y / zoomboxScale;
+        return new Rect(pos.X - scaledX / 2, pos.Y - scaledY / 2, scaledX, scaledY);
     }
 
     public static VecD ToVecD(Point pos) => new VecD(pos.X, pos.Y);
@@ -244,7 +239,7 @@ internal static class TransformHelper
         };
     }
 
-    public static Anchor? GetAnchorInPosition(VecD pos, ShapeCorners corners, VecD origin, double zoomboxScale, double sizeMult = 1)
+    public static Anchor? GetAnchorInPosition(VecD pos, ShapeCorners corners, VecD origin, double zoomboxScale, VecD size)
     {
         VecD topLeft = corners.TopLeft;
         VecD topRight = corners.TopRight;
@@ -252,43 +247,36 @@ internal static class TransformHelper
         VecD bottomRight = corners.BottomRight;
 
         // corners
-        if (IsWithinAnchor(topLeft, pos, zoomboxScale, sizeMult))
+        if (IsWithinHandle(topLeft, pos, zoomboxScale, size))
             return Anchor.TopLeft;
-        if (IsWithinAnchor(topRight, pos, zoomboxScale, sizeMult))
+        if (IsWithinHandle(topRight, pos, zoomboxScale, size))
             return Anchor.TopRight;
-        if (IsWithinAnchor(bottomLeft, pos, zoomboxScale, sizeMult))
+        if (IsWithinHandle(bottomLeft, pos, zoomboxScale, size))
             return Anchor.BottomLeft;
-        if (IsWithinAnchor(bottomRight, pos, zoomboxScale, sizeMult))
+        if (IsWithinHandle(bottomRight, pos, zoomboxScale, size))
             return Anchor.BottomRight;
 
         // sides
-        if (IsWithinAnchor((bottomLeft - topLeft) / 2 + topLeft, pos, zoomboxScale, sizeMult))
+        if (IsWithinHandle((bottomLeft - topLeft) / 2 + topLeft, pos, zoomboxScale, size))
             return Anchor.Left;
-        if (IsWithinAnchor((bottomRight - topRight) / 2 + topRight, pos, zoomboxScale, sizeMult))
+        if (IsWithinHandle((bottomRight - topRight) / 2 + topRight, pos, zoomboxScale, size))
             return Anchor.Right;
-        if (IsWithinAnchor((topLeft - topRight) / 2 + topRight, pos, zoomboxScale, sizeMult))
+        if (IsWithinHandle((topLeft - topRight) / 2 + topRight, pos, zoomboxScale, size))
             return Anchor.Top;
-        if (IsWithinAnchor((bottomLeft - bottomRight) / 2 + bottomRight, pos, zoomboxScale, sizeMult))
+        if (IsWithinHandle((bottomLeft - bottomRight) / 2 + bottomRight, pos, zoomboxScale, size))
             return Anchor.Bottom;
 
         // origin
-        if (IsWithinAnchor(origin, pos, zoomboxScale, sizeMult))
+        if (IsWithinHandle(origin, pos, zoomboxScale, size))
             return Anchor.Origin;
         return null;
     }
 
-    public static bool IsWithinAnchor(VecD anchorPos, VecD mousePos, double zoomboxScale, double sizeMult = 1)
+    public static bool IsWithinHandle(VecD anchorPos, VecD mousePos, double zoomboxScale, VecD size)
     {
         var delta = (anchorPos - mousePos).Abs();
-        double scaled = AnchorSize * sizeMult / zoomboxScale / 2;
-        return delta.X < scaled && delta.Y < scaled;
-    }
-
-    public static bool IsWithinTransformHandle(VecD handlePos, VecD mousePos, double zoomboxScale)
-    {
-        var delta = (handlePos - mousePos).Abs();
-        double scaled = MoveHandleSize / zoomboxScale / 2;
-        return delta.X < scaled && delta.Y < scaled;
+        VecD scaled = size / zoomboxScale / 2;
+        return delta.X < scaled.X && delta.Y < scaled.Y;
     }
 
     public static VecD GetDragHandlePos(ShapeCorners corners, double zoomboxScale)

src/PixiEditor.AvaloniaUI/Views/Overlays/TransformOverlay/TransformOverlay.cs

@@ -144,9 +144,9 @@ internal class TransformOverlay : Overlay
     private Pen blackFreqDashedPen = new Pen(Brushes.Black, 1) { DashStyle = new DashStyle(new double[] { 2, 2 }, 0) };
     private Pen whiteFreqDashedPen = new Pen(Brushes.White, 1) { DashStyle = new DashStyle(new double[] { 2, 2 }, 2) };
 
-    private Geometry handleGeometry = GetHandleGeometry("MoveHandle");
+    private Geometry handleGeometry /*= GetHandleGeometry("MoveHandle")*/;
 
-    private Geometry rotateCursorGeometry = GetHandleGeometry("RotateHandle");
+    private Geometry rotateCursorGeometry /*= GetHandleGeometry("RotateHandle")*/;
 
     private Point lastPointerPos;
     private IPointer? capturedPointer;
@@ -204,7 +204,7 @@ internal class TransformOverlay : Overlay
     private void DrawOverlay
         (DrawingContext context, VecD size, ShapeCorners corners, VecD origin, double zoomboxScale)
     {
-        // draw transparent background to enable mouse input
+        /*// draw transparent background to enable mouse input
         DrawMouseInputArea(context, size);
 
         blackPen.Thickness = 1 / zoomboxScale;
@@ -260,7 +260,7 @@ internal class TransformOverlay : Overlay
         context.DrawGeometry(Brushes.Black, null, handleGeometry);
 
         // rotate cursor
-        context.DrawGeometry(Brushes.White, blackPen, rotateCursorGeometry);
+        context.DrawGeometry(Brushes.White, blackPen, rotateCursorGeometry);*/
     }
 
     protected override void OnPointerExited(PointerEventArgs e)
@@ -271,7 +271,7 @@ internal class TransformOverlay : Overlay
 
     protected override void OnPointerPressed(PointerPressedEventArgs e)
     {
-        base.OnPointerPressed(e);
+        /*base.OnPointerPressed(e);
         if (e.GetMouseButton(this) != MouseButton.Left)
             return;
 
@@ -306,20 +306,22 @@ internal class TransformOverlay : Overlay
         }
         
         e.Pointer.Capture(this);
-        capturedPointer = e.Pointer;
+        capturedPointer = e.Pointer;*/
     }
 
     private bool ShouldRotate(VecD mousePos)
     {
-        if (Corners.IsPointInside(mousePos) ||
+        return false;
+        /*if (Corners.IsPointInside(mousePos) ||
             TransformHelper.GetAnchorInPosition(mousePos, Corners, InternalState.Origin, ZoomboxScale) is not null ||
             TransformHelper.IsWithinTransformHandle(TransformHelper.GetDragHandlePos(Corners, ZoomboxScale), mousePos, ZoomboxScale))
             return false;
-        return TransformHelper.GetAnchorInPosition(mousePos, Corners, InternalState.Origin, ZoomboxScale, anchorSizeMultiplierForRotation) is not null;
+        return TransformHelper.GetAnchorInPosition(mousePos, Corners, InternalState.Origin, ZoomboxScale, anchorSizeMultiplierForRotation) is not null;*/
     }
 
     private bool UpdateRotationCursor(VecD mousePos)
     {
+        return false;
         if ((!ShouldRotate(mousePos) && !isRotating) || LockRotation)
         {
             rotateCursorGeometry.Transform = new ScaleTransform(0, 0);
@@ -351,7 +353,7 @@ internal class TransformOverlay : Overlay
         }
 
         VecD pos = TransformHelper.ToVecD(e.GetPosition(this));
-        Anchor? anchor = TransformHelper.GetAnchorInPosition(pos, Corners, InternalState.Origin, ZoomboxScale);
+        //Anchor? anchor = TransformHelper.GetAnchorInPosition(pos, Corners, InternalState.Origin, ZoomboxScale);
 
         if (isMoving)
         {
@@ -380,14 +382,14 @@ internal class TransformOverlay : Overlay
             InternalState = InternalState with { ProportionalAngle1 = propAngle1OnStartRotate + angle, ProportionalAngle2 = propAngle2OnStartRotate + angle, };
             Corners = TransformUpdateHelper.UpdateShapeFromRotation(cornersOnStartRotate, InternalState.Origin, angle);
         }
-        else if (anchor is not null)
+        /*else if (anchor is not null)
         {
             if ((TransformHelper.IsCorner((Anchor)anchor) && CornerFreedom == TransformCornerFreedom.Free) ||
                 (TransformHelper.IsSide((Anchor)anchor) && SideFreedom == TransformSideFreedom.Free))
                 finalCursor = new Cursor(StandardCursorType.Arrow);
             else
                 finalCursor = TransformHelper.GetResizeCursor((Anchor)anchor, Corners, ZoomboxAngle);
-        }
+        }*/
 
         if (Cursor != finalCursor)
             Cursor = finalCursor;

src/PixiEditor.Extensions/UI/Overlays/IHandle.cs

@@ -0,0 +1,16 @@
+using Avalonia.Controls;
+using Avalonia.Input;
+using Avalonia.Media;
+
+namespace PixiEditor.Extensions.UI.Overlays;
+
+public interface IHandle
+{
+    public Control Owner { get; }
+    public IBrush HandleBrush { get; set; }
+    public IPen? HandlePen { get; set; }
+    public double ZoomboxScale { get; set; }
+
+    public void Draw(DrawingContext context);
+    protected void OnPressed(PointerPressedEventArgs args);
+}