Convert shape extensions to DrawingCanvas methods

Author: JimBobSquarePants

src/ImageSharp.Drawing/Processing/DRAWING_CANVAS.md

@@ -376,7 +376,7 @@ If you want to move from the architecture into the code, this is the best order.
 
 1. `DrawingCanvas.cs`
 2. `DrawingCanvas{TPixel}.cs`
-3. `DrawingCanvasFactoryExtensions.cs` and `DrawingCanvasShapeExtensions.cs`
+3. `DrawingCanvasFactoryExtensions.cs` and `DrawingCanvas.Shapes.cs`
 4. `DrawingCanvasBatcher{TPixel}.cs`
 5. `CompositionCommand.cs`
 6. `DefaultDrawingBackend.cs`

…ocessing/DrawingCanvasShapeExtensions.cs …awing/Processing/DrawingCanvas.Shapes.cssrc/ImageSharp.Drawing/Processing/DrawingCanvasShapeExtensions.cs renamed to src/ImageSharp.Drawing/Processing/DrawingCanvas.Shapes.cs src/ImageSharp.Drawing/Processing/DrawingCanvasShapeExtensions.cs renamed to src/ImageSharp.Drawing/Processing/DrawingCanvas.Shapes.cs

@@ -3,238 +3,223 @@
 
 namespace SixLabors.ImageSharp.Drawing.Processing;
 
-/// <summary>
-/// Convenience canvas helpers that forward to the core <see cref="DrawingCanvas"/> primitives.
-/// </summary>
-public static class DrawingCanvasShapeExtensions
+/// <content>
+/// Convenience shape helpers that forward to the core <see cref="DrawingCanvas"/> primitives.
+/// </content>
+public abstract partial class DrawingCanvas
 {
     /// <summary>
     /// Saves the current drawing state and begins an isolated compositing layer over the whole canvas.
     /// </summary>
-    /// <param name="canvas">The destination canvas.</param>
     /// <returns>The save count after the layer state has been pushed.</returns>
-    public static int SaveLayer(this DrawingCanvas canvas)
-        => canvas.SaveLayer(new GraphicsOptions(), canvas.Bounds);
+    public int SaveLayer()
+        => this.SaveLayer(new GraphicsOptions(), this.Bounds);
 
     /// <summary>
     /// Saves the current drawing state and begins an isolated compositing layer over the whole canvas.
     /// </summary>
-    /// <param name="canvas">The destination canvas.</param>
     /// <param name="layerOptions">Graphics options controlling how the layer is composited on restore.</param>
     /// <returns>The save count after the layer state has been pushed.</returns>
-    public static int SaveLayer(this DrawingCanvas canvas, GraphicsOptions layerOptions)
-        => canvas.SaveLayer(layerOptions, canvas.Bounds);
+    public int SaveLayer(GraphicsOptions layerOptions)
+        => this.SaveLayer(layerOptions, this.Bounds);
 
     /// <summary>
     /// Fills the whole canvas using the given brush.
     /// </summary>
-    /// <param name="canvas">The destination canvas.</param>
     /// <param name="brush">Brush used to shade destination pixels.</param>
-    public static void Fill(this DrawingCanvas canvas, Brush brush)
+    public void Fill(Brush brush)
     {
-        Rectangle bounds = canvas.Bounds;
-        canvas.Fill(brush, new RectangularPolygon(bounds));
+        Rectangle bounds = this.Bounds;
+
+        this.Fill(brush, new RectangularPolygon(bounds));
     }
 
     /// <summary>
     /// Fills a local region using the given brush.
     /// </summary>
-    /// <param name="canvas">The destination canvas.</param>
     /// <param name="brush">Brush used to shade destination pixels.</param>
     /// <param name="region">Region to fill in local coordinates.</param>
-    public static void Fill(this DrawingCanvas canvas, Brush brush, Rectangle region)
-        => canvas.Fill(brush, new RectangularPolygon(region));
+    public void Fill(Brush brush, Rectangle region)
+        => this.Fill(brush, new RectangularPolygon(region));
 
     /// <summary>
     /// Clears the whole canvas using the given brush and clear-style composition options.
     /// </summary>
-    /// <param name="canvas">The destination canvas.</param>
     /// <param name="brush">Brush used to shade destination pixels during clear.</param>
-    public static void Clear(this DrawingCanvas canvas, Brush brush)
+    public void Clear(Brush brush)
     {
-        Rectangle bounds = canvas.Bounds;
-        canvas.Clear(brush, new RectangularPolygon(bounds));
+        Rectangle bounds = this.Bounds;
+
+        this.Clear(brush, new RectangularPolygon(bounds));
     }
 
     /// <summary>
     /// Clears a local region using the given brush and clear-style composition options.
     /// </summary>
-    /// <param name="canvas">The destination canvas.</param>
     /// <param name="brush">Brush used to shade destination pixels during clear.</param>
     /// <param name="region">Region to clear in local coordinates.</param>
-    public static void Clear(this DrawingCanvas canvas, Brush brush, Rectangle region)
-        => canvas.Clear(brush, new RectangularPolygon(region));
+    public void Clear(Brush brush, Rectangle region)
+        => this.Clear(brush, new RectangularPolygon(region));
 
     /// <summary>
     /// Fills all paths in a collection using the given brush.
     /// </summary>
-    /// <param name="canvas">The destination canvas.</param>
     /// <param name="brush">Brush used to shade covered pixels.</param>
     /// <param name="paths">Path collection to fill.</param>
-    public static void Fill(this DrawingCanvas canvas, Brush brush, IPathCollection paths)
+    public void Fill(Brush brush, IPathCollection paths)
     {
         Guard.NotNull(paths, nameof(paths));
 
         foreach (IPath path in paths)
         {
-            canvas.Fill(brush, path);
+            this.Fill(brush, path);
         }
     }
 
     /// <summary>
     /// Fills a path built by the provided builder using the given brush.
     /// </summary>
-    /// <param name="canvas">The destination canvas.</param>
     /// <param name="brush">Brush used to shade covered pixels.</param>
     /// <param name="pathBuilder">The path builder describing the fill region.</param>
-    public static void Fill(this DrawingCanvas canvas, Brush brush, PathBuilder pathBuilder)
+    public void Fill(Brush brush, PathBuilder pathBuilder)
     {
         Guard.NotNull(pathBuilder, nameof(pathBuilder));
-        canvas.Fill(brush, pathBuilder.Build());
+
+        this.Fill(brush, pathBuilder.Build());
     }
 
     /// <summary>
     /// Fills an ellipse using the provided brush.
     /// </summary>
-    /// <param name="canvas">The destination canvas.</param>
     /// <param name="brush">Brush used to shade covered pixels.</param>
     /// <param name="center">Ellipse center point in local coordinates.</param>
     /// <param name="size">Ellipse width and height in local coordinates.</param>
-    public static void FillEllipse(this DrawingCanvas canvas, Brush brush, PointF center, SizeF size)
-        => canvas.Fill(brush, new EllipsePolygon(center, size));
+    public void FillEllipse(Brush brush, PointF center, SizeF size)
+        => this.Fill(brush, new EllipsePolygon(center, size));
 
     /// <summary>
     /// Fills the closed arc shape produced by joining the arc endpoints with a straight line.
     /// </summary>
-    /// <param name="canvas">The destination canvas.</param>
     /// <param name="brush">Brush used to shade covered pixels.</param>
     /// <param name="center">Arc center point in local coordinates.</param>
     /// <param name="radius">Arc radii in local coordinates.</param>
     /// <param name="rotation">Ellipse rotation in degrees.</param>
     /// <param name="startAngle">Arc start angle in degrees.</param>
     /// <param name="sweepAngle">Arc sweep angle in degrees.</param>
-    public static void FillArc(this DrawingCanvas canvas, Brush brush, PointF center, SizeF radius, float rotation, float startAngle, float sweepAngle)
-        => canvas.Fill(brush, new Path(new ArcLineSegment(center, radius, rotation, startAngle, sweepAngle)));
+    public void FillArc(Brush brush, PointF center, SizeF radius, float rotation, float startAngle, float sweepAngle)
+        => this.Fill(brush, new Path(new ArcLineSegment(center, radius, rotation, startAngle, sweepAngle)));
 
     /// <summary>
     /// Fills a pie sector using the provided brush.
     /// </summary>
-    /// <param name="canvas">The destination canvas.</param>
     /// <param name="brush">Brush used to shade covered pixels.</param>
     /// <param name="center">Pie center point in local coordinates.</param>
     /// <param name="radius">Pie radii in local coordinates.</param>
     /// <param name="rotation">Ellipse rotation in degrees.</param>
     /// <param name="startAngle">Pie start angle in degrees.</param>
     /// <param name="sweepAngle">Pie sweep angle in degrees.</param>
-    public static void FillPie(this DrawingCanvas canvas, Brush brush, PointF center, SizeF radius, float rotation, float startAngle, float sweepAngle)
-        => canvas.Fill(brush, new Pie(center, radius, rotation, startAngle, sweepAngle));
+    public void FillPie(Brush brush, PointF center, SizeF radius, float rotation, float startAngle, float sweepAngle)
+        => this.Fill(brush, new Pie(center, radius, rotation, startAngle, sweepAngle));
 
     /// <summary>
     /// Fills a pie sector using the provided brush.
     /// </summary>
-    /// <param name="canvas">The destination canvas.</param>
     /// <param name="brush">Brush used to shade covered pixels.</param>
     /// <param name="center">Pie center point in local coordinates.</param>
     /// <param name="radius">Pie radii in local coordinates.</param>
     /// <param name="startAngle">Pie start angle in degrees.</param>
     /// <param name="sweepAngle">Pie sweep angle in degrees.</param>
-    public static void FillPie(this DrawingCanvas canvas, Brush brush, PointF center, SizeF radius, float startAngle, float sweepAngle)
-        => canvas.Fill(brush, new Pie(center, radius, startAngle, sweepAngle));
+    public void FillPie(Brush brush, PointF center, SizeF radius, float startAngle, float sweepAngle)
+        => this.Fill(brush, new Pie(center, radius, startAngle, sweepAngle));
 
     /// <summary>
     /// Draws an arc outline using the provided pen.
     /// </summary>
-    /// <param name="canvas">The destination canvas.</param>
     /// <param name="pen">Pen used to generate the arc outline.</param>
     /// <param name="center">Arc center point in local coordinates.</param>
     /// <param name="radius">Arc radii in local coordinates.</param>
     /// <param name="rotation">Ellipse rotation in degrees.</param>
     /// <param name="startAngle">Arc start angle in degrees.</param>
     /// <param name="sweepAngle">Arc sweep angle in degrees.</param>
-    public static void DrawArc(this DrawingCanvas canvas, Pen pen, PointF center, SizeF radius, float rotation, float startAngle, float sweepAngle)
-        => canvas.Draw(pen, new Path(new ArcLineSegment(center, radius, rotation, startAngle, sweepAngle)));
+    public void DrawArc(Pen pen, PointF center, SizeF radius, float rotation, float startAngle, float sweepAngle)
+        => this.Draw(pen, new Path(new ArcLineSegment(center, radius, rotation, startAngle, sweepAngle)));
 
     /// <summary>
     /// Draws a cubic bezier outline using the provided pen.
     /// </summary>
-    /// <param name="canvas">The destination canvas.</param>
     /// <param name="pen">Pen used to generate the bezier outline.</param>
     /// <param name="points">Bezier control points.</param>
-    public static void DrawBezier(this DrawingCanvas canvas, Pen pen, params PointF[] points)
+    public void DrawBezier(Pen pen, params PointF[] points)
     {
         Guard.NotNull(points, nameof(points));
-        canvas.Draw(pen, new Path(new CubicBezierLineSegment(points)));
+
+        this.Draw(pen, new Path(new CubicBezierLineSegment(points)));
     }
 
     /// <summary>
     /// Draws an ellipse outline using the provided pen.
     /// </summary>
-    /// <param name="canvas">The destination canvas.</param>
     /// <param name="pen">Pen used to generate the ellipse outline.</param>
     /// <param name="center">Ellipse center point in local coordinates.</param>
     /// <param name="size">Ellipse width and height in local coordinates.</param>
-    public static void DrawEllipse(this DrawingCanvas canvas, Pen pen, PointF center, SizeF size)
-        => canvas.Draw(pen, new EllipsePolygon(center, size));
+    public void DrawEllipse(Pen pen, PointF center, SizeF size)
+        => this.Draw(pen, new EllipsePolygon(center, size));
 
     /// <summary>
     /// Draws a pie sector outline using the provided pen.
     /// </summary>
-    /// <param name="canvas">The destination canvas.</param>
     /// <param name="pen">Pen used to generate the pie outline.</param>
     /// <param name="center">Pie center point in local coordinates.</param>
     /// <param name="radius">Pie radii in local coordinates.</param>
     /// <param name="rotation">Ellipse rotation in degrees.</param>
     /// <param name="startAngle">Pie start angle in degrees.</param>
     /// <param name="sweepAngle">Pie sweep angle in degrees.</param>
-    public static void DrawPie(this DrawingCanvas canvas, Pen pen, PointF center, SizeF radius, float rotation, float startAngle, float sweepAngle)
-        => canvas.Draw(pen, new Pie(center, radius, rotation, startAngle, sweepAngle));
+    public void DrawPie(Pen pen, PointF center, SizeF radius, float rotation, float startAngle, float sweepAngle)
+        => this.Draw(pen, new Pie(center, radius, rotation, startAngle, sweepAngle));
 
     /// <summary>
     /// Draws a pie sector outline using the provided pen.
     /// </summary>
-    /// <param name="canvas">The destination canvas.</param>
     /// <param name="pen">Pen used to generate the pie outline.</param>
     /// <param name="center">Pie center point in local coordinates.</param>
     /// <param name="radius">Pie radii in local coordinates.</param>
     /// <param name="startAngle">Pie start angle in degrees.</param>
     /// <param name="sweepAngle">Pie sweep angle in degrees.</param>
-    public static void DrawPie(this DrawingCanvas canvas, Pen pen, PointF center, SizeF radius, float startAngle, float sweepAngle)
-        => canvas.Draw(pen, new Pie(center, radius, startAngle, sweepAngle));
+    public void DrawPie(Pen pen, PointF center, SizeF radius, float startAngle, float sweepAngle)
+        => this.Draw(pen, new Pie(center, radius, startAngle, sweepAngle));
 
     /// <summary>
     /// Draws a rectangular outline using the provided pen.
     /// </summary>
-    /// <param name="canvas">The destination canvas.</param>
     /// <param name="pen">Pen used to generate the rectangle outline.</param>
     /// <param name="region">Rectangle region to stroke.</param>
-    public static void Draw(this DrawingCanvas canvas, Pen pen, Rectangle region)
-        => canvas.Draw(pen, new RectangularPolygon(region));
+    public void Draw(Pen pen, Rectangle region)
+        => this.Draw(pen, new RectangularPolygon(region));
 
     /// <summary>
     /// Draws all paths in a collection using the provided pen.
     /// </summary>
-    /// <param name="canvas">The destination canvas.</param>
     /// <param name="pen">Pen used to generate outlines.</param>
     /// <param name="paths">Path collection to stroke.</param>
-    public static void Draw(this DrawingCanvas canvas, Pen pen, IPathCollection paths)
+    public void Draw(Pen pen, IPathCollection paths)
     {
         Guard.NotNull(paths, nameof(paths));
 
         foreach (IPath path in paths)
         {
-            canvas.Draw(pen, path);
+            this.Draw(pen, path);
         }
     }
 
     /// <summary>
     /// Draws a path outline built by the provided builder using the given pen.
     /// </summary>
-    /// <param name="canvas">The destination canvas.</param>
     /// <param name="pen">Pen used to generate the outline fill path.</param>
     /// <param name="pathBuilder">The path builder describing the path to stroke.</param>
-    public static void Draw(this DrawingCanvas canvas, Pen pen, PathBuilder pathBuilder)
+    public void Draw(Pen pen, PathBuilder pathBuilder)
     {
         Guard.NotNull(pathBuilder, nameof(pathBuilder));
-        canvas.Draw(pen, pathBuilder.Build());
+
+        this.Draw(pen, pathBuilder.Build());
     }
 }

src/ImageSharp.Drawing/Processing/DrawingCanvas.cs

@@ -11,7 +11,7 @@ namespace SixLabors.ImageSharp.Drawing.Processing;
 /// <summary>
 /// Represents a drawing canvas over a frame target.
 /// </summary>
-public abstract class DrawingCanvas : IDisposable
+public abstract partial class DrawingCanvas : IDisposable
 {
     /// <summary>
     /// Gets the local bounds of this canvas.