Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-ui

Source of release 0.19.3

0.19.3 / src / widgets / parameters / input.lucb

#==============================================================================================
#
#   widgets/parameters/input - Pointer gestures: scrubbing, the value ladder, clicks, menus
#
#==============================================================================================

## A scrub moves this many steps per point; Shift ten times as many, Alt a tenth.
let scrub_rate: f64 = 0.5
## The value ladder moves one rung's step per this many points across.
let ladder_pitch: f64 = 12.0

extend ParameterPanel:
    func handle(event: Event) -> !:
        if event.cancelled:
            try self.cancel()
            return
        self.arrange(self.box.value().bounds().width)
        if self.edit_row >= 0 and try self.editing_event(event):
            return
        let kind = event.kind
        if kind == input.EventKind.pointer_moved or kind == input.EventKind.pointer_entered:
            try self.moved(event)
        elif kind == input.EventKind.pointer_left:
            self.set_hot(-1, part_none, 0)
            self.hide_tip()
        elif kind == input.EventKind.pointer_down and event.button == 0 and event.inside:
            try self.press(event)
        elif kind == input.EventKind.pointer_down and event.button == 1:
            if not try self.remove_at(event.x, event.y):
                try self.open_context(event.x, event.y)
        elif kind == input.EventKind.pointer_down and event.button == 2 and event.inside:
            try self.start_ladder(event)
        elif kind == input.EventKind.pointer_up and event.button == 0:
            try self.release(event)
        elif kind == input.EventKind.pointer_up and event.button == 2 and self.laddering:
            self.laddering = false
            self.press_row = -1
            self.ladder.value().hide()
            try self.finish()
        elif kind == input.EventKind.key_down:
            try self.key(event)

    ## The press is gone (focus moved, the window lost it): a drag keeps what
    ## it reached and commits; typing keeps what was typed, as a field left does.
    func cancel() -> !:
        let dragged = self.scrubbing or self.laddering or self.press_part == part_slider or self.press_part == part_curve
        self.scrubbing = false
        self.laddering = false
        self.press_row = -1
        self.press_part = part_none
        self.ladder.value().hide()
        self.hide_tip()
        if dragged:
            try self.finish()
        if self.edit_row >= 0:
            try self.end_editing(true)
        self.box.value().invalidate()

    # -- Hover.

    func set_hot(row: i64, part: i64, component: i64):
        if row == self.hot_row and part == self.hot_part and component == self.hot_component:
            return
        self.hot_row = row
        self.hot_part = part
        self.hot_component = component
        self.box.value().set_cursor(self.cursor_for(row, part))
        self.box.value().invalidate()

    ## Scrubbable parts show the resize cursor, as every scrubber does; typing
    ## fields the text cursor; things to click the pointer.
    func cursor_for(row: i64, part: i64) -> input.Cursor:
        if row < 0 or (part != part_folder and not self.enabled((usize)row)):
            return input.Cursor.arrow
        let kind = self.rows[(usize)row].kind
        if (part == part_field or part == part_label) and numeric(kind):
            return input.Cursor.resize_horizontal
        if part == part_field:
            return input.Cursor.text
        if part == part_none or part == part_label:
            return input.Cursor.arrow
        return input.Cursor.pointer

    func moved(event: Event) -> !:
        if self.laddering:
            try self.climb(event)
            return
        if self.press_part == part_slider and self.press_row >= 0:
            try self.slide(event.x)
            return
        if self.press_part == part_curve and self.press_row >= 0:
            try self.drag_point(event)
            return
        if (self.press_part == part_field or self.press_part == part_label) and self.press_row >= 0 and numeric(self.rows[(usize)self.press_row].kind):
            try self.scrub(event)
            return
        if self.press_row >= 0:
            return
        let (row, part, component) = self.hit(event.x, event.y)
        self.set_hot(row, part, component)
        self.schedule_tip(row)

    # -- Presses.

    func press(event: Event) -> !:
        self.hide_tip()
        let (row, part, component) = self.hit(event.x, event.y)
        self.set_hot(row, part, component)
        if row < 0:
            return
        let index = (usize)row
        if part == part_folder:
            let open = not self.rows[index].open
            self.rows[index].open = open
            try self.remember_folder(self.rows[index].name.value, open)
            self.stale = true
            self.box.value().invalidate()
            return
        if not self.enabled(index):
            return
        let kind = self.rows[index].kind
        if kind != ParameterKind.info and kind != ParameterKind.separator:
            self.current = row
        if part == part_toggle:
            var values = self.rows[index].values
            values[0] = 0.0 if values[0] != 0.0 else 1.0
            try self.edit(index, values)
            return
        if part == part_curve:
            try self.press_curve(index, event)
            return
        if part == part_chip:
            var values = self.rows[index].values
            if component >= 0 and (f64)component != values[0]:
                values[0] = (f64)component
                try self.edit(index, values)
            return
        if (part == part_field or part == part_label) and numeric(kind) and (event.control or event.meta):
            # Cmd/Ctrl-click puts the default back, as the number field does.
            try self.revert(index)
            return
        if part == part_none or (part == part_label and not numeric(kind)):
            return
        self.press_row = row
        self.press_part = part
        self.press_component = component
        self.press_x = event.x
        self.press_y = event.y
        self.press_values = self.rows[index].values
        self.scrubbing = false
        if part == part_slider:
            try self.begin(row)
            try self.slide(event.x)
        self.box.value().invalidate()

    func release(event: Event) -> !:
        let row = self.press_row
        let part = self.press_part
        let component = self.press_component
        let scrubbed = self.scrubbing
        self.press_row = -1
        self.press_part = part_none
        self.scrubbing = false
        self.box.value().invalidate()
        if row < 0 or row >= (i64)self.total:
            return
        if scrubbed or part == part_slider or part == part_curve:
            try self.finish()
            return
        let (at, over, over_component) = self.hit(event.x, event.y)
        if at != row or over != part or (part == part_field and over_component != component):
            return
        let index = (usize)row
        if part == part_field:
            try self.begin_editing(row, component)
        elif part == part_menu and is_ramp(self.rows[index].kind):
            try self.open_interpolation(index)
        elif part == part_menu:
            try self.open_items(index)
        elif part == part_swatch and is_ramp(self.rows[index].kind):
            try self.open_point_color(index)
        elif part == part_swatch:
            try self.open_color(index)
        elif part == part_browse or part == part_button:
            try ParameterPanel.emit(self.activated, row)

    ## Scrubbing a field or its label: each point across moves the value by
    ## half a step (Shift ten times, Alt a tenth); the label moves every
    ## component of a vector together.
    func scrub(event: Event) -> !:
        let row = self.press_row
        let index = (usize)row
        let travelled = event.x - self.press_x
        if not self.scrubbing:
            if math.abs(travelled) < 3.0:
                return
            self.scrubbing = true
            self.press_x = event.x
            self.press_rate = ParameterPanel.increment(self.rows[index]) * scrub_rate * modifier(event)
            try self.begin(row)
            return
        if row >= (i64)self.total:
            return
        let rate = ParameterPanel.increment(self.rows[index]) * scrub_rate * modifier(event)
        if rate != self.press_rate:
            # A modifier pressed mid-drag goes on from here, rather than jumping.
            self.press_rate = rate
            self.press_values = self.rows[index].values
            self.press_x = event.x
            return
        var values = self.rows[index].values
        for component in 0..<self.rows[index].components:
            if self.press_part == part_field and component != self.press_component:
                continue
            values[(usize)component] = ParameterPanel.snapped(self.rows[index], self.press_values[(usize)component] + travelled * rate)
        try self.set_live(index, values)

    ## A press on the slider jumps there, and the drag follows.
    func slide(x: f64) -> !:
        let index = (usize)self.press_row
        if index >= self.total:
            return
        let row = self.rows[index]
        let range = ParameterPanel.slider_range(row) else return
        let rect = self.slider_rect(row)
        let fraction = math.clamp((x - rect.x - 3.0) / math.max(1.0, rect.width - 6.0), 0.0, 1.0)
        var values = row.values
        values[0] = ParameterPanel.snapped(row, range.0 + fraction * (range.1 - range.0))
        try self.set_live(index, values)

    ## A live value during a drag: shown now, reported with the frame.
    func set_live(index: usize, values: f64[4]) -> !:
        var kept = values
        for component in 0..<4:
            kept[component] = row_clamp(self.rows[index], kept[component])
        if kept == self.rows[index].values:
            return
        self.rows[index].values = kept
        try self.touch((i64)index)

    ## The step arrows, scrubbing and the ladder's middle rung move by, stored;
    ## a round step in the unit the row shows.
    static func increment(row: Row) -> f64:
        let units = row.units
        if row.step > 0.0:
            return units.stored(measures.shown_step(row.step, units))
        if row.kind == ParameterKind.integer and not units.converts():
            return 1.0
        if let range = ParameterPanel.slider_range(row):
            return units.stored(nice_step(units.shown(range.1 - range.0) / 100.0))
        return units.stored(math.min(1.0, math.pow(10.0, 1.0 - (f64)shown_decimals(row))))

    ## `value` on the row's grid: its step, or the decimals it shows.
    static func snapped(row: Row, value: f64) -> f64:
        let grid = ParameterPanel.increment(row) if row.step > 0.0 else row.units.stored(math.pow(10.0, -(f64)shown_decimals(row)))
        return row_clamp(row, math.floor(value / grid + 0.5) * grid)

    # -- The value ladder.

    ## Houdini's value ladder: the middle button over a number opens a column
    ## of steps (100, 10, 1, 0.1 … around the row's own) centred on the
    ## pointer; up and down choose the step, left and right move the value by it.
    func start_ladder(event: Event) -> !:
        let (row, part, component) = self.hit(event.x, event.y)
        if row < 0 or not self.enabled((usize)row) or not numeric(self.rows[(usize)row].kind) or (part != part_field and part != part_label and part != part_slider):
            return
        let index = (usize)row
        # The rungs in the unit the row shows; `climb` stores them.
        var rungs: f64[8]
        let units = self.rows[index].units
        let middle = units.shown(ParameterPanel.increment(self.rows[index]))
        let smallest = 1.0 if self.rows[index].kind == ParameterKind.integer and not units.converts() else math.pow(10.0, -(f64)shown_decimals(self.rows[index]))
        var count: usize = 0
        var start: usize = 0
        var power = 3
        while power >= -4 and count < 8:
            let step = middle * math.pow(10.0, (f64)power)
            if step >= smallest * 0.999:
                if power == 0:
                    start = count
                rungs[count] = step
                count += 1
            power -= 1
        self.laddering = true
        self.press_row = row
        self.press_part = part_label if part == part_label else part_field
        self.press_component = component
        self.press_y = event.y
        self.rung = (i64)start
        self.rung_x = event.x
        self.rung_values = self.rows[index].values
        let cell = self.row_height()
        try self.ladder.value().show(rungs, count, start, event.x - 40.0, event.y - cell * ((f64)start + 0.5))
        try self.begin(row)
        self.box.value().invalidate()

    func climb(event: Event) -> !:
        let index = (usize)self.press_row
        if index >= self.total:
            return
        let cell = self.row_height()
        let count = (i64)self.ladder.value().count
        let rung = between((i64)self.ladder.value().start + (i64)math.floor((event.y - self.press_y) / cell + 0.5), 0, count - 1)
        if rung != self.rung:
            self.rung = rung
            self.rung_x = event.x
            self.rung_values = self.rows[index].values
            self.ladder.value().select((usize)rung)
        let step = self.rows[index].units.stored(self.ladder.value().rungs[(usize)rung])
        let moved = math.floor((event.x - self.rung_x) / ladder_pitch) * step
        var values = self.rows[index].values
        for component in 0..<self.rows[index].components:
            if self.press_part == part_field and component != self.press_component:
                continue
            values[(usize)component] = row_clamp(self.rows[index], math.floor((self.rung_values[(usize)component] + moved) / step + 0.5) * step)
        try self.set_live(index, values)

    # -- Menus.

    ## A menu parameter's items in a popup under its face, the chosen one ticked.
    func open_items(index: usize) -> !:
        let items = self.rows[index].items.value
        let count = (usize)between((i64)parameter_text.item_count(items), 0, 64)
        if count == 0:
            return
        let chosen = parameter_text.item_of(items, self.rows[index].values[0])
        var commands: interop.Reference[Command][64] = ---
        var made: usize = 0
        defer release_commands(commands[..<made])
        for item in 0..<count:
            commands[made] = try interop.Reference[Command].adopt(new Command(parameter_text.item_label(items, item)) in memory.heap, command_type, memory.heap)
            commands[made].value().set_checked((i64)item == chosen)
            made += 1
        try self.show_popup(commands[..<made], ParameterPanel.span_rect(self.rows[index]), popup_items, (i64)index)

    ## The context menu, after Houdini's: revert this or every parameter, and
    ## copy one parameter's value to paste into another.
    func open_context(x: f64, y: f64) -> !:
        self.hide_tip()
        let (row, part, component) = self.hit(x, y)
        _ = part
        _ = component
        var valued = false
        var changed = false
        var pastes = false
        if row >= 0 and self.enabled((usize)row):
            let target = self.rows[(usize)row]
            valued = holds_values(target.kind)
            changed = not at_default(target)
            pastes = valued and copied_count > 0
        var all = false
        for index in 0..<self.total:
            if self.enabled(index) and not at_default(self.rows[index]):
                all = true
        var commands: interop.Reference[Command][6] = ---
        var made: usize = 0
        defer release_commands(commands[..<made])
        for caption in ["Revert to Default", "", "Copy Value", "Paste Value", "", "Revert All to Defaults"]:
            commands[made] = try interop.Reference[Command].adopt(new Command(caption, divider = caption.length == 0) in memory.heap, command_type, memory.heap)
            made += 1
        commands[0].value().set_enabled(changed)
        commands[2].value().set_enabled(valued)
        commands[3].value().set_enabled(pastes)
        commands[5].value().set_enabled(all)
        try self.show_popup(commands[..<made], Rect(x, y, 0.0, 0.0), popup_context, row)

    func show_popup(commands: const interop.Reference[Command][], under: Rect, mode: i64, row: i64) -> !:
        try self.items_popup.value().set_commands(commands)
        _ = self.items_popup.value().take_chosen()
        let box = self.items_popup.value().layout()
        defer box.release()
        # A menu's items list at least as wide as the menu, as a dropdown's do.
        try box.value().set_limits(Size(under.width, 0.0), Size(16384.0, 16384.0))
        try box.value().set_popup_point(under.x, under.y + under.height)
        try self.items_popup.value().open()
        self.popup_mode = mode
        self.popup_row = row
        self.box.value().invalidate()

    ## A color's editor under its swatch.
    func open_color(index: usize) -> !:
        let row = self.rows[index]
        var buffer: u8[8]
        var channels = (0, 0, 0)
        let red = byte_of(row.values[0], row.linear)
        let green = byte_of(row.values[1], row.linear)
        let blue = byte_of(row.values[2], row.linear)
        let written = hex_color(buffer, red, green, blue)
        let rect = self.swatch_rect(row)
        try self.color_popup.value().open_at(written, rect.x, rect.y + rect.height)
        channels = self.color_popup.value().rgb()
        self.color_row = (i64)index
        self.color_shown = channels
        self.box.value().invalidate()

## Whether a kind scrubs and takes the ladder.
func numeric(kind: ParameterKind) -> bool:
    return kind == ParameterKind.number or kind == ParameterKind.integer or kind == ParameterKind.vector or kind == ParameterKind.color

## Whether a kind holds a value to copy and paste.
func holds_values(kind: ParameterKind) -> bool:
    return numeric(kind) or kind == ParameterKind.toggle or kind == ParameterKind.menu

## Shift is coarse (ten times), Alt fine (a tenth).
func modifier(event: Event) -> f64:
    if event.shift:
        return 10.0
    if event.alt:
        return 0.1
    return 1.0

## 1, 2 or 5 times a power of ten, at or below `value`.
func nice_step(value: f64) -> f64:
    if value <= 0.0 or not math.is_finite(value):
        return 1.0
    let power = math.pow(10.0, math.floor(math.log10(value)))
    let scaled = value / power
    if scaled >= 5.0:
        return power * 5.0
    if scaled >= 2.0:
        return power * 2.0
    return power

func release_commands(commands: const interop.Reference[Command][]):
    for command in commands:
        command.release()

## A 0..1 component as a 0..255 sRGB byte; linear components are encoded first.
func byte_of(value: f64, linear: bool) -> i64:
    let encoded = transfer.srgb_encode(math.clamp(value, 0.0, 1.0)) if linear else math.clamp(value, 0.0, 1.0)
    return (i64)math.floor(encoded * 255.0 + 0.5)

## A 0..255 sRGB byte as the row keeps it.
func component_of(byte: i64, linear: bool) -> f64:
    let encoded = (f64)byte / 255.0
    return transfer.srgb_decode(encoded) if linear else encoded

## `#rrggbb` into `buffer`.
func hex_color(buffer: u8[], red: i64, green: i64, blue: i64) -> str:
    let digits = "0123456789abcdef"
    buffer[0] = '#'
    var at: usize = 1
    for channel in [red, green, blue]:
        buffer[at] = digits.bytes[(usize)((channel >> 4) & 15)]
        buffer[at + 1] = digits.bytes[(usize)(channel & 15)]
        at += 2
    return (str)buffer[..<7]