103 lines
4.4 KiB
Text
103 lines
4.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
|
|
function ly_place(ui_st: mut UiState, 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.content_h, h) - ly_vin(n) }
|
|
let top = n.y + n.pt + n.bt
|
|
if n.dir == UI_ROW and n.wrap { ly_place_wrap(ui_st, n, top, inner_w) } else if n.dir == UI_ROW { ly_place_line(ui_st, n, 0, len(n.children), top, inner_w, inner_h) } else { ly_place_line(ui_st, n, 0, len(n.children), top, inner_h, inner_w) }
|
|
for i in 0 .. len(n.children) {
|
|
if n.children[i].pos >= 2 { ly_place_abs(ui_st, n, n.children[i]) }
|
|
}
|
|
}
|
|
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 ly_pw(c, room) + c.ml + c.mr }
|
|
if dir == UI_COL and c.h_pct > 0.0 { return ly_ph(c, room) + 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(ui_st: mut UiState, n: UiNode, from: int, to: int, top: float, main_room: float, cross_room: float) -> void {
|
|
var used = 0.0
|
|
var grows = 0.0
|
|
var count = 0
|
|
let depth = ui_st.ly_depth
|
|
ui_st.ly_depth += 1
|
|
let sizes = ly_scratch(ui_st, depth)
|
|
for i in from .. to {
|
|
ui_kept(sizes, ly_basis(n.children[i], n.dir, main_room))
|
|
if n.children[i].pos < 2 {
|
|
used = used + sizes[i - from]
|
|
grows = grows + ly_grow(n.children[i], n.dir)
|
|
count += 1
|
|
}
|
|
}
|
|
used = used + n.gap * float(Math.max(count - 1, 0))
|
|
let free = main_room - used
|
|
if free < 0.0 { ly_shrink_line(ui_st, depth, n, from, sizes, 0.0 - free) }
|
|
ly_justify(ui_st, n, free, count, grows)
|
|
let extra = ui_st.ly_extra
|
|
var at = ui_st.ly_lead
|
|
for i in from .. to {
|
|
let c = n.children[i]
|
|
if c.pos >= 2 { continue }
|
|
var m = sizes[i - from]
|
|
if grows > 0.0 and free > 0.0 { m = m + free * ly_grow(c, n.dir) / grows }
|
|
ly_place_child(ui_st, n, c, at, top, m, cross_room)
|
|
if c.pos == 1 { ly_nudge(n, c) }
|
|
at = at + m + n.gap + extra
|
|
}
|
|
ui_st.ly_depth = depth
|
|
}
|
|
# a line's sizes, and its shrink's frozen flags, in lists kept one a depth (a line's children lay out
|
|
# their own lines while it is still placing them), emptied rather than made anew
|
|
function ly_scratch(ui_st: mut UiState, depth: int) -> []float {
|
|
while len(ui_st.ly_sizes) <= depth {
|
|
@alloc_ok("once per depth of nesting, then kept")
|
|
push(ui_st.ly_sizes, new []float)
|
|
@alloc_ok("once per depth of nesting, then kept")
|
|
push(ui_st.ly_frozen, new []bool)
|
|
}
|
|
List.clear(ui_st.ly_sizes[depth])
|
|
return ui_st.ly_sizes[depth]
|
|
}
|
|
# one child: `m` along the run and its own size (or the whole room, stretched) across, less margins
|
|
function ly_place_child(ui_st: mut UiState, 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 = ly_ph(c, cross_room) + c.mt + c.mb }
|
|
if n.dir == UI_COL and c.w_pct > 0.0 { cr = ly_pw(c, cross_room) + 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.bl
|
|
if n.dir == UI_ROW {
|
|
let cw = ly_clamp(m - c.ml - c.mr, c.min_w, c.max_w)
|
|
ly_place(ui_st, 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(ui_st, c, left + off + c.ml, top + at + c.mt, ly_clamp(cr - c.ml - c.mr, c.min_w, c.max_w), chh)
|
|
}
|
|
}
|