Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-ui

Source of release 0.19.0

0.19.0 / src / widgets / list_view.lucb

## A virtualized, single-selection text list. Applications own entry meaning;
## this control owns scrolling, selection, keyboard navigation and activation.
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

## Incoming labels are borrowed for the call; ListView retains its own copy.
## Icons are presentation data, independent of filenames or filesystem policy.
pub struct ListItem:
    pub let text: str
    pub let icon: IconKind = IconKind.blank

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

pub struct ListView: Widget:
    let box: interop.Reference[Layout]
    var items: StoredItem[]
    let activated: interop.Signal[i64]
    var selection: i64
    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 copies = try copy_items(items, selected)
        self.box = box
        self.activated = signal
        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)

    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 item = self.items[index]
            var x = theme.inset(self.font)
            if item.icon != IconKind.blank:
                let extent = self.font.value().height()
                let color = theme.accent if item.icon == IconKind.folder or item.icon == IconKind.folder_open else theme.muted
                try icons.draw(&painter, item.icon, gpu.Rect(x, y + (self.row_height() - extent) * 0.5, extent, extent), color)
                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.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 activate = self.handle(event) catch failure:
            return result.failure[unit](failure.code, failure.message)
        if activate:
            return self.activated.emit(self.selection)
        return result.success[unit](())

    func handle(event: Event) -> bool!:
        if event.cancelled:
            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().invalidate()
        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)
                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()
        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)
        for item in self.items:
            item.text.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:
        _ = try font.value().measure(item.text)
        copies[count] = StoredItem(try interop.copy_text(item.text), item.icon)
        count += 1
    return copies

func release_partial(items: StoredItem[], count: usize):
    for item in items[..<count]:
        item.text.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)