Fix Control lifetime tracking after native parent destruction

- Mark child wrappers as released when libui-ng container destructors destroy native children
- Reject direct destroy on controls that still have a Crystal-side parent
- Route Control subclass native pointer access through availability checks
- Sync Window#on_closing with libui-ng native destroy behavior
- Document lifetime rules for parent-owned controls and window close handling
- Add specs for recursive release propagation and destroyed-wrapper access

Author: kojix2

README.md

@@ -550,7 +550,7 @@ For example, when destroy is called on controls such as Window, Box, Grid, Group
 In the case of a Window, there are two common situations:
 
 When the user clicks the close (×) button on the title bar
-In this case, on_closing is triggered, and Window#destroy is called automatically.
+In this case, `on_closing` is triggered. If the callback returns `true`, libui-ng destroys the native window. UIng mirrors that native destruction by marking the `Window` wrapper and all child wrappers as destroyed. Do not call `Window#destroy` from inside `on_closing`; return `true` to allow the close, or `false` to keep the window open.
 
 When on_should_quit is triggered
 This means the entire program is about to quit. But here, Window#destroy is not called automatically, so the user needs to call it explicitly.
@@ -560,6 +560,7 @@ Crystal has garbage collection (GC) and provides a finalize hook when objects ar
 Therefore, UIng's primary policy is:
 
 - Control objects (`Window`, `Box`, `Grid`, `Tab`, etc.) are managed with explicit `destroy`.
+- Child controls are owned by their parent. To remove a child without destroying it, use the container's delete/remove API where available. Destroying a child directly while it still has a parent is not allowed.
 - C resources that require strict ordering (for example `Table::Model`) are managed with explicit `free`.
 - `finalize` is never treated as a primary cleanup mechanism for order-sensitive resources.
 

spec/control_lifetime_spec.cr

@@ -0,0 +1,95 @@
+require "./spec_helper"
+
+private class LifetimeControl < UIng::Control
+  @ref_ptr : Pointer(UIng::LibUI::Button)
+
+  def initialize
+    @ref_ptr = Pointer(UIng::LibUI::Button).null
+  end
+
+  def adopt(parent : UIng::Control) : Nil
+    take_ownership(parent)
+  end
+
+  def mark_from_parent_destroy : Nil
+    mark_released_from_parent_destroy
+  end
+
+  def mark_from_native_destroy : Nil
+    mark_released_from_native_destroy
+  end
+
+  def to_unsafe
+    ref_ptr
+  end
+end
+
+private class LifetimeContainer < LifetimeControl
+  @child : UIng::Control?
+
+  def initialize(@child : UIng::Control? = nil)
+    super()
+  end
+
+  def adopt_child(child : LifetimeControl) : Nil
+    @child = child
+    child.adopt(self)
+  end
+
+  protected def before_destroy : Nil
+    @child.try &.mark_released_from_parent_destroy
+    @child = nil
+  end
+end
+
+describe UIng::Control do
+  it "marks descendants released when a parent is destroyed natively" do
+    parent = LifetimeContainer.new
+    child = LifetimeContainer.new
+    grandchild = LifetimeControl.new
+
+    parent.adopt_child(child)
+    child.adopt_child(grandchild)
+    parent.mark_from_parent_destroy
+
+    parent.released?.should be_true
+    child.released?.should be_true
+    grandchild.released?.should be_true
+    child.parent.should be_nil
+    grandchild.parent.should be_nil
+  end
+
+  it "rejects direct destroy while the control is owned by a parent" do
+    parent = LifetimeContainer.new
+    child = LifetimeControl.new
+    parent.adopt_child(child)
+
+    expect_raises(Exception, /destroy a child control directly/) do
+      child.destroy
+    end
+
+    child.released?.should be_false
+    child.parent.should eq(parent)
+  end
+
+  it "rejects checked pointer access after parent destroy marking" do
+    child = LifetimeControl.new
+    child.mark_from_parent_destroy
+
+    expect_raises(Exception, /already been destroyed/) do
+      child.to_unsafe
+    end
+  end
+
+  it "marks descendants released when native code destroys a root control" do
+    root = LifetimeContainer.new
+    child = LifetimeControl.new
+    root.adopt_child(child)
+
+    root.mark_from_native_destroy
+
+    root.released?.should be_true
+    child.released?.should be_true
+    child.parent.should be_nil
+  end
+end

src/uing.cr

@@ -28,6 +28,11 @@ module UIng
   @@should_quit_callback_box : Pointer(Void)?
 
   # Convert control to Pointer(LibUI::Control)
+  def self.to_control(control : Control)
+    control.check_available
+    control.to_unsafe.as(Pointer(LibUI::Control))
+  end
+
   def self.to_control(control)
     if control.is_a?(Pointer)
       control.as(Pointer(LibUI::Control))

src/uing/area/area.cr

@@ -29,33 +29,32 @@ module UIng
       @ref_ptr = LibUI.new_scrolling_area(area_handler.to_unsafe, width, height)
     end
 
-    def destroy
+    protected def before_destroy : Nil
       @area_handler = nil
-      super
     end
 
     def set_size(width : Int32, height : Int32) : Nil
-      LibUI.area_set_size(@ref_ptr, width, height)
+      LibUI.area_set_size(ref_ptr, width, height)
     end
 
     def queue_redraw_all : Nil
-      LibUI.area_queue_redraw_all(@ref_ptr)
+      LibUI.area_queue_redraw_all(ref_ptr)
     end
 
     def scroll_to(x : Float64, y : Float64, width : Float64, height : Float64) : Nil
-      LibUI.area_scroll_to(@ref_ptr, x, y, width, height)
+      LibUI.area_scroll_to(ref_ptr, x, y, width, height)
     end
 
     def begin_user_window_move : Nil
-      LibUI.area_begin_user_window_move(@ref_ptr)
+      LibUI.area_begin_user_window_move(ref_ptr)
     end
 
     def begin_user_window_resize(edge : WindowResizeEdge) : Nil
-      LibUI.area_begin_user_window_resize(@ref_ptr, edge)
+      LibUI.area_begin_user_window_resize(ref_ptr, edge)
     end
 
     def to_unsafe
-      @ref_ptr
+      ref_ptr
     end
   end
 end

src/uing/box.cr

@@ -26,11 +26,11 @@ module UIng
       self.padded = true if padded
     end
 
-    def destroy
+    protected def before_destroy : Nil
       @children_refs.each do |child|
-        child.release_ownership
+        child.mark_released_from_parent_destroy
       end
-      super
+      @children_refs.clear
     end
 
     def delete(child : Control)
@@ -43,7 +43,7 @@ module UIng
 
     def append(control, stretchy : Bool = false) : Nil
       control.check_can_move
-      LibUI.box_append(@ref_ptr, UIng.to_control(control), stretchy)
+      LibUI.box_append(ref_ptr, UIng.to_control(control), stretchy)
       @children_refs << control
       control.take_ownership(self)
     end
@@ -55,26 +55,26 @@ module UIng
     end
 
     def num_children : Int32
-      LibUI.box_num_children(@ref_ptr)
+      LibUI.box_num_children(ref_ptr)
     end
 
     def delete(index : Int32) : Nil
       child = @children_refs[index]
-      LibUI.box_delete(@ref_ptr, index)
+      LibUI.box_delete(ref_ptr, index)
       @children_refs.delete_at(index)
       child.release_ownership
     end
 
     def padded? : Bool
-      LibUI.box_padded(@ref_ptr)
+      LibUI.box_padded(ref_ptr)
     end
 
     def padded=(padded : Bool) : Nil
-      LibUI.box_set_padded(@ref_ptr, padded)
+      LibUI.box_set_padded(ref_ptr, padded)
     end
 
     def to_unsafe
-      @ref_ptr
+      ref_ptr
     end
   end
 end

src/uing/button.cr

@@ -11,25 +11,24 @@ module UIng
       @ref_ptr = LibUI.new_button(text)
     end
 
-    def destroy
+    protected def before_destroy : Nil
       @on_clicked_box = nil
-      super
     end
 
     def text : String?
-      str_ptr = LibUI.button_text(@ref_ptr)
+      str_ptr = LibUI.button_text(ref_ptr)
       UIng.string_from_pointer(str_ptr)
     end
 
     def text=(text : String) : Nil
-      LibUI.button_set_text(@ref_ptr, text)
+      LibUI.button_set_text(ref_ptr, text)
     end
 
     def on_clicked(&block : -> Nil) : Nil
       @on_clicked_box = ::Box.box(block)
       if boxed_data = @on_clicked_box
         LibUI.button_on_clicked(
-          @ref_ptr,
+          ref_ptr,
           ->(_sender, data) : Nil {
             begin
               data_as_callback = ::Box(typeof(block)).unbox(data)
@@ -44,7 +43,7 @@ module UIng
     end
 
     def to_unsafe
-      @ref_ptr
+      ref_ptr
     end
   end
 end

src/uing/checkbox.cr

@@ -11,26 +11,25 @@ module UIng
       @ref_ptr = LibUI.new_checkbox(text)
     end
 
-    def destroy
+    protected def before_destroy : Nil
       @on_toggled_box = nil
-      super
     end
 
     def text : String?
-      str_ptr = LibUI.checkbox_text(@ref_ptr)
+      str_ptr = LibUI.checkbox_text(ref_ptr)
       UIng.string_from_pointer(str_ptr)
     end
 
     def text=(text : String) : Nil
-      LibUI.checkbox_set_text(@ref_ptr, text)
+      LibUI.checkbox_set_text(ref_ptr, text)
     end
 
     def checked? : Bool
-      LibUI.checkbox_checked(@ref_ptr)
+      LibUI.checkbox_checked(ref_ptr)
     end
 
     def checked=(checked : Bool) : Nil
-      LibUI.checkbox_set_checked(@ref_ptr, checked)
+      LibUI.checkbox_set_checked(ref_ptr, checked)
     end
 
     def on_toggled(&block : Bool -> Nil) : Nil
@@ -41,7 +40,7 @@ module UIng
       @on_toggled_box = ::Box.box(wrapper)
       if boxed_data = @on_toggled_box
         LibUI.checkbox_on_toggled(
-          @ref_ptr,
+          ref_ptr,
           ->(_sender, data) : Nil {
             begin
               data_as_callback = ::Box(typeof(wrapper)).unbox(data)
@@ -56,7 +55,7 @@ module UIng
     end
 
     def to_unsafe
-      @ref_ptr
+      ref_ptr
     end
   end
 end

src/uing/color_button.cr

@@ -11,18 +11,17 @@ module UIng
       @ref_ptr = LibUI.new_color_button
     end
 
-    def destroy
+    protected def before_destroy : Nil
       @on_changed_box = nil
-      super
     end
 
     def color : {Float64, Float64, Float64, Float64}
-      LibUI.color_button_color(@ref_ptr, out r, out g, out b, out a)
+      LibUI.color_button_color(ref_ptr, out r, out g, out b, out a)
       {r, g, b, a}
     end
 
     def set_color(r : Float64, g : Float64, b : Float64, a : Float64) : Nil
-      LibUI.color_button_set_color(@ref_ptr, r, g, b, a)
+      LibUI.color_button_set_color(ref_ptr, r, g, b, a)
     end
 
     def on_changed(&block : Float64, Float64, Float64, Float64 -> Nil) : Nil
@@ -33,7 +32,7 @@ module UIng
       @on_changed_box = ::Box.box(wrapper)
       if boxed_data = @on_changed_box
         LibUI.color_button_on_changed(
-          @ref_ptr,
+          ref_ptr,
           ->(_sender, data) : Nil {
             begin
               data_as_callback = ::Box(typeof(wrapper)).unbox(data)
@@ -48,7 +47,7 @@ module UIng
     end
 
     def to_unsafe
-      @ref_ptr
+      ref_ptr
     end
   end
 end