Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-ui

Source of release 0.19.1

0.19.1 / src / widgets / parameters / popups.lucb

#==============================================================================================
#
#   widgets/parameters/popups - The value ladder
#
#==============================================================================================

## The ladder floats over the window without taking input: the panel keeps the
## pointer through the ladder's drag. The row tooltip is a widgets.tooltip Tooltip.
func float_box() -> interop.Reference[Layout]!:
    let box = try layout.make_layout()
    box.value().set_popup(true)
    box.value().set_modal(false)
    box.value().set_popup_placement(layout.PopupPlacement.point)
    box.value().set_visible(false)
    return box

## Houdini's value ladder: a column of steps, the chosen one lit.
pub struct ValueLadder: Widget:
    let box: interop.Reference[Layout]
    let font: interop.Reference[Font]
    pub var rungs: f64[8]
    pub var count: usize
    pub var start: usize
    var selected: usize

    pub func init(font: interop.Reference[Font]) -> !:
        self.box = try float_box()
        self.font = font.clone()
        self.rungs = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
        self.count = 0
        self.start = 0
        self.selected = 0

    pub func layout() -> interop.Reference[Layout]:
        return self.box.clone()

    ## Show `count` of `rungs`, `start` lit, with its top-left at (`x`, `y`).
    pub func show(rungs: f64[8], count: usize, start: usize, x: f64, y: f64) -> !:
        self.rungs = rungs
        self.count = count
        self.start = start
        self.selected = start
        try self.box.value().set_popup_point(x, y)
        self.box.value().set_visible(true)

    pub func select(rung: usize):
        self.selected = rung
        self.box.value().invalidate()

    pub func hide():
        self.box.value().set_visible(false)

    func cell() -> f64:
        return math.max(20.0, self.box.value().theme().row_height(self.font))

    pub func measure(available: Constraints) -> interop.Outcome[Size]:
        return result.success[Size](Size(80.0, self.cell() * (f64)self.count + 1.0))

    pub func draw(target: interop.View[gpu.RenderTarget]) -> interop.Outcome[unit]:
        self.paint(target) catch failure:
            return result.failure[unit](failure.code, failure.message)
        return result.success[unit](())

    func paint(target: interop.View[gpu.RenderTarget]) -> !:
        var painter = try Painter(target)
        defer painter.close()
        let size = try target.get().size()
        let theme = self.box.value().theme()
        let cell = self.cell()
        try painter.rectangle(Rect(width = size.width, height = size.height), theme.border)
        for rung in 0..<self.count:
            let lit = rung == self.selected
            let y = (f64)rung * cell
            try painter.rectangle(Rect(1.0, y + 1.0, size.width - 2.0, cell - 1.0), theme.accent if lit else theme.raised)
            var digits: u8[48]
            let step = self.rungs[rung]
            let decimals = (i64)math.clamp(-math.floor(math.log10(step) + 1.0e-9), 0.0, 9.0)
            let shown = try format_number(digits, step, decimals)
            let x = math.floor((size.width - text_width(self.font, shown)) * 0.5)
            try painter.text(shown, x, y + math.floor((cell - self.font.value().height()) * 0.5), theme.accent_text if lit else theme.foreground, self.font)

    pub func event(event: Event) -> interop.Outcome[unit]:
        return result.success[unit](())

    pub func close():
        self.font.release()
        self.box.release()

    func trace(visit: func(ownership.Object*, void*) -> unit, context: void*):
        self.box.trace(visit, context)
        self.font.trace(visit, context)

pub let value_ladder_type: interop.Type[ValueLadder] = interop.Type[ValueLadder]("ValueLadder", ValueLadder.close, ValueLadder.trace, closeable = true, main_thread = true)