dymokomi/luce-ui
Source of release 0.19.2
0.19.2 / 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 lit = (i64)index == self.selection
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), theme.on_selection(color) if lit else 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.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 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)