Views: containers size to their content, and fixes for plain Dart apps

- Row and Column containers report the size their visible subviews need as
  their intrinsic size, so nested rows and columns no longer collapse to zero
  without a preferred size. Measured once per layout pass.
- macOS: a container created under ARC is handed over autoreleased instead of
  being freed on return (View() crashed in the Dart build).
- macOS: intrinsic sizes include the alignment insets, so buttons are not
  clipped in a process linked against an older SDK.
- macOS: destroying a view that holds the focused field no longer emits
  ViewBlurredEvent into the tree being torn down (crashed at exit).
- Application::Quit() on a loop that is not Run()'s own emits
  ApplicationExitingEvent on Windows and Linux too, and ends the process on
  Linux, as documented.

Author: lijy91

src/application.h

@@ -184,9 +184,10 @@ class Application : public EventEmitter<ApplicationEvent> {
    * are emitted.
    *
    * When the loop is not Run()'s own (a host such as a Flutter runner owns
-   * it), there is nothing to return to and the process ends instead; on
-   * macOS it goes through -[NSApplication terminate:], which exits with
-   * status 0 whatever @p exit_code is.
+   * it), there is nothing to return to and the process ends instead, after
+   * ApplicationExitingEvent: on macOS through -[NSApplication terminate:],
+   * which exits with status 0 whatever @p exit_code is; on Linux with
+   * @p exit_code; on Windows the host's loop gets WM_QUIT and ends it.
    *
    * A quit the user or the system starts outside Quit() (Cmd+Q, logout) also
    * emits ApplicationQuitRequestedEvent. On macOS it cannot be vetoed and

src/platform/linux/application_linux.cpp

@@ -98,7 +98,20 @@ class Application::Impl {
     return status != 0 ? status : app_->exit_code_;
   }
 
-  void Quit(int exit_code) { g_application_quit(G_APPLICATION(gtk_app_)); }
+  void Quit(int exit_code) {
+    if (app_->running_) {
+      // Our Run() owns the loop: stop it so Run() returns the exit code.
+      g_application_quit(G_APPLICATION(gtk_app_));
+      return;
+    }
+
+    // Someone else runs the loop (a Flutter runner, a host pumping it by
+    // hand): there is nothing to return to, so end the process, as macOS
+    // does through -terminate:.
+    ApplicationExitingEvent event(exit_code);
+    app_->Emit(event);
+    std::exit(exit_code);
+  }
 
   // gtk_application_add_window() and g_application_hold() only take effect on a
   // registered application, and g_application_run() registers too late for that.

src/platform/macos/view_macos.mm

@@ -22,6 +22,12 @@ - (BOOL)isFlipped {
 
 namespace {
 
+// Non-zero while a view takes its native control out of the window on the way
+// to destruction. Removing a focused field (or a container holding one) ends
+// editing, and the blur that follows must not reach listeners: they may run
+// while the rest of the tree is going away, as at process exit.
+int g_views_being_destroyed = 0;
+
 // The bridge is the delegate only while the view listens (HookControl), so a
 // field that nobody listens to reports nothing.
 NativeApiViewBridge* ListeningBridge(NSTextField* field) {
@@ -35,7 +41,7 @@ - (BOOL)isFlipped {
 
 void ReportFocus(NSTextField* field, bool focused) {
   NativeApiViewBridge* bridge = ListeningBridge(field);
-  if (!bridge) {
+  if (!bridge || g_views_being_destroyed > 0) {
     return;
   }
   if (focused) {
@@ -212,7 +218,9 @@ - (BOOL)control:(NSControl*)control
 
 View::Impl::~Impl() {
   if (owned && platform && platform->view) {
+    ++g_views_being_destroyed;
     [platform->view removeFromSuperview];
+    --g_views_being_destroyed;
   }
   platform.reset();
   native = nullptr;
@@ -221,10 +229,14 @@ - (BOOL)control:(NSControl*)control
 void* View::Impl::CreateNativeContainer() {
   NativeApiContainerView* view = [[NativeApiContainerView alloc] initWithFrame:NSZeroRect];
   view.autoresizingMask = NSViewNotSizable;
-#if !__has_feature(objc_arc)
+  // Handed over autoreleased, so it lives until Platform takes its own
+  // reference. Under ARC a plain __bridge return would free it on the way out.
+#if __has_feature(objc_arc)
+  return (void*)CFAutorelease((__bridge_retained CFTypeRef)view);
+#else
   [view autorelease];
-#endif
   return (__bridge void*)view;
+#endif
 }
 
 void View::Impl::SetNativeFrame(Rectangle frame) {
@@ -264,8 +276,20 @@ - (BOOL)control:(NSControl*)control
     return Size{0, 0};
   }
   NSSize size = view.intrinsicContentSize;
+  // That is the size of the alignment rect; a frame also covers the alignment
+  // insets (a push button's shadow and bezel margin). A process linked against
+  // an older SDK has such insets on current macOS, and without them the title
+  // would be clipped.
+  const NSEdgeInsets insets = view.alignmentRectInsets;
+  if (size.width > 0) {
+    size.width += insets.left + insets.right;
+  }
+  if (size.height > 0) {
+    size.height += insets.top + insets.bottom;
+  }
   if ([view isKindOfClass:[NSControl class]]) {
     // Labels and buttons know their width; an editable field reports none.
+    // sizeThatFits: already answers in frame terms.
     NSSize fitting = [(NSControl*)view sizeThatFits:NSMakeSize(CGFLOAT_MAX, CGFLOAT_MAX)];
     if (size.width < 0) {
       size.width = [view isKindOfClass:[NSTextField class]] && ((NSTextField*)view).isEditable

src/platform/windows/application_windows.cpp

@@ -196,7 +196,16 @@ class Application::Impl {
     return exit_code;
   }
 
-  void Quit(int exit_code) { PostQuitMessage(exit_code); }
+  void Quit(int exit_code) {
+    if (!app_->running_) {
+      // Someone else runs the loop (a Flutter runner, a host pumping it by
+      // hand): Run() will not return to emit this, and the host ends the
+      // process on WM_QUIT.
+      ApplicationExitingEvent event(exit_code);
+      app_->Emit(event);
+    }
+    PostQuitMessage(exit_code);
+  }
 
   bool SetIcon(const std::string& icon_path) {
     if (icon_path.empty()) {

src/view.cpp

@@ -1,12 +1,35 @@
 #include "view.h"
 
 #include <algorithm>
+#include <cstdint>
 
 #include "view_impl.h"
 #include "view_layout.h"
 
 namespace nativeapi {
 
+namespace {
+
+// Layout passes in progress on this thread, and a number per pass. Within one
+// pass nothing changes size, so IntrinsicSize() measures each view once; a
+// container's size depends on its whole subtree and would otherwise be
+// measured again at every level above it.
+thread_local int g_layout_depth = 0;
+thread_local uint64_t g_layout_pass = 0;
+
+class LayoutPass {
+ public:
+  LayoutPass() {
+    ++g_layout_depth;
+    ++g_layout_pass;
+  }
+  ~LayoutPass() { --g_layout_depth; }
+  LayoutPass(const LayoutPass&) = delete;
+  LayoutPass& operator=(const LayoutPass&) = delete;
+};
+
+}  // namespace
+
 // ---------------------------------------------------------------------------
 // Impl: the shared half
 // ---------------------------------------------------------------------------
@@ -20,6 +43,7 @@ View* View::Impl::Root() const {
 }
 
 void View::Impl::RelayoutTree() {
+  LayoutPass pass;
   Root()->pimpl_->Relayout();
 }
 
@@ -28,14 +52,47 @@ void View::Impl::InvalidateIntrinsicSize() {
 }
 
 void View::Impl::OnNativeResized() {
+  LayoutPass pass;
   Relayout();
 }
 
+Size View::Impl::IntrinsicSize() const {
+  if (g_layout_depth > 0 && measured_pass == g_layout_pass) {
+    return measured;
+  }
+  Size size;
+  if (layout == ViewLayout::Absolute || subviews.empty()) {
+    size = GetNativeIntrinsicSize();
+  } else {
+    std::vector<LayoutChild> children;
+    children.reserve(subviews.size());
+    for (const auto& subview : subviews) {
+      children.push_back(subview->pimpl_->AsLayoutChild());
+    }
+    size = ComputeStackContentSize(layout, padding, spacing, children);
+  }
+  if (g_layout_depth > 0) {
+    measured = size;
+    measured_pass = g_layout_pass;
+  }
+  return size;
+}
+
+LayoutChild View::Impl::AsLayoutChild() const {
+  LayoutChild entry;
+  entry.visible = visible;
+  entry.preferred = preferred_size;
+  entry.intrinsic = visible ? IntrinsicSize() : Size{0.0, 0.0};
+  entry.flex = flex;
+  entry.alignment = alignment;
+  return entry;
+}
+
 Rectangle View::Impl::AbsoluteFrame() const {
   if (has_frame) {
     return frame;
   }
-  const Size intrinsic = GetNativeIntrinsicSize();
+  const Size intrinsic = IntrinsicSize();
   return Rectangle{0.0, 0.0, intrinsic.width, intrinsic.height};
 }
 
@@ -50,14 +107,7 @@ void View::Impl::Relayout() {
     std::vector<LayoutChild> children;
     children.reserve(subviews.size());
     for (const auto& subview : subviews) {
-      auto& child = *subview->pimpl_;
-      LayoutChild entry;
-      entry.visible = child.visible;
-      entry.preferred = child.preferred_size;
-      entry.intrinsic = child.visible ? child.GetNativeIntrinsicSize() : Size{0.0, 0.0};
-      entry.flex = child.flex;
-      entry.alignment = child.alignment;
-      children.push_back(entry);
+      children.push_back(subview->pimpl_->AsLayoutChild());
     }
     const Rectangle own = GetNativeFrame();
     const auto frames = ComputeStackLayout(layout, Size{own.width, own.height}, padding, spacing,
@@ -222,7 +272,7 @@ Size View::GetPreferredSize() const {
 }
 
 Size View::GetIntrinsicSize() const {
-  return pimpl_->GetNativeIntrinsicSize();
+  return pimpl_->IntrinsicSize();
 }
 
 void View::SetFlex(double flex) {

src/view.h

@@ -437,9 +437,15 @@ class View : public EventEmitter<ViewEvent>,
   Size GetPreferredSize() const;
 
   /**
-   * @brief Gets the size the native control wants to be.
+   * @brief Gets the size the view wants to be when nothing stretches it.
    *
-   * @return The intrinsic size in logical points; zero for a container.
+   * A Row or Column parent uses it on every axis where SetPreferredSize()
+   * left 0, so nested rows and columns size to their content.
+   *
+   * @return The intrinsic size in logical points: the native control's own
+   *         size; for a Row or Column container, what its visible subviews
+   *         need at their preferred or intrinsic sizes, plus spacing and
+   *         padding; zero for an Absolute container.
    */
   Size GetIntrinsicSize() const;
 

src/view_impl.h

@@ -1,11 +1,13 @@
 #pragma once
 
+#include <cstdint>
 #include <memory>
 #include <optional>
 #include <string>
 #include <vector>
 
 #include "view.h"
+#include "view_layout.h"
 #include "window.h"
 
 namespace nativeapi {
@@ -60,6 +62,11 @@ class View::Impl {
   static void InitializeRoot(const std::shared_ptr<View>& view, std::weak_ptr<Window> window);
   /// Called by a control after a change that alters its intrinsic size.
   void InvalidateIntrinsicSize();
+  /// What GetIntrinsicSize() reports: the control's own size, or for a Row or
+  /// Column container with subviews the size its content needs.
+  Size IntrinsicSize() const;
+  /// What a Row or Column parent needs to know about this view.
+  LayoutChild AsLayoutChild() const;
   /// Called by a platform that replaced the native view: keeps `native` and
   /// the tree's z-order bookkeeping consistent.
   void NativeReplaced(void* replacement) { native = replacement; }
@@ -95,6 +102,9 @@ class View::Impl {
   /// called, otherwise the intrinsic size at the origin.
   Rectangle AbsoluteFrame() const;
   bool visible = true;
+  /// IntrinsicSize() of the layout pass numbered `measured_pass` (view.cpp).
+  mutable Size measured{0.0, 0.0};
+  mutable uint64_t measured_pass = 0;
   Color background_color{0, 0, 0, 0};
   std::optional<std::string> tooltip;
 
@@ -107,7 +117,8 @@ class View::Impl {
   /// its parent pointer; the platform detaches or parks the native child).
   void SetNativeFrame(Rectangle frame);
   Rectangle GetNativeFrame() const;
-  /// The size the control wants; zero for a container.
+  /// The size the native control wants; zero for a container, whose size
+  /// comes from its content instead (IntrinsicSize()).
   Size GetNativeIntrinsicSize() const;
   /// Reparents `child`'s native view under this one at z-index `index`.
   /// Called after `subviews` already holds the child at `index`, so the

src/view_layout.cpp

@@ -10,6 +10,10 @@ double NonNegative(double value) {
   return value < 0.0 ? 0.0 : value;
 }
 
+double Natural(double preferred, double intrinsic) {
+  return preferred > 0.0 ? preferred : intrinsic;
+}
+
 }  // namespace
 
 std::vector<Rectangle> ComputeStackLayout(ViewLayout layout, Size container, EdgeInsets padding,
@@ -33,12 +37,10 @@ std::vector<Rectangle> ComputeStackLayout(ViewLayout layout, Size container, Edg
   auto main_of = [&](Size size) { return row ? size.width : size.height; };
   auto cross_of = [&](Size size) { return row ? size.height : size.width; };
   auto natural_main = [&](const LayoutChild& child) {
-    const double preferred = main_of(child.preferred);
-    return preferred > 0.0 ? preferred : main_of(child.intrinsic);
+    return Natural(main_of(child.preferred), main_of(child.intrinsic));
   };
   auto natural_cross = [&](const LayoutChild& child) {
-    const double preferred = cross_of(child.preferred);
-    return preferred > 0.0 ? preferred : cross_of(child.intrinsic);
+    return Natural(cross_of(child.preferred), cross_of(child.intrinsic));
   };
 
   size_t visible_count = 0;
@@ -96,4 +98,32 @@ std::vector<Rectangle> ComputeStackLayout(ViewLayout layout, Size container, Edg
   return frames;
 }
 
+Size ComputeStackContentSize(ViewLayout layout, EdgeInsets padding, double spacing,
+                             const std::vector<LayoutChild>& children) {
+  if (layout == ViewLayout::Absolute) {
+    return Size{0.0, 0.0};
+  }
+  const bool row = layout == ViewLayout::Row;
+  double main_total = 0.0;
+  double cross_max = 0.0;
+  size_t visible_count = 0;
+  for (const auto& child : children) {
+    if (!child.visible) {
+      continue;
+    }
+    ++visible_count;
+    const double width = Natural(child.preferred.width, child.intrinsic.width);
+    const double height = Natural(child.preferred.height, child.intrinsic.height);
+    main_total += row ? width : height;
+    cross_max = std::max(cross_max, row ? height : width);
+  }
+  if (visible_count > 1) {
+    main_total += spacing * static_cast<double>(visible_count - 1);
+  }
+  const double horizontal = padding.left + padding.right;
+  const double vertical = padding.top + padding.bottom;
+  return row ? Size{main_total + horizontal, cross_max + vertical}
+             : Size{cross_max + horizontal, main_total + vertical};
+}
+
 }  // namespace nativeapi

src/view_layout.h

@@ -32,4 +32,13 @@ struct LayoutChild {
 std::vector<Rectangle> ComputeStackLayout(ViewLayout layout, Size container, EdgeInsets padding,
                                           double spacing, const std::vector<LayoutChild>& children);
 
+/**
+ * The size a Row or Column needs to give every visible child its preferred or
+ * intrinsic size (flex children included) without stretching: the children end
+ * to end plus spacing on the main axis, the largest child on the cross axis,
+ * padding around both. Zero for Absolute, whose children place themselves.
+ */
+Size ComputeStackContentSize(ViewLayout layout, EdgeInsets padding, double spacing,
+                             const std::vector<LayoutChild>& children);
+
 }  // namespace nativeapi

tests/CMakeLists.txt

@@ -6,6 +6,10 @@ add_executable(window_shape_test window_shape_test.cpp)
 target_link_libraries(window_shape_test PRIVATE nativeapi)
 add_test(NAME window_shape_test COMMAND window_shape_test)
 
+add_executable(view_layout_test view_layout_test.cpp)
+target_link_libraries(view_layout_test PRIVATE nativeapi)
+add_test(NAME view_layout_test COMMAND view_layout_test)
+
 add_executable(window_shadow_blur_test window_shadow_blur_test.cpp)
 target_link_libraries(window_shadow_blur_test PRIVATE nativeapi)
 add_test(NAME window_shadow_blur_test COMMAND window_shadow_blur_test)