Fix weird Gtk3Backend rendering glitch (tracking down the cause was such a pain)

stackotter · stackotter · commit 27f50579c52e · 2024-11-20T23:52:59.000+10:00
Long story short, Gtk3Backend.naturalSize(of:) is basically impossible to
implement properly due to Gtk 3's design so I've had to just add a safety
net to WindowGroupNode as a bit of a bandaid. The safety net prints a
warning before attempting to recover so it at least shouldn't surprise
anyone. Gtk3Backend is only for legacy support so I think this solution
is fine. The issue this commit fixes is that if the window grows due to
a view containing buttons appearing, all buttons would lose their labels
until you trigger a full redraw of the window by clicking off it. The
fact that buttons all lost their labels doesn't seem related to buttons
causing the issue, since all buttons lost their labels, even the ones
that had correct natural sizes and weren't causing the issue.

I still have no clue why this size underestimation (and subsequent
mis-sizing of the window) had the symptom of all buttons losing
their labels temporarily; Gtk 3 is a temperamental beast.
diff --git a/Sources/Gtk3Backend/Gtk3Backend.swift b/Sources/Gtk3Backend/Gtk3Backend.swift
@@ -86,8 +86,11 @@ public final class Gtk3Backend: AppBackend {
 
     public func setSize(ofWindow window: Window, to newSize: SIMD2<Int>) {
         let child = window.child! as! CustomRootWidget
+        child.preemptAllocatedSize(
+            allocatedWidth: newSize.x,
+            allocatedHeight: newSize.y
+        )
         window.size = Size(width: newSize.x, height: newSize.y)
-        child.preemptAllocatedSize(allocatedWidth: newSize.x, allocatedHeight: newSize.y)
     }
 
     public func setMinimumSize(ofWindow window: Window, to minimumSize: SIMD2<Int>) {
diff --git a/Sources/Gtk3CustomWidgets/gtk_custom_root_widget.c b/Sources/Gtk3CustomWidgets/gtk_custom_root_widget.c
@@ -10,7 +10,7 @@ static void gtk_custom_root_widget_class_init(GtkCustomRootWidgetClass *klass) {
     GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
     widget_class->get_preferred_width = gtk_custom_root_widget_get_preferred_width;
     widget_class->get_preferred_height = gtk_custom_root_widget_get_preferred_height;
-    widget_class->size_allocate = gtk_custom_root_widget_allocate;
+    widget_class->size_allocate = gtk_custom_root_widget_size_allocate;
     widget_class->get_request_mode = gtk_custom_root_widget_size_request_mode;
     widget_class->realize = gtk_custom_root_widget_realize;
 }
@@ -57,21 +57,15 @@ void gtk_custom_root_widget_get_preferred_height(
     *natural = max(root_widget->natural_height, root_widget->minimum_height);
 }
 
-void gtk_custom_root_widget_allocate(
+void gtk_custom_root_widget_size_allocate(
     GtkWidget *widget,
     GtkAllocation *allocation
 ) {
     GtkCustomRootWidget *root_widget = GTK_CUSTOM_ROOT_WIDGET(widget);
     gtk_widget_set_allocation(widget, allocation);
     gtk_widget_size_allocate(root_widget->child, allocation);
 
-    if (!root_widget->has_been_allocated) {
-        if (allocation->width == root_widget->natural_width && allocation->height == root_widget->natural_height) {
-            root_widget->allocated_width = allocation->width;
-            root_widget->allocated_height = allocation->height;
-            return;
-        }
-    } else if (allocation->width == root_widget->allocated_width && allocation->height == root_widget->allocated_height) {
+    if (allocation->width == root_widget->allocated_width && allocation->height == root_widget->allocated_height) {
         return;
     }
 
diff --git a/Sources/Gtk3CustomWidgets/include/gtk_custom_root_widget.h b/Sources/Gtk3CustomWidgets/include/gtk_custom_root_widget.h
@@ -51,7 +51,7 @@ void gtk_custom_root_widget_get_preferred_height(
     int *natural
 );
 
-void gtk_custom_root_widget_allocate(
+void gtk_custom_root_widget_size_allocate(
     GtkWidget *widget,
     GtkAllocation *allocation
 );
diff --git a/Sources/SwiftCrossUI/LayoutSystem.swift b/Sources/SwiftCrossUI/LayoutSystem.swift
@@ -109,15 +109,7 @@ public enum LayoutSystem {
                 if size.size != .zero || size.participateInStackLayoutsWhenEmpty {
                     print("warning: Hidden view became visible on second update. Layout may break.")
                 }
-                renderedChildren[index] = ViewSize(
-                    size: .zero,
-                    idealSize: .zero,
-                    minimumWidth: 0,
-                    minimumHeight: 0,
-                    maximumWidth: 0,
-                    maximumHeight: 0,
-                    participateInStackLayoutsWhenEmpty: false
-                )
+                renderedChildren[index] = .hidden
                 continue
             }
 
diff --git a/Sources/SwiftCrossUI/Scenes/WindowGroupNode.swift b/Sources/SwiftCrossUI/Scenes/WindowGroupNode.swift
@@ -130,13 +130,64 @@ public final class WindowGroupNode<Content: View>: SceneGraphNode {
             )
         }
 
-        _ = viewGraph.update(
+        let finalContentSize = viewGraph.update(
             with: newScene?.body,
             proposedSize: proposedWindowSize,
             environment: environment,
             dryRun: false
         )
 
+        // The Gtk 3 backend has some broken sizing code that can't really be
+        // fixed due to the design of Gtk 3. Our layout system underestimates
+        // the size of the new view due to the button not being in the Gtk 3
+        // widget hierarchy yet (which prevents Gtk 3 from computing the
+        // natural sizes of the new buttons). One fix seems to be removing
+        // view size reuse (currently the second check in ViewGraphNode.update)
+        // and I'm not exactly sure why, but that makes things awfully slow.
+        // The other fix is to add an alternative path to
+        // Gtk3Backend.naturalSize(of:) for buttons that moves non-realized
+        // buttons to a secondary window before measuring their natural size,
+        // but that's super janky, easy to break if the button in the real
+        // window is inheriting styles from its ancestors, and I'm not sure
+        // how to hide the window (it's probably terrible for performance too).
+        //
+        // I still have no clue why this size underestimation (and subsequent
+        // mis-sizing of the window) had the symptom of all buttons losing
+        // their labels temporarily; Gtk 3 is a temperamental beast.
+        //
+        // Anyway, Gtk3Backend isn't really intended to be a recommended
+        // backend so I think this is a fine solution for now (people should
+        // only use Gtk3Backend if they can't use GtkBackend).
+        if finalContentSize != contentSize {
+            print(
+                """
+                warning: Final window content size didn't match dry-run size. This is a sign that
+                         either view size caching is broken or that backend.naturalSize(of:) is 
+                         broken (or both).
+                      -> contentSize:      \(contentSize)
+                      -> finalContentSize: \(finalContentSize)
+                """
+            )
+
+            // Give the view graph one more chance to sort itself out to fail
+            // as gracefully as possible.
+            let newWindowSize = computeNewWindowSize(
+                currentProposedSize: proposedWindowSize,
+                backend: backend,
+                contentSize: finalContentSize,
+                environment: environment
+            )
+
+            if let newWindowSize {
+                return update(
+                    scene,
+                    proposedWindowSize: newWindowSize,
+                    backend: backend,
+                    environment: environment
+                )
+            }
+        }
+
         if scene.resizability.isResizable {
             backend.setMinimumSize(
                 ofWindow: window,
diff --git a/Sources/SwiftCrossUI/Views/Button.swift b/Sources/SwiftCrossUI/Views/Button.swift
@@ -22,7 +22,15 @@ public struct Button: ElementaryView, View {
         backend: Backend,
         dryRun: Bool
     ) -> ViewSize {
-        // TODO: Implement button sizing within SwiftCrossUI so that we can properly implement `dryRun`.
+        // TODO: Implement button sizing within SwiftCrossUI so that we can properly implement
+        //   `dryRun`. Relying on the backend for button sizing also makes the Gtk 3 backend
+        //   basically impossible to implement correctly, hence the
+        //   `finalContentSize != contentSize` check in WindowGroupNode to catch any weird
+        //   behaviour. Without that extra safety net logic, buttons all end up label-less
+        //   whenever the window grows due to a view containing buttons appearing. Not sure
+        //   why all buttons lose their labels (until you click off the window, forcing it to
+        //   refresh), but the reason Gtk 3 doesn't like it is that the window gets set smaller
+        //   than its content I think.
         backend.updateButton(widget, label: label, action: action, environment: environment)
         return ViewSize(fixedSize: backend.naturalSize(of: widget))
     }
