A bunch more shape stuff

Author: bbrk24

Sources/SwiftCrossUI/Backend/AppBackend.swift

@@ -544,8 +544,16 @@ public protocol AppBackend {
     ///   - path: The path to be rendered.
     ///   - container: The container widget that the path will render in. It has no other
     ///     children.
-    ///   - environment: The environment values, including color.
-    func renderPath(_ path: Path, container: Widget, environment: EnvironmentValues)
+    ///   - strokeColor: The color to draw the path's stroke.
+    ///   - fillColor: The color to shade the path's fill.
+    ///   - overrideStrokeStyle: If present, a value to override the path's stroke style.
+    func renderPath(
+        _ path: Path,
+        container: Widget,
+        strokeColor: Color,
+        fillColor: Color,
+        overrideStrokeStyle: StrokeStyle?
+    )
 }
 
 extension AppBackend {
@@ -870,7 +878,13 @@ extension AppBackend {
     func updatePath(_ path: Path, _ source: SwiftCrossUI.Path, pointsChanged: Bool) {
         todo()
     }
-    func renderPath(_ path: Path, container: Widget, environment: EnvironmentValues) {
+    func renderPath(
+        _ path: Path,
+        container: Widget,
+        strokeColor: Color,
+        fillColor: Color,
+        overrideStrokeStyle: StrokeStyle?
+    ) {
         todo()
     }
 }

Sources/SwiftCrossUI/Path.swift

@@ -20,11 +20,15 @@ public enum StrokeJoin {
 }
 
 public struct StrokeStyle {
-    public var width: Double = 1.0
-    public var cap: StrokeCap = .butt
-    public var join: StrokeJoin = .miter(limit: 10.0)
-
-    public static let none = StrokeStyle(width: 0.0)
+    public var width: Double
+    public var cap: StrokeCap
+    public var join: StrokeJoin
+
+    public init(width: Double, cap: StrokeCap = .butt, join: StrokeJoin = .miter(limit: 10.0)) {
+        self.width = width
+        self.cap = cap
+        self.join = join
+    }
 }
 
 /// An enum describing how a path is shaded.
@@ -181,6 +185,8 @@ public struct Path {
         public var width: Double { size.x }
         public var height: Double { size.y }
 
+        public var center: SIMD2<Double> { size * 0.5 + origin }
+
         public init(x: Double, y: Double, width: Double, height: Double) {
             origin = SIMD2(x: x, y: y)
             size = SIMD2(x: width, y: height)
@@ -203,7 +209,7 @@ public struct Path {
             clockwise: Bool
         )
         case transform(AffineTransform)
-        //        case subpath([Action], FillRule)
+        case subpath([Action], FillRule)
     }
 
     /// A list of every action that has been performed on this path.
@@ -214,7 +220,7 @@ public struct Path {
     /// to each action.
     public private(set) var actions: [Action] = []
     public private(set) var fillRule: FillRule = .evenOdd
-    public private(set) var strokeStyle: StrokeStyle = .none
+    public private(set) var strokeStyle = StrokeStyle(width: 1.0)
 
     public init() {}
 
@@ -274,11 +280,16 @@ public struct Path {
         return self
     }
 
-    public consuming func transform(_ transform: AffineTransform) -> Path {
+    public consuming func applyTransform(_ transform: AffineTransform) -> Path {
         actions.append(.transform(transform))
         return self
     }
 
+    public consuming func addSubpath(_ subpath: Path) -> Path {
+        actions.append(.subpath(subpath.actions, subpath.fillRule))
+        return self
+    }
+
     public consuming func stroke(style: StrokeStyle) -> Path {
         strokeStyle = style
         return self

Sources/SwiftCrossUI/Views/Shapes/Capsule.swift

@@ -0,0 +1,51 @@
+public struct Capsule: Shape {
+    public init() {}
+
+    public func path(in bounds: Path.Rect) -> Path {
+        if bounds.width > bounds.height {
+            let radius = bounds.height / 2.0
+
+            return Path()
+                .move(to: SIMD2(x: bounds.width + bounds.x - radius, y: bounds.y))
+                .addArc(
+                    center: SIMD2(x: bounds.width + bounds.x - radius, y: bounds.center.y),
+                    radius: radius,
+                    startAngle: .pi * 1.5,
+                    endAngle: .pi * 0.5,
+                    clockwise: true
+                )
+                .addLine(to: SIMD2(x: radius + bounds.x, y: bounds.height + bounds.y))
+                .addArc(
+                    center: SIMD2(x: radius + bounds.x, y: bounds.center.y),
+                    radius: radius,
+                    startAngle: .pi * 0.5,
+                    endAngle: .pi * 1.5,
+                    clockwise: true
+                )
+                .addLine(to: SIMD2(x: bounds.width + bounds.x - radius, y: bounds.y))
+        } else if bounds.width < bounds.height {
+            let radius = bounds.width / 2.0
+
+            return Path()
+                .move(to: SIMD2(x: bounds.x, y: bounds.height + bounds.y - radius))
+                .addArc(
+                    center: SIMD2(x: bounds.center.x, y: bounds.height + bounds.y - radius),
+                    radius: radius,
+                    startAngle: .pi,
+                    endAngle: 0.0,
+                    clockwise: false
+                )
+                .addLine(to: SIMD2(x: bounds.width + bounds.x, y: radius + bounds.y))
+                .addArc(
+                    center: SIMD2(x: bounds.center.x, y: radius + bounds.y),
+                    radius: radius,
+                    startAngle: 0.0,
+                    endAngle: .pi,
+                    clockwise: false
+                )
+                .addLine(to: SIMD2(x: bounds.x, y: bounds.height + bounds.y - radius))
+        } else {
+            return Circle().path(in: bounds)
+        }
+    }
+}

Sources/SwiftCrossUI/Views/Shapes/Circle.swift

@@ -2,14 +2,22 @@ public struct Circle: Shape {
     public init() {}
 
     public func path(in bounds: Path.Rect) -> Path {
-        Path().addCircle(
-            center: SIMD2(x: bounds.x + bounds.width / 2.0, y: bounds.y + bounds.height / 2.0),
-            radius: min(bounds.width, bounds.height) / 2.0
-        )
+        Path()
+            .addCircle(center: bounds.center, radius: min(bounds.width, bounds.height) / 2.0)
     }
 
-    public func size(fitting proposal: SIMD2<Int>) -> SIMD2<Int> {
-        let minDim = min(proposal.x, proposal.y)
-        return SIMD2(x: minDim, y: minDim)
+    public func size(fitting proposal: SIMD2<Int>) -> ViewSize {
+        let diameter = min(proposal.x, proposal.y)
+
+        return ViewSize(
+            size: SIMD2(x: diameter, y: diameter),
+            idealSize: SIMD2(x: 10, y: 10),
+            idealWidthForProposedHeight: proposal.y,
+            idealHeightForProposedWidth: proposal.x,
+            minimumWidth: 1,
+            minimumHeight: 1,
+            maximumWidth: nil,
+            maximumHeight: nil
+        )
     }
 }

Sources/SwiftCrossUI/Views/Shapes/Ellipse.swift

@@ -0,0 +1,19 @@
+public struct Ellipse: Shape {
+    public init() {}
+
+    public func path(in bounds: Path.Rect) -> Path {
+        Path()
+            .addCircle(center: .zero, radius: bounds.width / 2.0)
+            .applyTransform(
+                AffineTransform(
+                    linearTransform: SIMD4(
+                        x: 1.0,
+                        y: 0.0,
+                        z: 0.0,
+                        w: bounds.height / bounds.width
+                    ),
+                    translation: bounds.center
+                )
+            )
+    }
+}

Sources/SwiftCrossUI/Views/Shapes/Shape.swift

@@ -4,15 +4,30 @@ where Content == EmptyView {
     func path(in bounds: Path.Rect) -> Path
     /// Determine the ideal size of this shape given the proposed bounds.
     ///
-    /// The default implementation returns the proposal unmodified.
-    func size(fitting proposal: SIMD2<Int>) -> SIMD2<Int>
+    /// The default implementation accepts the proposal and imposes no practical limit on
+    /// the shape's size.
+    /// - Returns: Information about the shape's size. The ``ViewSize/size`` property is what
+    ///   frame the shape will actually be rendered with if the current layout pass is not
+    ///   a dry run, while the other properties are used to inform the layout engine how big
+    ///   or small the shape can be. The ``ViewSize/idealSize`` property should not vary with
+    ///   the `proposal`, and should only depend on the view's contents. Pass `nil` for the
+    ///   maximum width/height if the shape has no maximum size (and therefore may occupy
+    ///   the entire screen).
+    func size(fitting proposal: SIMD2<Int>) -> ViewSize
 }
 
 extension Shape {
     public var body: EmptyView { return EmptyView() }
 
-    public func size(fitting proposal: SIMD2<Int>) -> SIMD2<Int> {
-        return proposal
+    public func size(fitting proposal: SIMD2<Int>) -> ViewSize {
+        return ViewSize(
+            size: proposal,
+            idealSize: SIMD2(x: 10, y: 10),
+            minimumWidth: 1,
+            minimumHeight: 1,
+            maximumWidth: nil,
+            maximumHeight: nil
+        )
     }
 
     public func children<Backend: AppBackend>(
@@ -41,28 +56,27 @@ extension Shape {
         let size = size(fitting: proposedSize)
 
         let path = path(
-            in: Path.Rect(x: 0.0, y: 0.0, width: Double(size.x), height: Double(size.y)))
+            in: Path.Rect(x: 0.0, y: 0.0, width: Double(size.size.x), height: Double(size.size.y))
+        )
+
         let pointsChanged = storage.oldPath?.actions != path.actions
         storage.oldPath = path
 
         let backendPath = storage.backendPath as! Backend.Path
         backend.updatePath(backendPath, path, pointsChanged: pointsChanged)
 
         if !dryRun {
-            backend.setSize(of: widget, to: size)
-            backend.renderPath(backendPath, container: widget, environment: environment)
+            backend.setSize(of: widget, to: size.size)
+            backend.renderPath(
+                backendPath,
+                container: widget,
+                strokeColor: .clear,
+                fillColor: environment.suggestedForegroundColor,
+                overrideStrokeStyle: nil
+            )
         }
 
-        return ViewUpdateResult.leafView(
-            size: ViewSize(
-                size: size,
-                idealSize: SIMD2(x: 10, y: 10),
-                minimumWidth: 0,
-                minimumHeight: 0,
-                maximumWidth: nil,
-                maximumHeight: nil
-            )
-        )
+        return ViewUpdateResult.leafView(size: size)
     }
 }
 

Sources/SwiftCrossUI/Views/Shapes/StyledShape.swift

@@ -0,0 +1,80 @@
+public protocol StyledShape: Shape {
+    var strokeColor: Color? { get }
+    var fillColor: Color? { get }
+    var strokeStyle: StrokeStyle? { get }
+}
+
+struct StyledShapeImpl<Base: Shape>: StyledShape {
+    var base: Base
+    var strokeColor: Color?
+    var fillColor: Color?
+    var strokeStyle: StrokeStyle?
+
+    init(
+        base: Base, strokeColor: Color? = nil, fillColor: Color? = nil,
+        strokeStyle: StrokeStyle? = nil
+    ) {
+        self.base = base
+
+        if let styledBase = base as? any StyledShape {
+            self.strokeColor = strokeColor ?? styledBase.strokeColor
+            self.fillColor = fillColor ?? styledBase.fillColor
+            self.strokeStyle = strokeStyle ?? styledBase.strokeStyle
+        } else {
+            self.strokeColor = strokeColor
+            self.fillColor = fillColor
+            self.strokeStyle = strokeStyle
+        }
+    }
+
+    func path(in bounds: Path.Rect) -> Path {
+        return base.path(in: bounds)
+    }
+
+    func size(fitting proposal: SIMD2<Int>) -> ViewSize {
+        return base.size(fitting: proposal)
+    }
+}
+
+extension Shape {
+    public func fill(_ color: Color) -> some StyledShape {
+        StyledShapeImpl(base: self, fillColor: color)
+    }
+
+    public func stroke(_ color: Color, style: StrokeStyle? = nil) -> some StyledShape {
+        StyledShapeImpl(base: self, strokeColor: color, strokeStyle: style)
+    }
+}
+
+extension StyledShape {
+    public func update<Backend: AppBackend>(
+        _ widget: Backend.Widget, children: any ViewGraphNodeChildren, proposedSize: SIMD2<Int>,
+        environment: EnvironmentValues, backend: Backend, dryRun: Bool
+    ) -> ViewUpdateResult {
+        let storage = children as! ShapeStorage
+        let size = size(fitting: proposedSize)
+
+        let path = path(
+            in: Path.Rect(x: 0.0, y: 0.0, width: Double(size.size.x), height: Double(size.size.y))
+        )
+
+        let pointsChanged = storage.oldPath?.actions != path.actions
+        storage.oldPath = path
+
+        let backendPath = storage.backendPath as! Backend.Path
+        backend.updatePath(backendPath, path, pointsChanged: pointsChanged)
+
+        if !dryRun {
+            backend.setSize(of: widget, to: size.size)
+            backend.renderPath(
+                backendPath,
+                container: widget,
+                strokeColor: strokeColor ?? .clear,
+                fillColor: fillColor ?? .clear,
+                overrideStrokeStyle: strokeStyle
+            )
+        }
+
+        return ViewUpdateResult.leafView(size: size)
+    }
+}

Sources/UIKitBackend/UIColor+Color.swift

@@ -27,4 +27,9 @@ extension Color {
     var uiColor: UIColor {
         UIColor(color: self)
     }
+
+    var cgColor: CGColor {
+        CGColor(
+            red: CGFloat(red), green: CGFloat(green), blue: CGFloat(blue), alpha: CGFloat(alpha))
+    }
 }