dymokomi/luce-ui
Source of release 0.19.5
0.19.5 / src / widgets / tabs.lucb
## Tabbed panels: the Tabs widget and the TabBar of titles it shows its pages under.
from luce_gpu import gpu
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 luce_window import input
from font import Font, selected_font
## The bar of a tabbed panel: the titles on the strip, the selected one on the
## surface with its top corners rounded, as the docking chrome draws panes.
pub struct TabBar: Widget:
let box: interop.Reference[Layout]
let font: interop.Reference[Font]
var titles: interop.Owned[str][]
var selected: i64
## A tab clicked but not yet taken by the panel, or -1.
var pending: i64
pub func init(titles: const str[], font: interop.Reference[Font]? = none, selected: i64 = 0) -> !:
if titles.length == 0:
error(result.invalid, "a tab bar needs at least one tab")
var chosen = try selected_font(font)
errdefer chosen.release()
let box = try layout.make_layout()
errdefer box.release()
try box.value().set_shrink(vertical = 0.0)
box.value().set_cursor(input.Cursor.pointer)
# clickable: a box receives pointer events only once it says so
box.value().set_interactive(true)
var copies = try new interop.Owned[str][titles.length] --- in memory.heap
for index in 0..<titles.length:
copies[index] = try interop.copy_text(titles[index])
self.box = box
self.font = chosen
self.titles = copies
self.selected = math.iclamp(selected, 0, (i64)titles.length - 1)
self.pending = -1
pub func layout() -> interop.Reference[Layout]:
return self.box.clone()
pub func selected_index() -> i64:
return self.selected
## Mark tab `index` (clamped to the tabs) selected; the panel's pages are
## unaffected.
pub func select(index: i64):
self.selected = math.iclamp(index, 0, (i64)self.titles.length - 1)
self.box.value().invalidate()
## The tab clicked since the last take, or -1.
pub func take_click() -> i64:
let was = self.pending
self.pending = -1
return was
func tab_width(index: usize) -> f64:
let text = self.font.value().measure(self.titles[index].value) catch failure:
_ = failure
recover 0.0
return text + self.font.value().advance() * 2.5
pub func measure(available: Constraints) -> interop.Outcome[Size]:
var width = 0.0
for index in 0..<self.titles.length:
width += self.tab_width(index) + 2.0
return result.success[Size](Size(width, self.box.value().theme().row_height(self.font) + 4.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.strip)
let text_y = math.max(0.0, (size.height - self.font.value().height()) * 0.5)
var x = 0.0
for index in 0..<self.titles.length:
let width = self.tab_width(index)
let current = (i64)index == self.selected
if current:
try painter.rounded_rectangle(gpu.Rect(x, 2.0, width, size.height - 2.0), theme.panel, theme.control_radius + 1.0, 1.0, 3)
try painter.text(self.titles[index].value, x + self.font.value().advance() * 1.25, text_y, color = theme.foreground if current else theme.muted, font = self.font)
x += width + 2.0
pub func event(event: Event) -> interop.Outcome[unit]:
if event.cancelled or event.kind != input.EventKind.pointer_down or event.button != 0 or not event.inside:
return result.success[unit](())
var x = 0.0
for index in 0..<self.titles.length:
let width = self.tab_width(index)
if event.x >= x and event.x < x + width:
self.pending = (i64)index
self.box.value().invalidate()
return result.success[unit](())
x += width + 2.0
return result.success[unit](())
pub func close():
for index in 0..<self.titles.length:
self.titles[index].release()
if self.titles.length > 0:
free(self.titles) in memory.heap
self.font.release()
self.box.release()
func trace(visit: func(ownership.Object*, void*) -> unit, context: void*):
self.font.trace(visit, context)
self.box.trace(visit, context)
for index in 0..<self.titles.length:
self.titles[index].trace(visit, context)
pub let tab_bar_type: interop.Type[TabBar] = interop.Type[TabBar]("TabBar", TabBar.close, TabBar.trace, closeable = true, main_thread = true)
## A tabbed panel: a bar of titles over one page at a time. Pages are any
## widgets; the selected one is shown, the rest leave the layout.
## `on_change` reports the selected index.
pub struct Tabs: Widget:
let box: interop.Reference[Layout]
let bar: interop.Reference[TabBar]
var pages: interop.Reference[Layout][]
var selected: i64
let changed: interop.Signal[i64]
pub func init(titles: const str[], pages: const interop.Interface[Widget][], font: interop.Reference[Font]? = none, selected: i64 = 0) -> !:
if titles.length != pages.length or titles.length == 0:
error(result.invalid, "a tabbed panel needs one title per page and at least one page")
let box = try layout.make_layout(layout.Axis.vertical, 0.0, 0.0, layout.Alignment.stretch)
errdefer box.release()
let bar = try interop.Reference[TabBar].adopt(new TabBar(titles, font, selected) in memory.heap, tab_bar_type, memory.heap)
errdefer bar.release()
let changed = try interop.Signal[i64]()
errdefer changed.release()
var boxes = try new interop.Reference[Layout][pages.length] --- in memory.heap
var children = try new interop.Interface[Widget][pages.length + 1] --- in memory.heap
defer free(children) in memory.heap
children[0] = bar.as_interface[Widget](bar.value())
let chosen = math.iclamp(selected, 0, (i64)pages.length - 1)
for index in 0..<pages.length:
boxes[index] = pages[index].value().layout()
boxes[index].value().set_visible((i64)index == chosen)
children[index + 1] = pages[index]
try box.value().set_children(children)
children[0].release()
self.box = box
self.bar = bar
self.pages = boxes
self.selected = chosen
self.changed = changed
pub func layout() -> interop.Reference[Layout]:
return self.box.clone()
pub func selected_index() -> i64:
return self.selected
## Called with the new index whenever the shown page changes, from a click or
## `select`.
pub func on_change(callback: interop.Callback[i64, unit]) -> interop.Reference[interop.Connection]!:
return try self.changed.connect(callback)
## Show page `index`, clamped to the pages.
pub func select(index: i64) -> interop.Outcome[unit]:
let chosen = math.iclamp(index, 0, (i64)self.pages.length - 1)
if chosen == self.selected:
return result.success[unit](())
self.selected = chosen
self.bar.value().select(chosen)
for which in 0..<self.pages.length:
self.pages[which].value().set_visible((i64)which == chosen)
self.box.value().invalidate()
return self.changed.emit(chosen)
pub func measure(available: Constraints) -> interop.Outcome[Size]:
let size = self.box.value().content_size(available) catch failure:
return result.failure[Size](failure.code, failure.message)
return result.success[Size](size)
## Each frame: take a click on the bar.
pub func draw(target: interop.View[gpu.RenderTarget]) -> interop.Outcome[unit]:
let clicked = self.bar.value().take_click()
if clicked >= 0:
return self.select(clicked)
return result.success[unit](())
pub func event(event: Event) -> interop.Outcome[unit]:
return result.success[unit](())
pub func close():
for index in 0..<self.pages.length:
self.pages[index].release()
if self.pages.length > 0:
free(self.pages) in memory.heap
self.changed.close()
self.changed.release()
self.bar.release()
self.box.release()
func trace(visit: func(ownership.Object*, void*) -> unit, context: void*):
self.box.trace(visit, context)
self.bar.trace(visit, context)
self.changed.trace(visit, context)
for index in 0..<self.pages.length:
self.pages[index].trace(visit, context)
pub let tabs_type: interop.Type[Tabs] = interop.Type[Tabs]("Tabs", Tabs.close, Tabs.trace, closeable = true, main_thread = true)
test "a tabbed panel shows one page and switches":
let a = try interop.Reference[TabBar].adopt(new TabBar(["x"]) in memory.heap, tab_bar_type, memory.heap)
defer a.release()
let b = try interop.Reference[TabBar].adopt(new TabBar(["y"]) in memory.heap, tab_bar_type, memory.heap)
defer b.release()
let pages: interop.Interface[Widget][2] = [a.as_interface[Widget](a.value()), b.as_interface[Widget](b.value())]
var panel = try Tabs(["One", "Two"], pages)
defer panel.close()
assert(panel.selected_index() == 0)
let switched = panel.select(1)
assert(switched.is_success())
switched.release()
assert(panel.selected_index() == 1)
var bar = try TabBar(["A", "B", "C"], selected = 5)
defer bar.close()
assert(bar.selected_index() == 2 and bar.take_click() == -1)