Orkuncakilkaya
66a2bc2214
A `view Name { field = x; function q(..); on e(..) }` declaration is the one bridge between a
program and its UI: it writes view_<name>() -> UiView, whose model is a Value of every field and
whose call runs a query or an event by name.
ludic.ui is a template runtime:
- HTML-shaped XML screens and components, loaded at run time;
- {expression} bindings, if/else/each, props, slots, per-instance state;
- on-press / onclick actions (event, set, emit);
- component libraries (export="true", <import src as>).
Styling:
- stylesheets in <style> or importable .lss files (@import);
- CSS selectors (#id, .class, [attr=v], descendant and > combinators, :hover, :disabled,
:first-child, :last-child, :nth-child, :not) weighed by specificity;
- the box model and flex under CSS's property names.
Also:
- default parameters, and positional-then-named calls;
- Value gains a float kind;
- a function shadowing a runtime one is refused;
- an index is evaluated before the slice is read;
- runtime errors name the right file.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
99 lines
4 KiB
Text
99 lines
4 KiB
Text
# layout_run.ludic - a box's children given their places: along its direction by size, grow and
|
|
# justify, across it by align (or each child's own `self`), a wrapping row one line at a time
|
|
var ly_lead: float = 0.0
|
|
var ly_extra: float = 0.0
|
|
function ly_place(n: UiNode, x: float, y: float, w: float, h: float) -> void {
|
|
n.x = x
|
|
n.y = y
|
|
n.cw = w
|
|
n.ch = h
|
|
if (n.kind != UI_BOX and n.kind != UI_SCROLL) or n.children == null { return }
|
|
let inner_w = w - ly_hin(n)
|
|
var inner_h = h - ly_vin(n)
|
|
if n.kind == UI_SCROLL { inner_h = Math.max(n.mh, h) - ly_vin(n) }
|
|
let top = n.y + n.pt + n.border
|
|
if n.dir == UI_ROW and n.wrap {
|
|
ly_place_wrap(n, top, inner_w)
|
|
return
|
|
}
|
|
if n.dir == UI_ROW { ly_place_line(n, 0, len(n.children), top, inner_w, inner_h) } else { ly_place_line(n, 0, len(n.children), top, inner_h, inner_w) }
|
|
}
|
|
function ly_fills(c: UiNode, dir: int) -> bool {
|
|
if dir == UI_ROW { return c.w == UI_FILL }
|
|
return c.h == UI_FILL
|
|
}
|
|
function ly_grow(c: UiNode, dir: int) -> float {
|
|
if ly_fills(c, dir) { return Math.max(c.grow, 1.0) }
|
|
return c.grow
|
|
}
|
|
# where a child starts along the run: `fill` from nothing, a percentage from the room it is in
|
|
function ly_basis(c: UiNode, dir: int, room: float) -> float {
|
|
if ly_fills(c, dir) { return 0.0 }
|
|
if dir == UI_ROW and c.w_pct > 0.0 { return room * c.w_pct / 100.0 + c.ml + c.mr }
|
|
if dir == UI_COL and c.h_pct > 0.0 { return room * c.h_pct / 100.0 + c.mt + c.mb }
|
|
return ly_main(c, dir)
|
|
}
|
|
function ly_stretches(n: UiNode, c: UiNode) -> bool {
|
|
if ly_fills(c, 1 - n.dir) { return true }
|
|
var a = n.align
|
|
if c.self >= 0 { a = c.self }
|
|
return a == UI_STRETCH
|
|
}
|
|
# children from..to along one line starting at `top`: sizes, the spare room, then each place
|
|
function ly_place_line(n: UiNode, from: int, to: int, top: float, main_room: float, cross_room: float) -> void {
|
|
var used = 0.0
|
|
var grows = 0.0
|
|
for i in from .. to {
|
|
used = used + ly_basis(n.children[i], n.dir, main_room)
|
|
grows = grows + ly_grow(n.children[i], n.dir)
|
|
}
|
|
used = used + n.gap * float(Math.max(to - from - 1, 0))
|
|
let free = main_room - used
|
|
ly_justify(n, free, to - from, grows)
|
|
let extra = ly_extra
|
|
var at = ly_lead
|
|
for i in from .. to {
|
|
let c = n.children[i]
|
|
var m = ly_basis(c, n.dir, main_room)
|
|
if grows > 0.0 and free > 0.0 { m = m + free * ly_grow(c, n.dir) / grows }
|
|
ly_place_child(n, c, at, top, m, cross_room)
|
|
at = at + m + n.gap + extra
|
|
}
|
|
}
|
|
# one child: `m` along the run and its own size (or the whole room, stretched) across, less margins
|
|
function ly_place_child(n: UiNode, c: UiNode, at: float, top: float, m: float, cross_room: float) -> void {
|
|
var cr = ly_cross(c, n.dir)
|
|
if n.dir == UI_ROW and c.h_pct > 0.0 { cr = cross_room * c.h_pct / 100.0 + c.mt + c.mb }
|
|
if n.dir == UI_COL and c.w_pct > 0.0 { cr = cross_room * c.w_pct / 100.0 + c.ml + c.mr }
|
|
if ly_stretches(n, c) { cr = cross_room }
|
|
var a = n.align
|
|
if c.self >= 0 { a = c.self }
|
|
var off = 0.0
|
|
if a == UI_CENTER { off = (cross_room - cr) / 2.0 }
|
|
if a == UI_END { off = cross_room - cr }
|
|
let left = n.x + n.pl + n.border
|
|
if n.dir == UI_ROW {
|
|
let cw = ly_clamp(m - c.ml - c.mr, c.min_w, c.max_w)
|
|
ly_place(c, left + at + c.ml, top + off + c.mt, cw, ly_clamp(cr - c.mt - c.mb, c.min_h, c.max_h))
|
|
} else {
|
|
let chh = ly_clamp(m - c.mt - c.mb, c.min_h, c.max_h)
|
|
ly_place(c, left + off + c.ml, top + at + c.mt, ly_clamp(cr - c.ml - c.mr, c.min_w, c.max_w), chh)
|
|
}
|
|
}
|
|
# where the first child starts and what goes between, when nothing grows into the spare room
|
|
function ly_justify(n: UiNode, free: float, count: int, grows: float) -> void {
|
|
ly_lead = 0.0
|
|
ly_extra = 0.0
|
|
if grows > 0.0 or free <= 0.0 or count == 0 { return }
|
|
if n.justify == UI_CENTER { ly_lead = free / 2.0 }
|
|
if n.justify == UI_END { ly_lead = free }
|
|
if n.justify == UI_BETWEEN and count > 1 { ly_extra = free / float(count - 1) }
|
|
if n.justify == UI_AROUND {
|
|
ly_extra = free / float(count)
|
|
ly_lead = ly_extra / 2.0
|
|
}
|
|
if n.justify == UI_EVENLY {
|
|
ly_extra = free / float(count + 1)
|
|
ly_lead = ly_extra
|
|
}
|
|
}
|