dymokomi/luce-ui
Source of release 0.19.2
0.19.2 / tests / ownership / layout_cycles.lucb
## A callback-like retained parent edge makes layout owners part of a cycle.
## The collector may finalize a child's layout before detaching its widget.
from luce_gpu import gpu
import interop
import memory
import ownership
from luce_ui import ui
from luce_ui.ui import Layout, Widget, Size, Constraints, Event, Spacer, HStack, Application
struct Child: Widget:
let box: interop.Reference[Layout]
let retained_parent: interop.Reference[Layout]
pub func init(box: interop.Reference[Layout], parent: interop.Reference[Layout]):
self.box = box.clone()
self.retained_parent = parent.clone()
pub func layout() -> interop.Reference[Layout]:
return self.box.clone()
pub func measure(available: Constraints) -> interop.Outcome[Size]:
return interop.Outcome[Size].success(interop.Owned[Size](Size()))
pub func draw(target: interop.View[gpu.RenderTarget]) -> interop.Outcome[unit]:
return interop.Outcome[unit].success(interop.Owned[unit](()))
pub func event(event: Event) -> interop.Outcome[unit]:
return interop.Outcome[unit].success(interop.Owned[unit](()))
pub func close():
self.box.release()
self.retained_parent.release()
func trace(visit: func(ownership.Object*, void*) -> unit, context: void*):
self.box.trace(visit, context)
self.retained_parent.trace(visit, context)
let child_type: interop.Type[Child] = interop.Type[Child]("Layout cycle child", Child.close, Child.trace, closeable = true, main_thread = true)
pub func collect() -> !:
let box = try interop.Reference[Layout].adopt(new Layout() in memory.heap, ui.layout_type, memory.heap)
defer box.release()
# Buffer this leaf first so collection exercises the adverse finalizer order.
let alias = box.clone()
alias.release()
let parent = try interop.Reference[Layout].adopt(new Layout() in memory.heap, ui.layout_type, memory.heap)
defer parent.release()
let child = try interop.Reference[Child].adopt(new Child(box, parent) in memory.heap, child_type, memory.heap)
defer child.release()
let widget = child.as_interface[Widget](child.value())
defer widget.release()
try parent.value().set_children([widget])
## Keeps a widget alive through a traced edge, as a Luce object's field would.
struct Holder:
let widget: interop.Interface[Widget]
pub func close():
self.widget.release()
func trace(visit: func(ownership.Object*, void*) -> unit, context: void*):
self.widget.trace(visit, context)
let holder_type: interop.Type[Holder] = interop.Type[Holder]("Layout cycle holder", Holder.close, Holder.trace, closeable = true)
func spacer() -> interop.Reference[Spacer]!:
return try interop.Reference[Spacer].adopt(new Spacer(1.0) in memory.heap, ui.spacer_type, memory.heap)
## A widget leaves the tree, held on only by a traced owner, and the next
## layout releases the tree's old entries. A collection that the release
## sets off must see the tree's new entries, not the ones just given up: it
## once traced those and took one reference too many from the widget. How
## many candidates are waiting decides where the collection fires, so every
## count around the collector's limit is tried.
pub func relayout_during_collection() -> !:
var prefill: usize = 990
while prefill <= 1030:
try relayout_once(prefill)
prefill += 1
func relayout_once(prefill: usize) -> !:
let flexible = try spacer()
let space = flexible.as_interface[Widget](flexible.value())
flexible.release()
let row = try interop.Reference[HStack].adopt(new HStack([space], 0.0, 0.0) in memory.heap, ui.hstack_type, memory.heap)
defer row.release()
let root = row.as_interface[Widget](row.value())
defer root.release()
let app = try interop.Reference[Application].adopt(new Application(root) in memory.heap, ui.application_type, memory.heap)
defer app.release()
let first = app.value().layout(300.0, 100.0)
first.release()
var nothing: interop.Interface[Widget][]
try row.value().set_children(nothing)
let holder = try interop.Reference[Holder].adopt(new Holder(widget = space.clone()) in memory.heap, holder_type, memory.heap)
defer holder.release()
space.release()
# An empty candidate buffer, then the app, the holder and `prefill` others in it.
ownership.collect()
let app_alias = app.clone()
app_alias.release()
let holder_alias = holder.clone()
holder_alias.release()
let fillers = try new interop.Reference[Spacer][prefill + 1] --- in memory.heap
defer free(fillers) in memory.heap
var index: usize = 0
while index < prefill:
fillers[index] = try spacer()
let alias = fillers[index].clone()
alias.release()
index += 1
let second = app.value().layout(300.0, 100.0)
second.release()
index = 0
while index < prefill:
fillers[index].release()
index += 1