removing weak self captures for debugging

Author: JWI

Sources/SwiftCrossUI/Scenes/WindowGroupNode.swift

@@ -44,10 +44,7 @@ public final class WindowGroupNode<Content: View>: SceneGraphNode {
         self.window = window
         parentEnvironment = environment
 
-        backend.setResizeHandler(ofWindow: window) { [weak self] newSize in
-            guard let self else {
-                return
-            }
+        backend.setResizeHandler(ofWindow: window) { newSize in
             _ = self.update(
                 self.scene,
                 proposedWindowSize: newSize,
@@ -58,10 +55,7 @@ public final class WindowGroupNode<Content: View>: SceneGraphNode {
             )
         }
 
-        backend.setWindowEnvironmentChangeHandler(of: window) { [weak self] in
-            guard let self else {
-                return
-            }
+        backend.setWindowEnvironmentChangeHandler(of: window) {
             _ = self.update(
                 self.scene,
                 proposedWindowSize: backend.size(ofWindow: window),
@@ -110,11 +104,6 @@ public final class WindowGroupNode<Content: View>: SceneGraphNode {
         parentEnvironment = environment
 
         if let newScene = newScene {
-            // Don't set default size even if it has changed. We only set that once
-            // at window creation since some backends don't have a concept of
-            // 'default' size which would mean that setting the default size every time
-            // the default size changed would resize the window (which is incorrect
-            // behaviour).
             backend.setTitle(ofWindow: window, to: newScene.title)
             backend.setResizability(ofWindow: window, to: newScene.resizability.isResizable)
             scene = newScene
@@ -125,9 +114,8 @@ public final class WindowGroupNode<Content: View>: SceneGraphNode {
             rootEnvironment: environment
         )
 
-        // Assign onResize manually
-        newEnvironment.onResize = { [weak self] _ in
-            guard let self = self else { return }
+        // Assign onResize manually, strong capture
+        newEnvironment.onResize = { _ in
             _ = self.update(
                 self.scene,
                 proposedWindowSize: backend.size(ofWindow: window),
@@ -144,8 +132,6 @@ public final class WindowGroupNode<Content: View>: SceneGraphNode {
 
         let dryRunResult: ViewUpdateResult?
         if !windowSizeIsFinal {
-            // Perform a dry-run update of the root view to check if the window
-            // needs to change size.
             let contentResult = viewGraph.update(
                 with: newScene?.body,
                 proposedSize: proposedWindowSize,
@@ -161,9 +147,6 @@ public final class WindowGroupNode<Content: View>: SceneGraphNode {
                 environment: environment
             )
 
-            // Restart the window update if the content has caused the window to
-            // change size. To avoid infinite recursion, we take the view's word
-            // and assume that it will take on the minimum/maximum size it claimed.
             if let newWindowSize {
                 return update(
                     scene,
@@ -184,40 +167,17 @@ public final class WindowGroupNode<Content: View>: SceneGraphNode {
             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 let dryRunResult, finalContentResult.size != dryRunResult.size {
             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 
+                         either view size caching is broken or that backend.naturalSize(of:) is
                          broken (or both).
                       -> dryRunResult.size:       \(dryRunResult.size)
                       -> finalContentResult.size: \(finalContentResult.size)
                 """
             )
 
-            // Give the view graph one more chance to sort itself out to fail
-            // as gracefully as possible.
             let newWindowSize = computeNewWindowSize(
                 currentProposedSize: proposedWindowSize,
                 backend: backend,
@@ -236,8 +196,6 @@ public final class WindowGroupNode<Content: View>: SceneGraphNode {
             }
         }
 
-        // Set this even if the window isn't programmatically resizable
-        // because the window may still be user resizable.
         if scene.resizability.isResizable {
             backend.setMinimumSize(
                 ofWindow: window,