Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-ui

Source of release 0.19.1

0.19.1 / src / widgets / slider.lucb

## The Slider widget: a labeled horizontal value slider.
from luce_gpu import gpu
import interop
from luce_std import math
import ownership
import memory
import layout
import result
from layout import Widget, Layout, Size, Constraints, Event
from painter import Painter
from luce_window import input
from font import Font, selected_font
from widgets.number_field import format_number

## A horizontal slider over `minimum..maximum` with an optional label and the
## value shown after it. Dragging anywhere on the track sets the value; arrow
## keys step by `step` (a tenth of the range when zero), shift by ten steps,
## and Home and End jump to the bounds.
## `on_change` fires with the new value on every change the user makes; the
## value can also be set from code without a signal. `show_value = false`
## leaves the readout to a field beside the slider.
pub struct Slider: Widget:
    let box: interop.Reference[Layout]
    let font: interop.Reference[Font]
    var caption: interop.Owned[str]
    var minimum: f64
    var maximum: f64
    var step: f64
    var current: f64
    var decimals: i64
    var dragging: bool
    var show_value: bool
    let changed: interop.Signal[f64]

    pub func init(text: str = "", minimum: f64 = 0.0, maximum: f64 = 1.0, value: f64 = 0.0, step: f64 = 0.0, decimals: i64 = 0,
                  font: interop.Reference[Font]? = none, show_value: bool = true) -> !:
        if not math.is_finite(minimum) or not math.is_finite(maximum) or maximum <= minimum or not math.is_finite(value) or not math.is_finite(step) or step < 0.0:
            error(result.invalid, "a slider needs finite bounds with maximum above minimum, a finite value and a nonnegative step")
        if decimals < 0 or decimals > 6:
            error(result.invalid, "slider decimals must be 0..6")
        var selected = try selected_font(font)
        errdefer selected.release()
        _ = try selected.value().measure(text)
        let box = try layout.make_layout()
        errdefer box.release()
        try box.value().set_shrink(vertical = 0.0)
        box.value().set_focusable(true)
        box.value().set_cursor(input.Cursor.pointer)
        let signal = try interop.Signal[f64]()
        errdefer signal.release()
        self.caption = try interop.copy_text(text)
        self.box = box
        self.font = selected
        self.minimum = minimum
        self.maximum = maximum
        self.step = step
        self.current = math.clamp(value, minimum, maximum)
        self.decimals = decimals
        self.dragging = false
        self.show_value = show_value
        self.changed = signal

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

    pub func value() -> f64:
        return self.current

    ## Set the value from code, clamped; no change signal.
    pub func set_value(value: f64) -> !:
        if not math.is_finite(value):
            error(result.invalid, "slider values must be finite")
        self.current = math.clamp(value, self.minimum, self.maximum)
        self.box.value().invalidate()

    ## Change the bounds and re-clamp the value; no change signal.
    pub func set_range(minimum: f64, maximum: f64) -> !:
        if not math.is_finite(minimum) or not math.is_finite(maximum) or maximum <= minimum:
            error(result.invalid, "a slider needs finite bounds with maximum above minimum")
        self.minimum = minimum
        self.maximum = maximum
        self.current = math.clamp(self.current, minimum, maximum)
        self.box.value().invalidate()

    pub func on_change(callback: interop.Callback[f64, unit]) -> interop.Reference[interop.Connection]!:
        return try self.changed.connect(callback)

    func change(value: f64) -> interop.Outcome[unit]:
        let clamped = math.clamp(value, self.minimum, self.maximum)
        if clamped == self.current:
            return result.success[unit](())
        self.current = clamped
        self.box.value().invalidate()
        return self.changed.emit(clamped)

    func label_width() -> f64:
        let width = self.font.value().measure(self.caption.value) catch failure:
            _ = failure
            recover 0.0
        return width + self.font.value().advance() if self.caption.value.length > 0 else 0.0

    ## The value's text width: room for the widest number in range at the decimals shown.
    func value_width() -> f64:
        if not self.show_value:
            return 0.0
        var digits: i64 = 1
        var magnitude = math.max(math.abs(self.minimum), math.abs(self.maximum))
        while magnitude >= 10.0 and digits < 12:
            magnitude /= 10.0
            digits += 1
        let count = digits + (1 if self.minimum < 0.0 else 0) + (self.decimals + 1 if self.decimals > 0 else 0)
        return (f64)count * self.font.value().advance()

    ## The track's rectangle within the widget.
    func track(width: f64, height: f64) -> gpu.Rect:
        let left = self.label_width()
        let right = self.value_width() + self.font.value().advance() if self.show_value else 0.0
        return gpu.Rect(left, 0.0, math.max(8.0, width - left - right), height)

    pub func measure(available: Constraints) -> interop.Outcome[Size]:
        let width = self.label_width() + 120.0 + (self.value_width() + self.font.value().advance() if self.show_value else 0.0)
        return result.success[Size](Size(width, self.box.value().theme().row_height(self.font)))

    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 enabled = self.box.value().is_enabled()
        let text_y = math.max(0.0, (size.height - self.font.value().height()) * 0.5)
        if self.caption.value.length > 0:
            try painter.text(self.caption.value, 0.0, text_y, color = theme.foreground if enabled else theme.muted, font = self.font)
        let rail = self.track(size.width, size.height)
        let thickness = 2.0
        let middle = rail.y + math.floor((rail.height - thickness) * 0.5)
        try painter.rectangle(gpu.Rect(rail.x, middle, rail.width, thickness), theme.border)
        let fraction = (self.current - self.minimum) / (self.maximum - self.minimum)
        let knob = 8.0
        let filled = math.floor((rail.width - knob) * fraction)
        try painter.rectangle(gpu.Rect(rail.x, middle, filled + knob * 0.5, thickness), theme.accent if enabled else theme.muted)
        let knob_height = math.min(rail.height, 14.0)
        let knob_color = theme.accent if enabled and (self.dragging or self.box.value().contains_pointer() or self.box.value().is_focused()) else theme.foreground
        try painter.rectangle(gpu.Rect(rail.x + filled, rail.y + math.floor((rail.height - knob_height) * 0.5), knob, knob_height), knob_color if enabled else theme.muted)
        if not self.show_value:
            return
        var digits: u8[32]
        let shown = try format_number(digits, self.current, self.decimals)
        try painter.text(shown, rail.x + rail.width + self.font.value().advance(), text_y, color = theme.foreground if enabled else theme.muted, font = self.font)

    func value_at(x: f64, width: f64, height: f64) -> f64:
        let rail = self.track(width, height)
        let knob = 8.0
        let fraction = math.clamp((x - rail.x - knob * 0.5) / math.max(1.0, rail.width - knob), 0.0, 1.0)
        return self.snap(self.minimum + fraction * (self.maximum - self.minimum))

    func snap(value: f64) -> f64:
        if self.step <= 0.0:
            return value
        return self.minimum + math.floor((value - self.minimum) / self.step + 0.5) * self.step

    func increment() -> f64:
        return self.step if self.step > 0.0 else (self.maximum - self.minimum) * 0.1

    pub func event(event: Event) -> interop.Outcome[unit]:
        if event.cancelled:
            self.dragging = false
            self.box.value().invalidate()
            return result.success[unit](())
        if not self.box.value().is_enabled():
            return result.success[unit](())
        let bounds = self.box.value().bounds()
        if event.kind == input.EventKind.pointer_down and event.button == 0 and event.inside:
            self.dragging = true
            return self.change(self.value_at(event.x, bounds.width, bounds.height))
        if event.kind == input.EventKind.pointer_moved:
            if self.dragging:
                return self.change(self.value_at(event.x, bounds.width, bounds.height))
            self.box.value().invalidate()
        elif event.kind == input.EventKind.pointer_up and event.button == 0:
            self.dragging = false
            self.box.value().invalidate()
        elif event.kind == input.EventKind.key_down:
            let amount = self.increment() * (10.0 if event.shift else 1.0)
            if event.key == input.Key.left or event.key == input.Key.down:
                return self.change(self.current - amount)
            if event.key == input.Key.right or event.key == input.Key.up:
                return self.change(self.current + amount)
            if event.key == input.Key.home:
                return self.change(self.minimum)
            if event.key == input.Key.end:
                return self.change(self.maximum)
        return result.success[unit](())

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

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

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

test "slider values clamp, snap and format":
    var slider = try Slider("Size", 1.0, 200.0, 40.0, 1.0)
    defer slider.close()
    assert(slider.value() == 40.0)
    try slider.set_value(500.0)
    assert(slider.value() == 200.0)
    assert(slider.snap(3.4) == 3.0 and slider.snap(3.6) == 4.0)
    var digits: u8[32]
    assert((try format_number(digits, 40.0, 0)) == "40")
    assert((try format_number(digits, 0.756, 2)) == "0.76")
    assert((try format_number(digits, -12.5, 1)) == "-12.5")
    assert((try format_number(digits, 0.0, 1)) == "0.0")
    var rejected = false
    _ = Slider("Bad", 1.0, 1.0) catch failure:
        assert(failure.code == result.invalid)
        rejected = true
        recover try Slider()
    assert(rejected)