Use idealSize of content for contentSize windows, fix idealSize propagation

Also fixed some Gtk-specific window resizing issues.

Author: stackotter

Examples/Package.resolved

@@ -1,4 +1,5 @@
 import CGtk
+import Dispatch
 import GtkCustomWidgets
 
 /// A custom widget made specifically for SwiftCrossUI. This widget provides the
@@ -50,7 +51,15 @@ public class CustomRootWidget: Widget {
     }
 
     public func setResizeHandler(_ handler: @escaping (Size) -> Void) {
-        let box = SignalBox1<Size>(callback: handler)
+        let box = SignalBox1<Size> { size in
+            // Ensure that the handler can't mess with the current update.
+            // Otherwise if it goes and updates the whole view hierarchy then
+            // Gtk gets annoyed cause everything kinda gets pulled out from
+            // under it.
+            DispatchQueue.main.async {
+                handler(size)
+            }
+        }
         gtk_custom_root_widget_set_resize_callback(
             castedPointer(),
             { data, size in

Sources/Gtk/Widgets/CustomRootWidget.swift

@@ -149,7 +149,6 @@ public class PopoverMenu: Popover {
         gtk_popover_popup(castedPointer())
 
         gtk_widget_get_preferred_size(widgetPointer, &menuMinimumSize, &menuNaturalSize)
-        print(menuNaturalSize)
 
         // TODO: Figure out why this is actually happening and whether it's just specific to
         //   my machines. Probably just some weird menu CSS from the default themes, but

Sources/Gtk/Widgets/PopoverMenu.swift

@@ -93,8 +93,8 @@ public final class GtkBackend: AppBackend {
             windowSize.height - childSize.height
         )
         window.size = Size(
-            width: decorationsSize.x + newSize.x,
-            height: decorationsSize.y + newSize.y
+            width: newSize.x,
+            height: newSize.y
         )
         child.preemptAllocatedSize(allocatedWidth: newSize.x, allocatedHeight: newSize.y)
     }

Sources/GtkBackend/GtkBackend.swift

@@ -150,6 +150,8 @@ public enum LayoutSystem {
 
         let size: SIMD2<Int>
         let idealSize: SIMD2<Int>
+        let idealWidthForProposedHeight: Int
+        let idealHeightForProposedWidth: Int
         let minimumWidth: Int
         let minimumHeight: Int
         let maximumWidth: Double?
@@ -169,6 +171,10 @@ public enum LayoutSystem {
                 maximumWidth =
                     renderedChildren.map(\.maximumWidth).reduce(0, +) + Double(totalSpacing)
                 maximumHeight = renderedChildren.map(\.maximumHeight).max()
+                idealWidthForProposedHeight =
+                    renderedChildren.map(\.idealWidthForProposedHeight).reduce(0, +) + totalSpacing
+                idealHeightForProposedWidth =
+                    renderedChildren.map(\.idealHeightForProposedWidth).max() ?? 0
             case .vertical:
                 size = SIMD2<Int>(
                     renderedChildren.map(\.size.x).max() ?? 0,
@@ -183,6 +189,10 @@ public enum LayoutSystem {
                 maximumWidth = renderedChildren.map(\.maximumWidth).max()
                 maximumHeight =
                     renderedChildren.map(\.maximumHeight).reduce(0, +) + Double(totalSpacing)
+                idealWidthForProposedHeight =
+                    renderedChildren.map(\.idealWidthForProposedHeight).max() ?? 0
+                idealHeightForProposedWidth =
+                    renderedChildren.map(\.idealHeightForProposedWidth).reduce(0, +) + totalSpacing
         }
 
         if !dryRun {
@@ -233,6 +243,8 @@ public enum LayoutSystem {
         return ViewSize(
             size: size,
             idealSize: idealSize,
+            idealWidthForProposedHeight: idealWidthForProposedHeight,
+            idealHeightForProposedWidth: idealHeightForProposedWidth,
             minimumWidth: minimumWidth,
             minimumHeight: minimumHeight,
             maximumWidth: maximumWidth,

Sources/SwiftCrossUI/LayoutSystem.swift

@@ -109,12 +109,40 @@ struct StrictFrameView<Child: View>: TypeSafeView {
             backend.setPosition(ofChildAt: 0, in: widget, to: childPosition)
         }
 
+        let idealWidth: Int
+        let idealHeight: Int
+        if let width, let height {
+            idealWidth = width
+            idealHeight = height
+        } else if let width, height == nil {
+            idealWidth = width
+            idealHeight = childSize.idealHeightForProposedWidth
+        } else if let height, width == nil {
+            idealHeight = height
+            idealWidth = childSize.idealWidthForProposedHeight
+        } else {
+            idealWidth = childSize.idealSize.x
+            idealHeight = childSize.idealSize.y
+        }
+
+        let idealWidthForProposedHeight: Int
+        let idealHeightForProposedWidth: Int
+        if width == nil && height == nil {
+            idealWidthForProposedHeight = childSize.idealWidthForProposedHeight
+            idealHeightForProposedWidth = childSize.idealHeightForProposedWidth
+        } else {
+            idealWidthForProposedHeight = idealWidth
+            idealHeightForProposedWidth = idealHeight
+        }
+
         return ViewSize(
             size: frameSize,
             idealSize: SIMD2(
-                width ?? childSize.idealSize.x,
-                height ?? childSize.idealSize.y
+                idealWidth,
+                idealHeight
             ),
+            idealWidthForProposedHeight: idealWidthForProposedHeight,
+            idealHeightForProposedWidth: idealHeightForProposedWidth,
             minimumWidth: width ?? childSize.minimumWidth,
             minimumHeight: height ?? childSize.minimumHeight,
             maximumWidth: width.map(Double.init) ?? childSize.maximumWidth,
@@ -183,9 +211,6 @@ struct FlexibleFrameView<Child: View>: TypeSafeView {
         dryRun: Bool
     ) -> ViewSize {
         var proposedFrameSize = proposedSize
-        if let idealWidth {
-            proposedFrameSize.x = min(proposedFrameSize.x, idealWidth)
-        }
         if let minWidth {
             proposedFrameSize.x = max(proposedFrameSize.x, minWidth)
         }
@@ -198,9 +223,6 @@ struct FlexibleFrameView<Child: View>: TypeSafeView {
         if let maxHeight {
             proposedFrameSize.y = min(proposedFrameSize.y, maxHeight)
         }
-        if let idealHeight {
-            proposedFrameSize.y = min(proposedFrameSize.y, idealHeight)
-        }
 
         let childSize = children.child0.update(
             with: body.view0,
@@ -209,27 +231,50 @@ struct FlexibleFrameView<Child: View>: TypeSafeView {
             dryRun: dryRun
         )
 
+        // TODO: Fix idealSize propagation. When idealSize isn't possible, we
+        //   have to use idealWidthForProposedHeight and
+        //   idealHeightForProposedWidth, and sometimes we may also have to
+        //   perform an additional dryRun update to probe the child view.
+
         var frameSize = childSize
         if let minWidth {
             frameSize.size.x = max(frameSize.size.x, minWidth)
             frameSize.minimumWidth = minWidth
             frameSize.idealSize.x = max(frameSize.idealSize.x, minWidth)
+            frameSize.idealWidthForProposedHeight = max(
+                frameSize.idealWidthForProposedHeight,
+                minWidth
+            )
         }
         if let maxWidth {
             frameSize.size.x = min(frameSize.size.x, maxWidth)
             frameSize.idealSize.x = min(frameSize.idealSize.x, maxWidth)
             frameSize.maximumWidth = min(childSize.maximumWidth, Double(maxWidth))
+            frameSize.idealWidthForProposedHeight = min(
+                frameSize.idealWidthForProposedHeight,
+                maxWidth
+            )
         }
+
         if let minHeight {
             frameSize.size.y = max(frameSize.size.y, minHeight)
             frameSize.minimumHeight = minHeight
             frameSize.idealSize.y = max(frameSize.idealSize.y, minHeight)
+            frameSize.idealHeightForProposedWidth = max(
+                frameSize.idealHeightForProposedWidth,
+                minHeight
+            )
         }
         if let maxHeight {
             frameSize.size.y = min(frameSize.size.y, maxHeight)
             frameSize.idealSize.y = min(frameSize.idealSize.y, maxHeight)
             frameSize.maximumHeight = min(childSize.maximumHeight, Double(maxHeight))
+            frameSize.idealHeightForProposedWidth = min(
+                frameSize.idealHeightForProposedWidth,
+                maxHeight
+            )
         }
+
         if let idealWidth {
             frameSize.idealSize.x = idealWidth
         }

Sources/SwiftCrossUI/Modifiers/Frame.swift

@@ -77,6 +77,8 @@ struct PaddingModifierView<Child: View>: TypeSafeView {
         return ViewSize(
             size: size,
             idealSize: childSize.idealSize &+ paddingSize,
+            idealWidthForProposedHeight: childSize.idealWidthForProposedHeight + paddingSize.x,
+            idealHeightForProposedWidth: childSize.idealHeightForProposedWidth + paddingSize.y,
             minimumWidth: childSize.minimumWidth + paddingSize.x,
             minimumHeight: childSize.minimumHeight + paddingSize.y,
             maximumWidth: childSize.maximumWidth + Double(paddingSize.x),

Sources/SwiftCrossUI/Modifiers/Padding.swift

@@ -40,7 +40,9 @@ public final class WindowGroupNode<Content: View>: SceneGraphNode {
         parentEnvironment = environment
 
         backend.setResizeHandler(ofWindow: window) { [weak self] newSize in
-            guard let self else { return }
+            guard let self else {
+                return
+            }
             _ = self.update(
                 scene,
                 proposedWindowSize: newSize,
@@ -61,7 +63,9 @@ public final class WindowGroupNode<Content: View>: SceneGraphNode {
 
         _ = update(
             newScene,
-            proposedWindowSize: backend.size(ofWindow: window),
+            proposedWindowSize: isFirstUpdate
+                ? (newScene ?? scene).defaultSize
+                : backend.size(ofWindow: window),
             backend: backend,
             environment: environment
         )
@@ -238,8 +242,8 @@ public final class WindowGroupNode<Content: View>: SceneGraphNode {
             } else {
                 return nil
             }
-        } else if contentSize.size != currentProposedSize {
-            return contentSize.size
+        } else if contentSize.idealSize != currentProposedSize {
+            return contentSize.idealSize
         } else {
             return nil
         }

Sources/SwiftCrossUI/Scenes/WindowGroupNode.swift

@@ -33,6 +33,14 @@ public struct ViewSize: Equatable {
     public var size: SIMD2<Int>
     /// The size that the view ideally wants to take up.
     public var idealSize: SIMD2<Int>
+    /// The width that the view ideally wants to take up assuming that the
+    /// proposed height doesn't change. Only really differs from `idealSize` for
+    /// views that have a trade-off between width and height (such as `Text`).
+    public var idealWidthForProposedHeight: Int
+    /// The height that the view ideally wants to take up assuming that the
+    /// proposed width doesn't change. Only really differs from `idealSize` for
+    /// views that have a trade-off between width and height (such as `Text`).
+    public var idealHeightForProposedWidth: Int
     /// The minimum width that the view can take (if its height remains the same).
     public var minimumWidth: Int
     /// The minimum height that the view can take (if its width remains the same).
@@ -59,6 +67,8 @@ public struct ViewSize: Equatable {
     public init(
         size: SIMD2<Int>,
         idealSize: SIMD2<Int>,
+        idealWidthForProposedHeight: Int? = nil,
+        idealHeightForProposedWidth: Int? = nil,
         minimumWidth: Int,
         minimumHeight: Int,
         maximumWidth: Double?,
@@ -67,6 +77,8 @@ public struct ViewSize: Equatable {
     ) {
         self.size = size
         self.idealSize = idealSize
+        self.idealWidthForProposedHeight = idealWidthForProposedHeight ?? idealSize.x
+        self.idealHeightForProposedWidth = idealHeightForProposedWidth ?? idealSize.y
         self.minimumWidth = minimumWidth
         self.minimumHeight = minimumHeight
         // Using `Double(1 << 53)` as the default allows us to differentiate between views
@@ -87,6 +99,8 @@ public struct ViewSize: Equatable {
     public init(fixedSize: SIMD2<Int>) {
         size = fixedSize
         idealSize = fixedSize
+        idealWidthForProposedHeight = fixedSize.x
+        idealHeightForProposedWidth = fixedSize.y
         minimumWidth = fixedSize.x
         minimumHeight = fixedSize.y
         maximumWidth = Double(fixedSize.x)

Sources/SwiftCrossUI/ViewGraph/ViewSize.swift

@@ -31,7 +31,7 @@ public struct Group<Content: View>: View {
         backend: Backend,
         dryRun: Bool
     ) -> ViewSize {
-        let size = LayoutSystem.updateStackLayout(
+        LayoutSystem.updateStackLayout(
             container: widget,
             children: layoutableChildren(backend: backend, children: children),
             proposedSize: proposedSize,
@@ -40,6 +40,5 @@ public struct Group<Content: View>: View {
             dryRun: dryRun,
             inheritStackLayoutParticipation: true
         )
-        return size
     }
 }