Use Controls to implement node resizing

src/Blazor.Diagrams.Core/Controls/Default/ResizeControl.cs

@@ -0,0 +1,36 @@
+using Blazor.Diagrams.Core.Events;
+using Blazor.Diagrams.Core.Geometry;
+using Blazor.Diagrams.Core.Models.Base;
+using Blazor.Diagrams.Core.Positions.Resizing;
+using System.Threading.Tasks;
+
+namespace Blazor.Diagrams.Core.Controls.Default
+{
+    public class ResizeControl : ExecutableControl
+    {
+        private readonly IResizeProvider _resizeProvider;
+
+        public ResizeControl(IResizeProvider resizeProvider)
+        {
+            _resizeProvider = resizeProvider;
+        }
+
+        public override Point? GetPosition(Model model) => _resizeProvider.GetPosition(model);
+
+        public override ValueTask OnPointerDown(Diagram diagram, Model model, PointerEventArgs e)
+        {
+            _resizeProvider.OnResizeStart(diagram, model, e);
+            diagram.PointerMove += _resizeProvider.OnPointerMove;
+            diagram.PointerUp += _resizeProvider.OnResizeEnd;
+            diagram.PointerUp += (_, _) => OnResizeEnd(diagram);
+
+            return ValueTask.CompletedTask;
+        }
+
+        void OnResizeEnd(Diagram diagram)
+        {
+            diagram.PointerMove -= _resizeProvider.OnPointerMove;
+            diagram.PointerUp -= _resizeProvider.OnResizeEnd;
+        }
+    }
+}

src/Blazor.Diagrams.Core/Models/NodeModel.cs

@@ -11,6 +11,7 @@ public class NodeModel : MovableModel, IHasBounds, IHasShape, ILinkable
     private readonly List<PortModel> _ports = new();
     private readonly List<BaseLinkModel> _links = new();
     private Size? _size;
+    public Size MinimumDimensions { get; set; } = new Size(0, 0);
 
     public event Action<NodeModel>? SizeChanged;
     public event Action<NodeModel>? Moving;

src/Blazor.Diagrams.Core/Positions/Resizing/BottomLeftResizerProvider.cs

@@ -0,0 +1,72 @@
+using Blazor.Diagrams.Core.Events;
+using Blazor.Diagrams.Core.Geometry;
+using Blazor.Diagrams.Core.Models;
+using Blazor.Diagrams.Core.Models.Base;
+
+namespace Blazor.Diagrams.Core.Positions.Resizing
+{
+    public class BottomLeftResizerProvider : IResizeProvider
+    {
+        private Size _originalSize = null!;
+        private Point _originalPosition = null!;
+        private Point _originalMousePosition = null!;
+        private NodeModel _nodeModel = null!;
+
+        public Point? GetPosition(Model model)
+        {
+            if (model is NodeModel nodeModel && nodeModel.Size is not null)
+            {
+                return new Point(nodeModel.Position.X - 5, nodeModel.Position.Y + nodeModel.Size.Height + 5);
+            }
+            return null;
+        }
+
+        public void OnResizeStart(Diagram diagram, Model model, PointerEventArgs eventArgs)
+        {
+            if (model is NodeModel nodeModel)
+            {
+                _originalPosition = new Point(nodeModel.Position.X, nodeModel.Position.Y);
+                _originalMousePosition = new Point(eventArgs.ClientX, eventArgs.ClientY);
+                _originalSize = nodeModel.Size!;
+                _nodeModel = nodeModel;
+            }
+        }
+
+        public void OnPointerMove(Model? model, PointerEventArgs args)
+        {
+            if (_nodeModel is null)
+            {
+                return;
+            }
+
+            var height = _originalSize.Height + (args.ClientY - _originalMousePosition.Y);
+            var width = _originalSize.Width - (args.ClientX - _originalMousePosition.X);
+
+            var positionX = _originalPosition.X + (args.ClientX - _originalMousePosition.X);
+            var positionY = _originalPosition.Y;
+
+            if (width < _nodeModel.MinimumDimensions.Width)
+            {
+                width = _nodeModel.MinimumDimensions.Width;
+                positionX = _nodeModel.Position.X;
+            }
+            if (height < _nodeModel.MinimumDimensions.Height)
+            {
+                height = _nodeModel.MinimumDimensions.Height;
+                positionY = _nodeModel.Position.Y;
+            }
+
+            _nodeModel.SetPosition(positionX, positionY);
+            _nodeModel.Size = new Size(width, height);
+        }
+
+        public void OnResizeEnd(Model? model, PointerEventArgs args)
+        {
+            _originalSize = null!;
+            _originalPosition = null!;
+            _originalMousePosition = null!;
+            _nodeModel = null!;
+        }
+
+    }
+}

src/Blazor.Diagrams.Core/Positions/Resizing/BottomRightResizerProvider.cs

@@ -0,0 +1,68 @@
+using Blazor.Diagrams.Core.Events;
+using Blazor.Diagrams.Core.Geometry;
+using Blazor.Diagrams.Core.Models;
+using Blazor.Diagrams.Core.Models.Base;
+
+namespace Blazor.Diagrams.Core.Positions.Resizing
+{
+    public class BottomRightResizerProvider : IResizeProvider
+    {
+        private Size _originalSize = null!;
+        private Point _originalMousePosition = null!;
+        private NodeModel _nodeModel = null!;
+
+        public Point? GetPosition(Model model)
+        {
+            if (model is NodeModel nodeModel && nodeModel.Size is not null)
+            {
+                return new Point(nodeModel.Position.X + nodeModel.Size.Width + 5, nodeModel.Position.Y + nodeModel.Size.Height + 5);
+            }
+            return null;
+        }
+
+        public void OnResizeStart(Diagram diagram, Model model, PointerEventArgs eventArgs)
+        {
+            if (model is NodeModel nodeModel)
+            {
+                _originalMousePosition = new Point(eventArgs.ClientX, eventArgs.ClientY);
+                _originalSize = nodeModel.Size!;
+                _nodeModel = nodeModel;
+            }
+        }
+
+        public void OnPointerMove(Model? model, PointerEventArgs args)
+        {
+            if (_nodeModel is null)
+            {
+                return;
+            }
+            var positionX = _nodeModel.Position.X;
+            var positionY = _nodeModel.Position.Y;
+
+            var height = _originalSize.Height + (args.ClientY - _originalMousePosition.Y);
+            var width = _originalSize.Width + (args.ClientX - _originalMousePosition.X);
+
+            if (width < _nodeModel.MinimumDimensions.Width)
+            {
+                width = _nodeModel.MinimumDimensions.Width;
+                positionX = _nodeModel.Position.X;
+            }
+            if (height < _nodeModel.MinimumDimensions.Height)
+            {
+                height = _nodeModel.MinimumDimensions.Height;
+                positionY = _nodeModel.Position.Y;
+            }
+
+            _nodeModel.SetPosition(positionX, positionY);
+            _nodeModel.Size = new Size(width, height);
+        }
+
+        public void OnResizeEnd(Model? model, PointerEventArgs args)
+        {
+            _originalSize = null!;
+            _originalMousePosition = null!;
+            _nodeModel = null!;
+        }
+
+    }
+}

src/Blazor.Diagrams.Core/Positions/Resizing/IResizeProvider.cs

@@ -0,0 +1,13 @@
+using Blazor.Diagrams.Core.Events;
+using Blazor.Diagrams.Core.Models;
+using Blazor.Diagrams.Core.Models.Base;
+
+namespace Blazor.Diagrams.Core.Positions.Resizing
+{
+    public interface IResizeProvider : IPositionProvider
+    {
+        public void OnResizeStart(Diagram diagram, Model model, PointerEventArgs eventArgs);
+        public void OnPointerMove(Model? model, PointerEventArgs args);
+        public void OnResizeEnd(Model? model, PointerEventArgs args);
+    }
+}

src/Blazor.Diagrams.Core/Positions/Resizing/TopLeftResizerProvider.cs

@@ -0,0 +1,72 @@
+using Blazor.Diagrams.Core.Events;
+using Blazor.Diagrams.Core.Geometry;
+using Blazor.Diagrams.Core.Models;
+using Blazor.Diagrams.Core.Models.Base;
+
+namespace Blazor.Diagrams.Core.Positions.Resizing
+{
+    public class TopLeftResizerProvider : IResizeProvider
+    {
+        private Size _originalSize = null!;
+        private Point _originalPosition = null!;
+        private Point _originalMousePosition = null!;
+        private NodeModel _nodeModel = null!;
+
+        public Point? GetPosition(Model model)
+        {
+            if (model is NodeModel nodeModel && nodeModel.Size is not null)
+            {
+                return new Point(nodeModel.Position.X - 5, nodeModel.Position.Y - 5);
+            }
+            return null;
+        }
+
+        public void OnResizeStart(Diagram diagram, Model model, PointerEventArgs eventArgs)
+        {
+            if (model is NodeModel nodeModel)
+            {
+                _originalPosition = new Point(nodeModel.Position.X, nodeModel.Position.Y);
+                _originalMousePosition = new Point(eventArgs.ClientX, eventArgs.ClientY);
+                _originalSize = nodeModel.Size!;
+                _nodeModel = nodeModel;
+            }
+        }
+
+        public void OnPointerMove(Model? model, PointerEventArgs args)
+        {
+            if (_nodeModel is null)
+            {
+                return;
+            }
+
+            var height = _originalSize.Height - (args.ClientY - _originalMousePosition.Y);
+            var width = _originalSize.Width - (args.ClientX - _originalMousePosition.X);
+
+            var positionX = _originalPosition.X + (args.ClientX - _originalMousePosition.X);
+            var positionY = _originalPosition.Y + (args.ClientY - _originalMousePosition.Y);
+
+            if (width < _nodeModel.MinimumDimensions.Width)
+            {
+                width = _nodeModel.MinimumDimensions.Width;
+                positionX = _nodeModel.Position.X;
+            }
+            if (height < _nodeModel.MinimumDimensions.Height)
+            {
+                height = _nodeModel.MinimumDimensions.Height;
+                positionY = _nodeModel.Position.Y;
+            }
+
+            _nodeModel.SetPosition(positionX, positionY);
+            _nodeModel.Size = new Size(width, height);
+        }
+
+        public void OnResizeEnd(Model? model, PointerEventArgs args)
+        {
+            _originalSize = null!;
+            _originalPosition = null!;
+            _originalMousePosition = null!;
+            _nodeModel = null!;
+        }
+
+    }
+}

src/Blazor.Diagrams.Core/Positions/Resizing/TopRightResizerProvider.cs

@@ -0,0 +1,71 @@
+using Blazor.Diagrams.Core.Events;
+using Blazor.Diagrams.Core.Geometry;
+using Blazor.Diagrams.Core.Models;
+using Blazor.Diagrams.Core.Models.Base;
+
+namespace Blazor.Diagrams.Core.Positions.Resizing
+{
+    public class TopRightResizerProvider : IResizeProvider
+    {
+        private Size _originalSize = null!;
+        private Point _originalPosition = null!;
+        private Point _originalMousePosition = null!;
+        private NodeModel _nodeModel = null!;
+
+        public Point? GetPosition(Model model)
+        {
+            if (model is NodeModel nodeModel && nodeModel.Size is not null)
+            {
+                return new Point(nodeModel.Position.X + nodeModel.Size.Width + 5, nodeModel.Position.Y - 5);
+            }
+            return null;
+        }
+
+        public void OnResizeStart(Diagram diagram, Model model, PointerEventArgs eventArgs)
+        {
+            if (model is NodeModel nodeModel)
+            {
+                _originalPosition = new Point(nodeModel.Position.X, nodeModel.Position.Y);
+                _originalMousePosition = new Point(eventArgs.ClientX, eventArgs.ClientY);
+                _originalSize = nodeModel.Size!;
+                _nodeModel = nodeModel;
+            }
+        }
+
+        public void OnPointerMove(Model? model, PointerEventArgs args)
+        {
+            if (_nodeModel is null)
+            {
+                return;
+            }
+            var height = _originalSize.Height - (args.ClientY - _originalMousePosition.Y);
+            var width = _originalSize.Width + (args.ClientX - _originalMousePosition.X);
+
+            var positionX = _originalPosition.X;
+            var positionY = _originalPosition.Y + (args.ClientY - _originalMousePosition.Y);
+
+            if (width < _nodeModel.MinimumDimensions.Width)
+            {
+                width = _nodeModel.MinimumDimensions.Width;
+                positionX = _nodeModel.Position.X;
+            }
+            if (height < _nodeModel.MinimumDimensions.Height)
+            {
+                height = _nodeModel.MinimumDimensions.Height;
+                positionY = _nodeModel.Position.Y;
+            }
+
+            _nodeModel.SetPosition(positionX, positionY);
+            _nodeModel.Size = new Size(width, height);
+        }
+
+        public void OnResizeEnd(Model? model, PointerEventArgs args)
+        {
+            _originalSize = null!;
+            _originalPosition = null!;
+            _originalMousePosition = null!;
+            _nodeModel = null!;
+        }
+
+    }
+}

src/Blazor.Diagrams/BlazorDiagram.cs

@@ -19,7 +19,8 @@ public BlazorDiagram(BlazorDiagramOptions? options = null)
             [typeof(RemoveControl)] = typeof(RemoveControlWidget),
             [typeof(BoundaryControl)] = typeof(BoundaryControlWidget),
             [typeof(DragNewLinkControl)] = typeof(DragNewLinkControlWidget),
-            [typeof(ArrowHeadControl)] = typeof(ArrowHeadControlWidget)
+            [typeof(ArrowHeadControl)] = typeof(ArrowHeadControlWidget),
+            [typeof(ResizeControl)] = typeof(ResizeControlWidget)
         };
 
         Options = options ?? new BlazorDiagramOptions();

src/Blazor.Diagrams/Components/Controls/ResizeControlWidget.razor

@@ -0,0 +1,10 @@
+<div class="default-node-resizer" />
+
+@code
+{
+    [Parameter]
+    public ResizeControl Control { get; set; } = null!;
+
+    [Parameter]
+    public Model Model { get; set; } = null!;
+}

src/Blazor.Diagrams/Components/NodeWidget.razor

@@ -1,4 +1,4 @@
-<div class="default-node @(Node.Group != null ? "grouped" : "") @(Node.Selected ? "selected" : "")">
+<div class="default-node @(Node.Group != null ? "grouped" : "") @(Node.Selected ? "selected" : "")" style=@GenerateStyle()>
     @(Node.Title ?? "Title")
     @foreach (var port in Node.Ports)
     {
@@ -11,4 +11,12 @@
     [Parameter]
     public NodeModel Node { get; set; } = null!;
 
+    private string GenerateStyle()
+    {
+        if (Node.Size is not null)
+        {
+            return $"width: {Node.Size.Width}px; height: {Node.Size.Height}px";
+        }
+        return string.Empty;
+    }
 }