Use new SizeProposal type instead of SIMD2<Int> in View.computeLayout

This makes it possible to request ideal sizing without calling
computeLayout twice.

Author: stackotter

Sources/AppKitBackend/AppKitBackend.swift

@@ -35,7 +35,6 @@ public final class AppKitBackend: AppBackend {
                 scrollerStyle: NSScroller.preferredScrollerStyle
             ).rounded(.awayFromZero)
         )
-        print(result)
         return result
     }
 

Sources/AppKitBackend/NSViewRepresentable.swift

@@ -142,22 +142,27 @@ extension View where Self: NSViewRepresentable {
     public func computeLayout<Backend: AppBackend>(
         _ widget: Backend.Widget,
         children: any ViewGraphNodeChildren,
-        proposedSize: SIMD2<Int>,
+        proposedSize: SizeProposal,
         environment: EnvironmentValues,
-        backend: Backend
+        backend _: Backend
     ) -> ViewLayoutResult {
-        guard backend is AppKitBackend else {
-            fatalError("NSViewRepresentable updated by \(Backend.self)")
-        }
-
+        // We update the underlying view in computeLayout because we don't expect
+        // UIViews to have their layout computations decoupled from their content.
         let representingWidget = widget as! RepresentingWidget<Self>
         representingWidget.update(with: environment)
 
-        let size = representingWidget.representable.determineViewSize(
-            for: proposedSize,
+        // TODO: Pass size proposal through to XRepresentable views
+        var size = representingWidget.representable.determineViewSize(
+            for: proposedSize.evaluated(withIdealSize: SIMD2(10, 10)),
             nsView: representingWidget.subview,
             context: representingWidget.context!
         )
+        if proposedSize.width == nil {
+            size.size.x = size.idealWidthForProposedHeight
+        }
+        if proposedSize.height == nil {
+            size.size.y = size.idealHeightForProposedWidth
+        }
 
         return ViewLayoutResult.leafView(size: size)
     }

Sources/SwiftCrossUI/Environment/EnvironmentValues.swift

@@ -79,13 +79,12 @@ public struct EnvironmentValues {
             backend.activate(window: window as! Backend.Window)
         }
         activate(with: backend)
-        print("Activated")
     }
 
     /// The backend's representation of the window that the current view is
     /// in, if any. This is a very internal detail that should never get
     /// exposed to users.
-    package var window: Any?
+    public var window: Any?
     /// The backend in use. Mustn't change throughout the app's lifecycle.
     let backend: any AppBackend
 
@@ -147,7 +146,7 @@ public struct EnvironmentValues {
     }
 
     /// Creates the default environment.
-    init<Backend: AppBackend>(backend: Backend) {
+    public init<Backend: AppBackend>(backend: Backend) {
         self.backend = backend
 
         onResize = { _ in }

Sources/SwiftCrossUI/Layout/LayoutSystem.swift

@@ -1,3 +1,5 @@
+import Foundation
+
 public enum LayoutSystem {
     static func width(forHeight height: Int, aspectRatio: Double) -> Int {
         roundSize(Double(height) * aspectRatio)
@@ -11,6 +13,18 @@ public enum LayoutSystem {
         Int(size.rounded(.towardZero))
     }
 
+    /// Clamps a value to a range given optional lower and upper bounds.
+    static func clamp<T: Comparable>(_ value: T, minimum: T? = nil, maximum: T? = nil) -> T {
+        var value = value
+        if let minimum {
+            value = max(value, minimum)
+        }
+        if let maximum {
+            value = min(value, maximum)
+        }
+        return value
+    }
+
     static func aspectRatio(of frame: SIMD2<Double>) -> Double {
         if frame.x == 0 || frame.y == 0 {
             // Even though we could technically compute an aspect ratio when the
@@ -47,14 +61,14 @@ public enum LayoutSystem {
     public struct LayoutableChild {
         private var computeLayout:
             (
-                _ proposedSize: SIMD2<Int>,
+                _ proposedSize: SizeProposal,
                 _ environment: EnvironmentValues
             ) -> ViewLayoutResult
         private var _commit: () -> ViewLayoutResult
         var tag: String?
 
         public init(
-            computeLayout: @escaping (SIMD2<Int>, EnvironmentValues) -> ViewLayoutResult,
+            computeLayout: @escaping (SizeProposal, EnvironmentValues) -> ViewLayoutResult,
             commit: @escaping () -> ViewLayoutResult,
             tag: String? = nil
         ) {
@@ -64,7 +78,7 @@ public enum LayoutSystem {
         }
 
         public func computeLayout(
-            proposedSize: SIMD2<Int>,
+            proposedSize: SizeProposal,
             environment: EnvironmentValues,
             dryRun: Bool = false
         ) -> ViewLayoutResult {
@@ -84,7 +98,7 @@ public enum LayoutSystem {
     public static func computeStackLayout<Backend: AppBackend>(
         container: Backend.Widget,
         children: [LayoutableChild],
-        proposedSize: SIMD2<Int>,
+        proposedSize: SizeProposal,
         environment: EnvironmentValues,
         backend: Backend,
         inheritStackLayoutParticipation: Bool = false
@@ -103,7 +117,7 @@ public enum LayoutSystem {
         var isHidden = [Bool](repeating: false, count: children.count)
         let flexibilities = children.enumerated().map { i, child in
             let result = child.computeLayout(
-                proposedSize: proposedSize,
+                proposedSize: .ideal,
                 environment: environment
             )
             isHidden[i] = !result.participatesInStackLayouts
@@ -118,11 +132,19 @@ public enum LayoutSystem {
             !hidden
         }.count
         let totalSpacing = max(visibleChildrenCount - 1, 0) * spacing
-        let sortedChildren = zip(children.enumerated(), flexibilities)
-            .sorted { first, second in
-                first.1 <= second.1
-            }
-            .map(\.0)
+
+        let sortedChildren: [(offset: Int, element: LayoutSystem.LayoutableChild)]
+        if orientation == .vertical && proposedSize.height == nil
+            || orientation == .horizontal && proposedSize.width == nil
+        {
+            sortedChildren = Array(children.enumerated())
+        } else {
+            sortedChildren = zip(children.enumerated(), flexibilities)
+                .sorted { first, second in
+                    first.1 <= second.1
+                }
+                .map(\.0)
+        }
 
         var spaceUsedAlongStackAxis = 0
         var childrenRemaining = visibleChildrenCount
@@ -149,25 +171,35 @@ public enum LayoutSystem {
                 continue
             }
 
-            let proposedWidth: Double
-            let proposedHeight: Double
+            let proposedWidth: Double?
+            let proposedHeight: Double?
             switch orientation {
                 case .horizontal:
-                    proposedWidth =
-                        Double(max(proposedSize.x - spaceUsedAlongStackAxis - totalSpacing, 0))
-                        / Double(childrenRemaining)
-                    proposedHeight = Double(proposedSize.y)
+                    if let parentProposedWidth = proposedSize.width {
+                        proposedWidth = Double(max(
+                            parentProposedWidth - spaceUsedAlongStackAxis - totalSpacing,
+                            0
+                        )) / Double(childrenRemaining)
+                    } else {
+                        proposedWidth = nil
+                    }
+                    proposedHeight = proposedSize.height.map(Double.init)
                 case .vertical:
-                    proposedHeight =
-                        Double(max(proposedSize.y - spaceUsedAlongStackAxis - totalSpacing, 0))
-                        / Double(childrenRemaining)
-                    proposedWidth = Double(proposedSize.x)
+                    if let parentProposedHeight = proposedSize.height {
+                        proposedHeight = Double(max(
+                            parentProposedHeight - spaceUsedAlongStackAxis - totalSpacing,
+                            0
+                        )) / Double(childrenRemaining)
+                    } else {
+                        proposedHeight = nil
+                    }
+                    proposedWidth = proposedSize.width.map(Double.init)
             }
 
             let childResult = child.computeLayout(
-                proposedSize: SIMD2<Int>(
-                    Int(proposedWidth.rounded(.towardZero)),
-                    Int(proposedHeight.rounded(.towardZero))
+                proposedSize: SizeProposal(
+                    proposedWidth.map { Int($0.rounded(.towardZero)) },
+                    proposedHeight.map { Int($0.rounded(.towardZero)) }
                 ),
                 environment: environment
             )

Sources/SwiftCrossUI/Layout/SizeProposal.swift

@@ -0,0 +1,46 @@
+/// A proposed view size. Uses `nil` to indicate when the ideal size should
+/// be used along a given axis.
+public struct SizeProposal: Hashable {
+    /// An empty proposal.
+    public static let zero = Self(0, 0)
+
+    /// A proposal for the view to take on its ideal size.
+    static let ideal = Self(nil, nil)
+
+    /// The proposed width. If `nil`, the view should take on its ideal
+    /// width for the proposed height.
+    public var width: Int?
+    /// The proposed height. If `nil`, the view should take on its ideal
+    /// height for the proposed width.
+    public var height: Int?
+
+    /// The proposal as a concrete size if both dimensions are non-nil,
+    /// otherwise nil.
+    var concrete: SIMD2<Int>? {
+        guard let width, let height else {
+            return nil
+        }
+        return SIMD2(width, height)
+    }
+
+    /// Creates a new size proposal. Use `nil` for dimensions that the view
+    /// should take on its ideal size along.
+    public init(_ width: Int?, _ height: Int?) {
+        self.width = width
+        self.height = height
+    }
+
+    /// Creates a new size proposal from a concrete size.
+    public init(_ size: SIMD2<Int>) {
+        self.width = size.x
+        self.height = size.y
+    }
+
+    /// Evaluates the size proposal with a view's ideal size.
+    package func evaluated(withIdealSize idealSize: SIMD2<Int>) -> SIMD2<Int> {
+        SIMD2(
+            width ?? idealSize.x,
+            height ?? idealSize.y
+        )
+    }
+}

Sources/SwiftCrossUI/State/State.swift

@@ -91,7 +91,8 @@ public struct State<Value>: DynamicProperty, StateProperty {
         // to protocol Optional doesn't conform to can still succeed when the value
         // is `.some` and the wrapped type conforms to the protocol.
         if Value.self as? ObservableObject.Type != nil,
-            let initialValue = initialValue as? ObservableObject {
+            let initialValue = initialValue as? ObservableObject
+        {
             storage.box.downstreamObservation = didChange.link(toUpstream: initialValue.didChange)
         } else if let initialValue = initialValue as? OptionalObservableObject,
             let innerDidChange = initialValue.didChange

Sources/SwiftCrossUI/Values/Color.swift

@@ -71,14 +71,15 @@ extension Color: ElementaryView {
 
     func computeLayout<Backend: AppBackend>(
         _ widget: Backend.Widget,
-        proposedSize: SIMD2<Int>,
+        proposedSize: SizeProposal,
         environment: EnvironmentValues,
         backend: Backend
     ) -> ViewLayoutResult {
-        ViewLayoutResult.leafView(
+        let idealSize = SIMD2(10, 10)
+        return ViewLayoutResult.leafView(
             size: ViewSize(
-                size: proposedSize,
-                idealSize: SIMD2(10, 10),
+                size: proposedSize.evaluated(withIdealSize: idealSize),
+                idealSize: idealSize,
                 minimumWidth: 0,
                 minimumHeight: 0,
                 maximumWidth: nil,

Sources/SwiftCrossUI/ViewGraph/AnyViewGraphNode.swift

@@ -15,7 +15,7 @@ public class AnyViewGraphNode<NodeView: View> {
     private var _computeLayoutWithNewView:
         (
             _ newView: NodeView?,
-            _ proposedSize: SIMD2<Int>,
+            _ proposedSize: SizeProposal,
             _ environment: EnvironmentValues
         ) -> ViewLayoutResult
     /// The node's type-erased commit method.
@@ -69,7 +69,7 @@ public class AnyViewGraphNode<NodeView: View> {
     /// the given size proposal already has a cached result.
     public func computeLayout(
         with newView: NodeView?,
-        proposedSize: SIMD2<Int>,
+        proposedSize: SizeProposal,
         environment: EnvironmentValues
     ) -> ViewLayoutResult {
         _computeLayoutWithNewView(newView, proposedSize, environment)

Sources/SwiftCrossUI/ViewGraph/ErasedViewGraphNode.swift

@@ -10,7 +10,7 @@ public struct ErasedViewGraphNode {
     public var computeLayoutWithNewView:
         (
             _ newView: Any?,
-            _ proposedSize: SIMD2<Int>,
+            _ proposedSize: SizeProposal,
             _ environment: EnvironmentValues
         ) -> (viewTypeMatched: Bool, size: ViewLayoutResult)
     /// The underlying view graph node's commit method.

Sources/SwiftCrossUI/ViewGraph/ViewGraph.swift

@@ -62,7 +62,7 @@ public class ViewGraph<Root: View> {
         if dryRun {
             result = rootNode.computeLayout(
                 with: newView ?? view,
-                proposedSize: proposedSize,
+                proposedSize: SizeProposal(proposedSize),
                 environment: parentEnvironment
             )
         } else {