dymokomi/luce-ui
Source of release 0.19.0
0.19.0 / src / widgets / table_view.lucb
## A virtualized multi-column list: a small model/view/delegate table. Columns
## describe sizing and alignment; each row is a list of cells that carry their own
## presentation — icon, tint, muted, emphasis — which is the delegate role. The view
## owns scrolling, whole-row selection (one row, or several with `multiple`),
## keyboard navigation, activation, an optional sticky header and drag-to-resize
## column dividers.
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
import text.cells as cell_widths
from layout import Widget, Layout, Size, Constraints, Event
from painter import Painter
from font import Font, selected_font
from theme import Theme
from icons import IconKind
from widgets.table_selection import RowSelection
import icons
let maximum_columns: usize = 16
## Text alignment within a column.
pub enum CellAlign as u8:
left = 0
right = 1
center = 2
## A column's title and sizing. `weight` > 0 makes the column absorb leftover width
## in proportion to its weight; weight 0 is a fixed column of `width` points, which
## is also the starting width a resize adjusts. Borrowed for the call; copied inside.
pub struct TableColumn:
pub let title: str = ""
pub let width: f64 = 120.0
pub let weight: f64 = 0.0
pub let minimum: f64 = 36.0
pub let align: CellAlign = CellAlign.left
## One cell's presentation — the model's display text plus its delegate roles. A
## missing tint draws in the row's foreground; muted draws in the theme's muted color;
## emphasis renders bold; an icon draws before the text, typically in column 0.
## Borrowed for the call; the table retains its own copy.
pub struct TableCell:
pub let text: str = ""
pub let icon: IconKind = IconKind.blank
pub let tint: gpu.Color? = none
pub let muted: bool = false
pub let emphasis: bool = false
struct StoredColumn:
var title: interop.Owned[str]
var width: f64
let weight: f64
let minimum: f64
let align: CellAlign
struct StoredCell:
let text: interop.Owned[str]
let icon: IconKind
let tint: gpu.Color?
let muted: bool
let emphasis: bool
pub struct TableView: Widget:
let box: interop.Reference[Layout]
var columns: StoredColumn[]
var cells: StoredCell[]
var rows: usize
let activated: interop.Signal[i64]
## The selected rows; its lead is `selected_index`.
var picked: RowSelection
var scroll: f64
let show_header: bool
let resizable: bool
let custom_row_height: f64?
let font: interop.Reference[Font]
## The column currently being resized, or -1. `drag_sign` is +1 when the dragged
## divider grows the column to its left, -1 when it shrinks the column to its right.
var drag_column: i64
var drag_start_x: f64
var drag_start_width: f64
var drag_sign: f64
## `cells` is row-major: `columns.length` cells per row, laid out one row after
## another. A flat slice keeps the public signature expressible from either tier.
## `multiple` lets command-click, shift-click, shift-arrows and command-A select
## several rows.
pub func init(columns: const TableColumn[], cells: const TableCell[], row_height: f64? = none,
font: interop.Reference[Font]? = none, header: bool = true, resizable: bool = true,
multiple: bool = false) -> !:
if columns.length == 0 or columns.length > maximum_columns:
error(result.invalid, "a table needs between 1 and 16 columns")
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, "table 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(160.0, 60.0), Size(16384.0, 16384.0))
let signal = try interop.Signal[i64]()
errdefer signal.release()
let stored_columns = try copy_columns(columns)
errdefer release_columns(stored_columns)
let stored_cells = try copy_cells(cells, columns.length, selected)
errdefer release_cells(stored_cells)
let picked = try RowSelection(cells.length // columns.length, multiple)
self.box = box
self.columns = stored_columns
self.cells = stored_cells
self.rows = cells.length // columns.length
self.activated = signal
self.picked = picked
self.scroll = 0.0
self.show_header = header
self.resizable = resizable
self.custom_row_height = row_height
self.font = selected
self.drag_column = -1
self.drag_start_x = 0.0
self.drag_start_width = 0.0
self.drag_sign = 1.0
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)
func header_height() -> f64:
return self.row_height() if self.show_header else 0.0
## The lead selected row (the one last clicked or moved to), or -1.
pub func selected_index() -> i64:
return self.picked.lead
## Whether row `index` is selected.
pub func is_selected(index: i64) -> bool:
return self.picked.contains(index)
## How many rows are selected.
pub func selected_count() -> i64:
return (i64)self.picked.count()
## Select every row of a `multiple` table.
pub func select_all():
self.picked.all()
self.box.value().invalidate()
## Add row `index` to the selection or take it out, keeping the lead: restoring
## a selection after `set_rows`. A single-selection table selects it alone.
pub func mark(index: i64, on: bool) -> !:
try self.picked.mark(index, on)
self.box.value().invalidate()
pub func scroll_offset() -> f64:
return self.scroll
## Fill `out[0..columns]` with each column's resolved on-screen width: fixed
## columns keep their width; weighted columns share the leftover by weight.
func resolve_widths(out: f64[]):
let available = self.box.value().bounds().width
var fixed_total: f64 = 0.0
var weight_total: f64 = 0.0
for index in 0..<self.columns.length:
if self.columns[index].weight > 0.0:
weight_total += self.columns[index].weight
else:
fixed_total += self.columns[index].width
let leftover = math.max(0.0, available - fixed_total)
for index in 0..<self.columns.length:
let column = self.columns[index]
if column.weight > 0.0 and weight_total > 0.0:
out[index] = math.max(column.minimum, leftover * column.weight / weight_total)
else:
out[index] = column.width
## The boundary (index of the column on its left) under `x`, or -1 when none is
## close enough or neither adjacent column is fixed and so resizable.
func divider_at(x: f64, widths: f64[]) -> i64:
if not self.resizable:
return -1
var edge: f64 = 0.0
for index in 0..<self.columns.length - 1:
edge += widths[index]
if math.abs(x - edge) <= 4.0 and (self.columns[index].weight == 0.0 or self.columns[index + 1].weight == 0.0):
return (i64)index
return -1
pub func set_rows(cells: const TableCell[]) -> !:
let copies = try copy_cells(cells, self.columns.length, self.font)
release_cells(self.cells)
self.cells = copies
self.rows = cells.length // self.columns.length
try self.picked.resize(self.rows)
let limit = math.max(0.0, (f64)self.rows * self.row_height() - math.max(0.0, self.box.value().bounds().height - self.header_height()))
self.scroll = math.clamp(self.scroll, 0.0, limit)
self.box.value().invalidate()
## Select row `index` alone (-1 for none) and scroll it into view.
pub func select(index: i64) -> !:
try self.picked.only(index)
self.reveal(index)
## Scroll row `index` into view.
func reveal(index: i64):
if index >= 0:
let rh = self.row_height()
let viewport = self.box.value().bounds().height - self.header_height()
let y = (f64)index * rh
if viewport <= 0.0:
self.scroll = 0.0
elif y < self.scroll:
self.scroll = y
elif y + rh > self.scroll + viewport:
self.scroll = math.max(0.0, y + rh - viewport)
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(260.0, 260.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()
try painter.rectangle(gpu.Rect(width = size.width, height = size.height), theme.background)
var widths: f64[16]
self.resolve_widths(widths)
let rh = self.row_height()
let hh = self.header_height()
let inset = theme.inset(self.font)
var index = (usize)(self.scroll / rh)
while index < self.rows:
let y = hh + (f64)index * rh - self.scroll
if y >= size.height:
break
if y + rh > hh:
if self.picked.contains((i64)index):
try painter.rectangle(gpu.Rect(0.0, y, size.width, rh), theme.selection)
if (i64)index == self.picked.lead:
try painter.rectangle(gpu.Rect(0.0, y, 2.0, rh), theme.accent)
elif self.box.value().contains_pointer() and self.box.value().pointer_position().y >= math.max(hh, y) and self.box.value().pointer_position().y < y + rh:
try painter.rectangle(gpu.Rect(0.0, y, size.width, rh), theme.hover())
var x: f64 = 0.0
for column in 0..<self.columns.length:
let cell = self.cells[index * self.columns.length + column]
try self.paint_cell(&painter, cell, self.columns[column], x, y, widths[column], rh, inset, theme)
x += widths[column]
index += 1
if self.show_header:
try painter.rectangle(gpu.Rect(0.0, 0.0, size.width, hh), theme.panel)
var hx: f64 = 0.0
for column in 0..<self.columns.length:
let title = self.columns[column].title.value
if title.length > 0:
try self.paint_label(&painter, title, self.columns[column], hx, 0.0, widths[column], hh, inset, theme.muted)
hx += widths[column]
if column < self.columns.length - 1:
try painter.rectangle(gpu.Rect(hx - 0.5, 0.0, 1.0, hh), theme.border)
try painter.rectangle(gpu.Rect(0.0, hh - 1.0, size.width, 1.0), theme.border)
if self.box.value().is_focused():
try painter.rectangle(gpu.Rect(width = size.width, height = 1.0), theme.accent)
let content = (f64)self.rows * rh
let viewport = size.height - hh
if content > viewport and viewport > 0.0:
let thumb = math.max(24.0, viewport * viewport / content)
let position = hh + self.scroll / math.max(1.0, content - viewport) * math.max(0.0, viewport - thumb)
try painter.rectangle(gpu.Rect(math.max(0.0, size.width - 6.0), position, 4.0, thumb), theme.border)
func paint_cell(painter: Painter*, cell: StoredCell, column: StoredColumn, x: f64, y: f64,
width: f64, rh: f64, inset: f64, theme: Theme) -> !:
var text_x = x + inset
if cell.icon != IconKind.blank:
let extent = self.font.value().height()
let color = theme.accent if cell.icon == IconKind.folder or cell.icon == IconKind.folder_open else theme.muted
try icons.draw(painter, cell.icon, gpu.Rect(text_x, y + (rh - extent) * 0.5, extent, extent), color)
text_x += extent + inset
if cell.text.value.length == 0:
return
var color = theme.foreground
if cell.muted:
color = theme.muted
if let tint = cell.tint:
color = tint
var buffer: u8[512]
let label = elide(self.font, cell.text.value, x + width - inset - text_x, buffer)
if label.length == 0:
return
let ty = y + (rh - self.font.value().height()) * 0.5
var draw_x = text_x
if column.align == CellAlign.right:
let measured = try self.font.value().measure(label)
draw_x = x + width - inset - measured
elif column.align == CellAlign.center:
let measured = try self.font.value().measure(label)
draw_x = x + (width - measured) * 0.5
try painter.text(label, draw_x, ty, color = color, font = self.font)
if cell.emphasis:
try painter.text(label, draw_x + 0.6, ty, color = color, font = self.font)
func paint_label(painter: Painter*, text: str, column: StoredColumn, x: f64, y: f64,
width: f64, rh: f64, inset: f64, color: gpu.Color) -> !:
var buffer: u8[512]
let label = elide(self.font, text, width - inset * 2.0, buffer)
if label.length == 0:
return
let ty = y + (rh - self.font.value().height()) * 0.5
var draw_x = x + inset
if column.align == CellAlign.right:
let measured = try self.font.value().measure(label)
draw_x = x + width - inset - measured
elif column.align == CellAlign.center:
let measured = try self.font.value().measure(label)
draw_x = x + (width - measured) * 0.5
try painter.text(label, draw_x, ty, color = color, font = self.font)
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.picked.lead)
return result.success[unit](())
func handle(event: Event) -> bool!:
if event.cancelled:
return false
var widths: f64[16]
self.resolve_widths(widths)
let rh = self.row_height()
let hh = self.header_height()
if event.kind == input.EventKind.pointer_up:
self.drag_column = -1
return false
if self.drag_column >= 0 and event.kind == input.EventKind.pointer_moved:
let width = math.max(self.columns[self.drag_column].minimum,
self.drag_start_width + self.drag_sign * (event.x - self.drag_start_x))
self.columns[self.drag_column].width = width
self.box.value().invalidate()
return false
if event.kind == input.EventKind.pointer_moved:
if self.show_header and event.y < hh and self.divider_at(event.x, widths) >= 0:
self.box.value().set_cursor(input.Cursor.resize_horizontal)
else:
self.box.value().set_cursor(input.Cursor.pointer)
# Repaint on every move so the hovered row keeps up with the pointer;
# set_cursor alone does not invalidate.
self.box.value().invalidate()
return false
if event.kind == input.EventKind.scroll:
let scale = 1.0 if event.scroll_unit == input.ScrollUnit.points else rh * 3.0
let viewport = math.max(0.0, self.box.value().bounds().height - hh)
let limit = math.max(0.0, (f64)self.rows * rh - viewport)
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:
if self.show_header and event.y < hh:
if event.button == 0:
let boundary = self.divider_at(event.x, widths)
if boundary >= 0:
let target = boundary if self.columns[boundary].weight == 0.0 else boundary + 1
self.drag_column = target
self.drag_start_x = event.x
self.drag_start_width = self.columns[target].width
self.drag_sign = 1.0 if target == boundary else -1.0
return false
let index = (i64)((event.y - hh + self.scroll) / rh)
if index >= 0 and index < (i64)self.rows:
if event.button == 1:
# A right-click on a selected row keeps the selection for its menu.
if not self.picked.contains(index):
try self.select(index)
return false
if event.shift:
try self.picked.extend(index)
elif event.meta or event.control:
try self.picked.toggle(index)
else:
try self.picked.only(index)
self.reveal(index)
return true
if event.button == 1:
try self.select(-1)
elif event.kind == input.EventKind.key_down:
let lead = self.picked.lead
if event.key == input.Key.enter and lead >= 0:
return true
elif self.rows > 0:
var target: i64 = -1
if event.key == input.Key.down:
target = lead + 1 if lead + 1 < (i64)self.rows else lead
elif event.key == input.Key.up:
target = lead - 1 if lead > 0 else 0
elif event.key == input.Key.home:
target = 0
elif event.key == input.Key.end:
target = (i64)self.rows - 1
elif event.key == input.Key.a and (event.meta or event.control):
self.select_all()
return false
if target >= 0:
if event.shift:
try self.picked.extend(target)
else:
try self.picked.only(target)
self.reveal(target)
return false
pub func close():
self.font.release()
self.activated.close()
self.activated.release()
release_cells(self.cells)
release_columns(self.columns)
self.picked.close()
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 cell in self.cells:
cell.text.trace(visit, context)
for column in self.columns:
column.title.trace(visit, context)
## Fit `text` into `max_width`, appending an ellipsis (U+2026) when it must be cut.
## Returns the original text when it fits, otherwise a view into `buffer`, which the
## caller owns for the draw.
func elide(font: interop.Reference[Font], text: str, max_width: f64, buffer: u8[]) -> str:
if max_width <= 0.0:
return ""
return fit(text, (usize)(max_width / font.value().advance()), buffer)
## `text` cut to `room` monospace cells. Wide scalars take two cells and marks none;
## when the text is wider, whole scalars are kept in `room - 1` cells and the ellipsis
## takes the last one. A wide scalar that would straddle the cut is left out, so its
## cell stays empty before the ellipsis.
func fit(text: str, room: usize, buffer: u8[]) -> str:
if cell_widths.width(text) <= room:
return text
if room < 1 or buffer.length < 3:
return ""
let kept = cell_widths.prefix(text, room - 1)
# A very wide column keeps what the buffer holds, ending on a scalar boundary.
var written = kept.length
if written + 3 > buffer.length:
written = buffer.length - 3
while written > 0 and (kept.bytes[written] & 0xC0) == 0x80:
written -= 1
memory.copy(buffer, kept.bytes, written)
buffer[written] = (u8)226
buffer[written + 1] = (u8)128
buffer[written + 2] = (u8)166
written += 3
return (str)buffer[..<written]
func copy_columns(columns: const TableColumn[]) -> StoredColumn[]!:
let copies = try new StoredColumn[columns.length] --- in memory.heap
var count: usize = 0
errdefer release_columns_partial(copies, count)
for column in columns:
copies[count] = StoredColumn(try interop.copy_text(column.title), column.width, column.weight, column.minimum, column.align)
count += 1
return copies
func copy_cells(cells: const TableCell[], column_count: usize, font: interop.Reference[Font]) -> StoredCell[]!:
if column_count == 0 or cells.length % column_count != 0:
error(result.invalid, "table cells must form whole rows of one cell per column")
if cells.length // column_count > 65536:
error(result.invalid, "a table supports at most 65536 rows")
let copies = try new StoredCell[cells.length] --- in memory.heap
var count: usize = 0
errdefer release_cells_partial(copies, count)
for cell in cells:
_ = try font.value().measure(cell.text)
copies[count] = StoredCell(try interop.copy_text(cell.text), cell.icon, cell.tint, cell.muted, cell.emphasis)
count += 1
return copies
func release_columns_partial(columns: StoredColumn[], count: usize):
for column in columns[..<count]:
column.title.release()
free(columns) in memory.heap
func release_columns(columns: StoredColumn[]):
release_columns_partial(columns, columns.length)
func release_cells_partial(cells: StoredCell[], count: usize):
for cell in cells[..<count]:
cell.text.release()
free(cells) in memory.heap
func release_cells(cells: StoredCell[]):
release_cells_partial(cells, cells.length)
pub let table_view_type: interop.Type[TableView] = interop.Type[TableView]("TableView", TableView.close, TableView.trace, closeable = true, main_thread = true)
test "elision counts cells: wide scalars are never cut and the ellipsis takes a cell":
var buffer: u8[64]
assert(fit("abc", 3, buffer) == "abc")
assert(fit("abcd", 3, buffer) == "ab…")
assert(fit("田中", 4, buffer) == "田中")
assert(fit("田中a", 4, buffer) == "田…")
assert(fit("会議の件", 7, buffer) == "会議の…")
# Three cells: 'a', then 田 would straddle the cut, so its cell stays empty.
assert(fit("a田中", 3, buffer) == "a…")
assert(fit("e\u{301}tc", 2, buffer) == "e\u{301}…")
assert(fit("田中", 1, buffer) == "…")
assert(fit("田中", 0, buffer) == "")
var small: u8[8]
assert(fit("田中会議の件", 11, small) == "田…")