dymokomi/luce-ui
Source of release 0.19.0
from luce_gpu import gpu
from luce_window import input
import interop
from luce_std import math
import memory
import ownership
import thread
from luce_std import crash
from luce_window import window
from luce_ui import ui
import layout_cycles
from luce_ui.ui import Widget, Button, Spacer, VStack, HStack, Layout, Size, Application, Painter, Rect, Event, Font, Panel, DStack
struct Tracker: memory.Allocator:
var upstream: memory.Allocator
var live: usize
var remaining: usize?
pub func allocate(size: usize, alignment: usize) -> u8[]?:
if let remaining = self.remaining:
if remaining == 0:
return none
self.remaining = remaining - 1
let block = self.upstream.allocate(size, alignment) else return none
self.live += 1
return block
pub func resize(block: u8[], size: usize) -> bool:
return self.upstream.resize(block, size)
pub func release(block: u8[]):
assert(self.live > 0)
self.live -= 1
self.upstream.release(block)
func restore(previous: memory.Allocator):
memory.heap = previous
func new_button(text: str) -> interop.Reference[Button]!:
return try interop.Reference[Button].adopt(new Button(text) in memory.heap, ui.button_type, memory.heap)
func expect(outcome: interop.Outcome[unit]) -> !:
defer outcome.release()
outcome.get() catch failure:
print(f"unexpected UI failure: {failure.message}")
assert(false)
func allocations(tracker: Tracker*) -> !:
var succeeded = false
var failures: usize = 0
for stage in 0..<20:
tracker.remaining = (usize)stage
let control: interop.Reference[Button]? = new_button("owned label") catch failure:
assert(failure.code == memory.exhausted)
failures += 1
recover none
if let value = control:
value.release()
succeeded = true
tracker.remaining = none
ownership.collect()
assert(tracker.live == 0)
assert(succeeded and failures >= 4)
func new_stack() -> interop.Reference[DStack]!:
let button = try new_button("content")
defer button.release()
let widget = button.as_interface[Widget](button.value())
defer widget.release()
let panel = try interop.Reference[Panel].adopt(new Panel("Example", widget) in memory.heap, ui.panel_type, memory.heap)
defer panel.release()
return try interop.Reference[DStack].adopt(new DStack([panel]) in memory.heap, ui.dstack_type, memory.heap)
func docking_allocations(tracker: Tracker*) -> !:
# Runtime candidate buffers grow infallibly. Reserve their normal capacity
# before testing fallible package allocations, then account for that cache.
let warmup = try new_stack()
warmup.release()
ownership.collect()
let baseline = tracker.live
var succeeded = false
var failures: usize = 0
for stage in 0..<160:
tracker.remaining = (usize)stage
let stack: interop.Reference[DStack]? = new_stack() catch failure:
assert(failure.code == memory.exhausted)
failures += 1
recover none
if let retained = stack:
assert(retained.value().panel_count() == 1)
retained.release()
succeeded = true
tracker.remaining = none
ownership.collect()
assert(tracker.live == baseline)
assert(succeeded and failures > 20)
assert(ownership.finish_run(0) == 0)
assert(tracker.live == 0)
func ownership_and_layout(tracker: Tracker*) -> !:
let control = try new_button("pause")
defer control.release()
let widget = control.as_interface[Widget](control.value())
defer widget.release()
let flexible = try interop.Reference[Spacer].adopt(new Spacer(1.0) in memory.heap, ui.spacer_type, memory.heap)
defer flexible.release()
let space = flexible.as_interface[Widget](flexible.value())
defer space.release()
let row = try interop.Reference[HStack].adopt(new HStack([widget, space], 10.0, 20.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()
try expect(app.value().layout(300.0, 100.0))
let box = control.value().layout()
defer box.release()
let bounds = box.value().bounds()
assert(bounds.x == 20.0 and bounds.y == 20.0 and bounds.width > 45.0 and bounds.width < 75.0 and bounds.height == 60.0)
let spacer_box = flexible.value().layout()
defer spacer_box.release()
let spare = spacer_box.value().bounds()
assert(spare.x == bounds.x + bounds.width + 10.0 and spare.width == 280.0 - spare.x)
try spacer_box.value().set_limits(Size(), Size(50.0, 16384.0))
try expect(app.value().layout(300.0, 100.0))
assert(spacer_box.value().bounds().width == 50.0)
try box.value().set_limits(Size(40.0, 20.0), Size(16384.0, 16384.0))
try expect(app.value().layout(60.0, 20.0))
assert(box.value().bounds().width == 40.0 and spacer_box.value().bounds().width == 0.0)
var duplicate = false
row.value().set_children([widget, widget]) catch failure:
assert(failure.code == ui.invalid)
duplicate = true
assert(duplicate)
var cyclic = false
row.value().set_children([root]) catch failure:
assert(failure.code == ui.busy or failure.code == ui.invalid)
cyclic = true
assert(cyclic)
let row_box = row.value().layout()
defer row_box.release()
assert(row_box.value().child_count() == 2)
let baseline = tracker.live
tracker.remaining = 0
var refused = false
row.value().set_children([space, widget]) catch failure:
assert(failure.code == memory.exhausted)
refused = true
tracker.remaining = none
assert(refused and tracker.live == baseline)
assert(row_box.value().child_count() == 2)
let first = try row_box.value().child(0)
defer first.release()
assert(first.owner == widget.owner)
let other = try interop.Reference[Application].adopt(new Application(root) in memory.heap, ui.application_type, memory.heap)
defer other.release()
let shared = other.value().layout(300.0, 100.0)
defer shared.release()
assert(not shared.is_success())
var empty: interop.Interface[Widget][]
try row.value().set_children(empty)
try expect(app.value().layout(300.0, 100.0))
assert(row_box.value().child_count() == 0)
try row.value().set_children([widget])
try expect(app.value().layout(300.0, 100.0))
func game_mode() -> !:
let flexible = try interop.Reference[Spacer].adopt(new Spacer(1.0) in memory.heap, ui.spacer_type, memory.heap)
defer flexible.release()
let space = flexible.as_interface[Widget](flexible.value())
defer space.release()
let app = try interop.Reference[Application].adopt(new Application(space, game = true, fps = 70.0) in memory.heap, ui.application_type, memory.heap)
defer app.release()
assert(app.value().is_game() and app.value().fps() == 70.0)
assert(not app.value().is_fullscreen())
app.value().set_game(false)
assert(not app.value().is_game())
try app.value().set_fps(0.0)
assert(app.value().fps() == 0.0)
var rejected = false
app.value().set_fps(-1.0) catch failure:
assert(failure.code == ui.invalid)
rejected = true
assert(rejected)
rejected = false
let invalid: interop.Reference[Application]? = interop.Reference[Application].adopt(new Application(space, fps = 1001.0) in memory.heap, ui.application_type, memory.heap) catch failure:
assert(failure.code == ui.invalid)
rejected = true
recover none
assert(rejected and invalid == none)
func shared_font() -> !:
let font = try interop.Reference[Font].adopt(new Font(size = 18.0) in memory.heap, ui.font_type, memory.heap)
let expected_width = try font.value().measure("Save") + ui.Theme().inset(font) * 2.0
var control = Button("Save", font = font) catch failure:
font.release()
error(failure.code, failure.message)
defer control.close()
font.release()
let measured = control.measure(ui.Constraints())
defer measured.release()
assert((try measured.get()).width == expected_width)
func drawing() -> !:
var font = try Font()
defer font.close()
assert(try font.measure("iii") == try font.measure("WWW"))
assert(try font.measure("aAĆ©") == 3.0 * font.advance())
var frame = try gpu.Frame(window.Size(100.0, 80.0, 200.0, 160.0, 2.0))
let target = try frame.target()
defer target.release()
var painter = try Painter(target)
defer painter.close()
try painter.text("Case preserved")
frame.close()
var expired = false
painter.rectangle(Rect(width = 20.0, height = 20.0), gpu.Color()) catch failure:
assert(failure.code == interop.expired)
expired = true
assert(expired)
## Holds an application, as a crash hook that saves its document would.
struct Saver:
var app: interop.Reference[Application]?
func save(argument: unit) -> interop.Outcome[unit]:
_ = argument
return interop.Outcome[unit].success(interop.Owned[unit](()))
func close():
if let app = self.app:
self.app = none
app.release()
func trace(visit: func(ownership.Object*, void*) -> unit, context: void*):
if let app = self.app:
app.trace(visit, context)
let saver_type: interop.Type[Saver] = interop.Type[Saver]("crash hook saver", Saver.close, Saver.trace)
## A crash hook that captures the application is removed by `close`: nothing it held
## outlives the application, and the handle the caller dropped early did not remove it.
func crash_hooks() -> !:
let button = try new_button("save")
defer button.release()
let widget = button.as_interface[Widget](button.value())
defer widget.release()
let app = try interop.Reference[Application].adopt(new Application(widget) in memory.heap, ui.application_type, memory.heap)
defer app.release()
let saver = try interop.Reference[Saver].adopt(new Saver(app = app.clone()) in memory.heap, saver_type, memory.heap)
defer saver.release()
let callback = try interop.Callback[unit, unit].bind_mutating(saver, Saver.save)
defer callback.release()
let kept = try app.value().on_crash(callback)
let dropped = try app.value().on_crash(callback)
dropped.release()
assert(kept.value().is_active())
app.value().close()
assert(not kept.value().is_active())
kept.release()
func construct_on_worker(context: void*?):
let rejected = (bool*)(context else trap("missing thread result"))
let layout: Layout? = Layout() catch failure:
assert(failure.code == interop.wrong_thread)
*rejected = true
recover none
assert(layout == none)
pub func main(arguments: str[]) -> i32!:
var rejected = false
let worker = try thread.spawn(construct_on_worker, (void*)&rejected)
try worker.join()
assert(rejected)
# crash reports keep a signal stack for the process: made before allocations are counted
try crash.enable()
var tracker = Tracker(upstream = memory.heap)
let previous = memory.heap
memory.heap = &tracker
defer restore(previous)
with tracker:
try allocations(&tracker)
try docking_allocations(&tracker)
try layout_cycles.collect()
assert(ownership.finish_run(0) == 0)
try layout_cycles.relayout_during_collection()
assert(ownership.finish_run(0) == 0)
assert(tracker.live == 0)
try ownership_and_layout(&tracker)
assert(ownership.finish_run(0) == 0)
assert(tracker.live == 0)
try shared_font()
try game_mode()
try drawing()
assert(ownership.finish_run(0) == 0)
assert(tracker.live == 0)
try crash_hooks()
ownership.collect()
assert(ownership.finish_run(0) == 0)
assert(tracker.live == 0)
print("ok UI ownership, allocation, layout and drawing scopes")
return 0