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

@@ -36,7 +36,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

@@ -118,13 +118,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
 
@@ -192,7 +191,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,15 +61,20 @@ public enum LayoutSystem {
     public struct LayoutableChild {
         private var computeLayout:
             @MainActor (
-                _ proposedSize: SIMD2<Int>,
+                _ proposedSize: SizeProposal,
                 _ environment: EnvironmentValues
             ) -> ViewLayoutResult
+
         private var _commit: @MainActor () -> ViewLayoutResult
+
         var tag: String?
 
         public init(
-            computeLayout: @escaping @MainActor (SIMD2<Int>, EnvironmentValues) -> ViewLayoutResult,
-            commit: @escaping @MainActor () -> ViewLayoutResult,
+            computeLayout: @escaping @MainActor (
+                SizeProposal,
+                EnvironmentValues
+            ) -> ViewLayoutResult,
+            commit: @escaping () -> ViewLayoutResult,
             tag: String? = nil
         ) {
             self.computeLayout = computeLayout
@@ -65,7 +84,7 @@ public enum LayoutSystem {
 
         @MainActor
         public func computeLayout(
-            proposedSize: SIMD2<Int>,
+            proposedSize: SizeProposal,
             environment: EnvironmentValues,
             dryRun: Bool = false
         ) -> ViewLayoutResult {
@@ -87,7 +106,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
@@ -106,7 +125,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
@@ -121,11 +140,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
@@ -152,25 +179,39 @@ 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, Sendable {
+    /// 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/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

@@ -16,7 +16,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.
@@ -70,7 +70,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

@@ -11,7 +11,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

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

Sources/SwiftCrossUI/ViewGraph/ViewGraphNode.swift

@@ -40,10 +40,10 @@ public class ViewGraphNode<NodeView: View, Backend: AppBackend>: Sendable {
     public var currentLayout: ViewLayoutResult?
     /// A cache of update results keyed by the proposed size they were for. Gets cleared before the
     /// results' sizes become invalid.
-    var resultCache: [SIMD2<Int>: ViewLayoutResult]
+    var resultCache: [SizeProposal: ViewLayoutResult]
     /// The most recent size proposed by the parent view. Used when updating the wrapped
     /// view as a result of a state change rather than the parent view updating.
-    private var lastProposedSize: SIMD2<Int>
+    private var lastProposedSize: SizeProposal
 
     /// A cancellable handle to the view's state property observations.
     private var cancellables: [Cancellable]
@@ -164,7 +164,7 @@ public class ViewGraphNode<NodeView: View, Backend: AppBackend>: Sendable {
     /// state.
     public func computeLayout(
         with newView: NodeView? = nil,
-        proposedSize: SIMD2<Int>,
+        proposedSize: SizeProposal,
         environment: EnvironmentValues
     ) -> ViewLayoutResult {
         // Defensively ensure that all future scene implementations obey this
@@ -189,15 +189,29 @@ public class ViewGraphNode<NodeView: View, Backend: AppBackend>: Sendable {
         // current view state.
         if let currentLayout, !resultCache.isEmpty {
             // If both the previous and current proposed sizes are larger than
-            // the view's previously computed maximum size, reuse the previous
-            // result (currentResult).
-            if ((Double(lastProposedSize.x) >= currentLayout.size.maximumWidth
-                && Double(proposedSize.x) >= currentLayout.size.maximumWidth)
-                || proposedSize.x == lastProposedSize.x)
-                && ((Double(lastProposedSize.y) >= currentLayout.size.maximumHeight
-                    && Double(proposedSize.y) >= currentLayout.size.maximumHeight)
-                    || proposedSize.y == lastProposedSize.y)
+            // the view's previously computed maximum size or equal to each other,
+            // reuse the previous result (currentResult).
+            var isHorizontalCacheHit = lastProposedSize.width == proposedSize.width
+            if !isHorizontalCacheHit,
+                let lastProposedWidth = lastProposedSize.width,
+                let proposedWidth = proposedSize.width
             {
+                isHorizontalCacheHit =
+                    (Double(lastProposedWidth) >= currentLayout.size.maximumWidth
+                        && Double(proposedWidth) >= currentLayout.size.maximumWidth)
+            }
+
+            var isVerticalCacheHit = lastProposedSize.height == proposedSize.height
+            if !isVerticalCacheHit,
+                let lastProposedHeight = lastProposedSize.height,
+                let proposedHeight = proposedSize.height
+            {
+                isVerticalCacheHit =
+                    (Double(lastProposedHeight) >= currentLayout.size.maximumHeight
+                        && Double(proposedHeight) >= currentLayout.size.maximumHeight)
+            }
+
+            if isHorizontalCacheHit && isVerticalCacheHit {
                 return currentLayout
             }