Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-ui

Source of release 0.19.6

0.19.6 / src / widgets / list_view.lucb

## A virtualized, single-selection text list. Applications own entry meaning;
## this control owns scrolling, selection, keyboard navigation and activation. With
## `set_drag_kind` the selected item drags out to the window's drop areas taking that kind.
from luce_gpu import gpu
from luce_window import input
import interop
from luce_std import math
import memory
import ownership
import layout
import result
from layout import Widget, Layout, Size, Constraints, Event
from painter import Painter
from font import Font, selected_font
from icons import IconKind
import icons
from widgets.drag_gesture import DragGesture

## Incoming labels are borrowed for the call; ListView retains its own copy.
## Icons are presentation data, independent of filenames or filesystem policy.
## `symbol` names any icon in the luciaos-assets set ("color-swatch", "filter", ...)
## and is drawn in place of `icon`, muted; a name not in the set draws nothing but
## keeps the icon's room so the rows stay aligned. `depth` (0–64) nests a row: its
## icon and text start that many steps right, a step being an icon and its inset, so
## a child's icon sits under its parent's text.
pub struct ListItem:
    pub let text: str
    pub let icon: IconKind = IconKind.blank
    pub let symbol: str = ""
    pub let depth: i64 = 0

struct StoredItem:
    let text: interop.Owned[str]
    let icon: IconKind
    let symbol: interop.Owned[str]
    let depth: i64

pub struct ListView: Widget:
    let box: interop.Reference[Layout]
    var items: StoredItem[]
    let activated: interop.Signal[i64]
    ## Told the selection whenever the user changes it (`on_select`).
    let selection_changed: interop.Signal[i64]
    var selection: i64
    ## A press that may drag the selected item out (`set_drag_kind`).
    var gesture: DragGesture
    var scroll: f64
    let custom_row_height: f64?
    let font: interop.Reference[Font]

    pub func init(items: const ListItem[], row_height: f64? = none, font: interop.Reference[Font]? = none) -> !:
        var selected = try selected_font(font)
        errdefer selected.release()
        if let height = row_height:
            if not math.is_finite(height) or height < selected.value().line_height() or height > 512.0:
                error(result.invalid, "list row height must fit the font and be at most 512")
        let box = try layout.make_layout()
        errdefer box.release()
        box.value().set_focusable(true)
        # It scrolls itself: the wheel over it is its own, inside a scroll view too.
        box.value().set_takes_scroll(true)
        box.value().set_cursor(input.Cursor.pointer)
        try box.value().set_flex()
        try box.value().set_limits(Size(120.0, 60.0), Size(16384.0, 16384.0))
        let signal = try interop.Signal[i64]()
        errdefer signal.release()
        let changed = try interop.Signal[i64]()
        errdefer changed.release()
        let copies = try copy_items(items, selected)
        self.box = box
        self.activated = signal
        self.selection_changed = changed
        self.gesture = DragGesture()
        self.items = copies
        self.selection = -1
        self.scroll = 0.0
        self.custom_row_height = row_height
        self.font = selected

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

    func row_height() -> f64:
        return self.custom_row_height else self.box.value().theme().row_height(self.font)

    pub func selected_index() -> i64:
        return self.selection

    pub func scroll_offset() -> f64:
        return self.scroll

    pub func set_items(items: const ListItem[]) -> !:
        let copies = try copy_items(items, self.font)
        release_items(self.items)
        self.items = copies
        self.selection = -1
        self.scroll = 0.0
        self.box.value().invalidate()

    pub func select(index: i64) -> !:
        if index < -1 or index >= (i64)self.items.length:
            error(result.invalid, "list selection is outside its items")
        self.selection = index
        if index >= 0:
            let y = (f64)index * self.row_height()
            let height = self.box.value().bounds().height
            if height <= 0.0:
                self.scroll = 0.0
            elif y < self.scroll:
                self.scroll = y
            elif y + self.row_height() > self.scroll + height:
                self.scroll = math.max(0.0, y + self.row_height() - height)
        self.box.value().invalidate()

    pub func on_activate(callback: interop.Callback[i64, unit]) -> interop.Reference[interop.Connection]!:
        return try self.activated.connect(callback)

    ## Called with the selected index whenever the user changes the selection, by a
    ## click or a key; `select` called by the program does not call it.
    pub func on_select(callback: interop.Callback[i64, unit]) -> interop.Reference[interop.Connection]!:
        return try self.selection_changed.connect(callback)

    ## Let the selected item be dragged out (`Layout.start_drag`) as an item of
    ## `kind`: its index. "" stops it.
    pub func set_drag_kind(kind: str) -> !:
        try self.gesture.set_kind(kind)

    pub func measure(available: Constraints) -> interop.Outcome[Size]:
        return result.success[Size](Size(220.0, 240.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()
        try painter.rectangle(gpu.Rect(width = size.width, height = size.height), self.box.value().theme().background)
        var index = (usize)(self.scroll / self.row_height())
        while index < self.items.length:
            let y = (f64)index * self.row_height() - self.scroll
            if y >= size.height:
                break
            if (i64)index == self.selection:
                try painter.rectangle(gpu.Rect(y = y, width = size.width, height = self.row_height()), self.box.value().theme().selection)
                try painter.rectangle(gpu.Rect(y = y, width = 2.0, height = self.row_height()), self.box.value().theme().accent)
            elif self.box.value().contains_pointer() and self.box.value().pointer_position().y >= y and self.box.value().pointer_position().y < y + self.row_height():
                try painter.rectangle(gpu.Rect(y = y, width = size.width, height = self.row_height()), self.box.value().theme().hover())
            let theme = self.box.value().theme()
            let lit = (i64)index == self.selection
            let item = self.items[index]
            var x = theme.inset(self.font) + (f64)item.depth * (self.font.value().height() + theme.inset(self.font))
            if item.symbol.value != "" or item.icon != IconKind.blank:
                let extent = self.font.value().height()
                let place = gpu.Rect(x, y + (self.row_height() - extent) * 0.5, extent, extent)
                let color = theme.accent if item.symbol.value == "" and (item.icon == IconKind.folder or item.icon == IconKind.folder_open) else theme.muted
                let ink = theme.on_selection(color) if lit else color
                if item.symbol.value != "":
                    try icons.draw_named(&painter, item.symbol.value, place, ink)
                else:
                    try icons.draw(&painter, item.icon, place, ink)
                x += extent + theme.inset(self.font)
            try painter.text(item.text.value, x, y + (self.row_height() - self.font.value().height()) * 0.5, color = theme.on_selection(theme.foreground) if lit else theme.foreground, font = self.font)
            index += 1
        if self.box.value().is_focused():
            try painter.rectangle(gpu.Rect(width = size.width, height = 1.0), self.box.value().theme().accent)

    pub func event(event: Event) -> interop.Outcome[unit]:
        let before = self.selection
        let activate = self.handle(event) catch failure:
            return result.failure[unit](failure.code, failure.message)
        if self.selection != before:
            let told = self.selection_changed.emit(self.selection)
            if not activate or not told.is_success():
                return told
            told.release()
        if activate:
            return self.activated.emit(self.selection)
        return result.success[unit](())

    func handle(event: Event) -> bool!:
        if event.cancelled:
            self.gesture.cancel()
            return false
        if event.kind == input.EventKind.pointer_moved and self.gesture.moved(event.x, event.y):
            if self.selection >= 0:
                var chosen: i64[1] = [self.selection]
                try self.box.value().start_drag(self.gesture.dragged_kind(), chosen)
            return false
        if event.kind == input.EventKind.pointer_moved:
            # The hovered row is lit: a move draws only when it reaches another row.
            let row = (i64)math.floor((event.y + self.scroll) / self.row_height())
            self.box.value().hover_part(row if row < (i64)self.items.length else -1)
            return false
        if event.kind == input.EventKind.pointer_up:
            _ = self.gesture.release()
            return false
        if event.kind == input.EventKind.scroll:
            let scale = 1.0 if event.scroll_unit == input.ScrollUnit.points else self.row_height() * 3.0
            let limit = math.max(0.0, (f64)self.items.length * self.row_height() - self.box.value().bounds().height)
            self.scroll = math.clamp(self.scroll - event.scroll_y * scale, 0.0, limit)
            self.box.value().repaint()
        elif event.kind == input.EventKind.pointer_down and (event.button == 0 or event.button == 1) and event.inside:
            let index = (i64)((event.y + self.scroll) / self.row_height())
            if index >= 0 and index < (i64)self.items.length:
                try self.select(index)
                if event.button == 0:
                    self.gesture.press(event.x, event.y, -1)
                return event.button == 0
            if event.button == 1:
                try self.select(-1)
        elif event.kind == input.EventKind.key_down:
            if event.key == input.Key.enter and self.selection >= 0:
                return true
            elif self.items.length > 0:
                if event.key == input.Key.down:
                    try self.select(self.selection + 1 if self.selection + 1 < (i64)self.items.length else self.selection)
                elif event.key == input.Key.up:
                    try self.select(self.selection - 1 if self.selection > 0 else 0)
                elif event.key == input.Key.home:
                    try self.select(0)
                elif event.key == input.Key.end:
                    try self.select((i64)self.items.length - 1)

        return false

    pub func close():
        self.font.release()
        self.activated.close()
        self.activated.release()
        self.selection_changed.close()
        self.selection_changed.release()
        self.gesture.close()
        release_items(self.items)
        self.box.release()

    func trace(visit: func(ownership.Object*, void*) -> unit, context: void*):
        self.font.trace(visit, context)
        self.box.trace(visit, context)
        self.activated.trace(visit, context)
        self.selection_changed.trace(visit, context)
        for item in self.items:
            item.text.trace(visit, context)
            item.symbol.trace(visit, context)

func copy_items(items: const ListItem[], font: interop.Reference[Font]) -> StoredItem[]!:
    if items.length > 65536:
        error(result.invalid, "a list supports at most 65536 items")
    let copies = try new StoredItem[items.length] --- in memory.heap
    var count: usize = 0
    errdefer release_partial(copies, count)
    for item in items:
        if item.depth < 0 or item.depth > 64:
            error(result.invalid, "a list item's depth is 0 to 64")
        _ = try font.value().measure(item.text)
        let text = try interop.copy_text(item.text)
        let symbol = try interop.copy_text(item.symbol) catch failure:
            text.release()
            error(failure.code, failure.message)
        copies[count] = StoredItem(text, item.icon, symbol, item.depth)
        count += 1
    return copies

func release_partial(items: StoredItem[], count: usize):
    for item in items[..<count]:
        item.text.release()
        item.symbol.release()
    free(items) in memory.heap

func release_items(items: StoredItem[]):
    release_partial(items, items.length)

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