Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-ui

Source of release 0.19.0

0.19.0 / src / widgets / pane_header.lucb

## A compact pane title with an optional vector icon. Pane paints the
## shared frame background; this widget owns text, font metrics and presentation.
from luce_gpu import gpu
import interop
from luce_std import math
import ownership
import icons
import layout
import result
from icons import IconKind
from layout import Widget, Layout, Size, Constraints, Event
from painter import Painter
from font import Font, selected_font

pub struct PaneHeader: Widget:
    let box: interop.Reference[Layout]
    let font: interop.Reference[Font]
    var caption: interop.Owned[str]
    var description: interop.Owned[str]
    var icon: IconKind

    pub func init(text: str, icon: IconKind = IconKind.blank, detail: str = "", font: interop.Reference[Font]? = none) -> !:
        let selected = try selected_font(font)
        errdefer selected.release()
        _ = try selected.value().measure(text)
        _ = try selected.value().measure(detail)
        let caption = try interop.copy_text(text)
        errdefer caption.release()
        let description = try interop.copy_text(detail)
        errdefer description.release()
        let box = try layout.make_layout()
        errdefer box.release()
        try box.value().set_shrink(vertical = 0.0)
        self.box = box
        self.font = selected
        self.caption = caption
        self.description = description
        self.icon = icon

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

    pub func text() -> interop.Owned[str]:
        return self.caption.clone()

    pub func detail() -> interop.Owned[str]:
        return self.description.clone()

    pub func set_text(text: str) -> !:
        if text == self.caption.value:
            return
        _ = try self.font.value().measure(text)
        let replacement = try interop.copy_text(text)
        let previous_caption = self.caption
        self.caption = replacement
        previous_caption.release()
        self.box.value().invalidate()

    pub func set_detail(detail: str) -> !:
        if detail == self.description.value:
            return
        _ = try self.font.value().measure(detail)
        let replacement = try interop.copy_text(detail)
        let previous_description = self.description
        self.description = replacement
        previous_description.release()
        self.box.value().invalidate()

    pub func set_icon(icon: IconKind):
        if icon == self.icon:
            return
        self.icon = icon
        self.box.value().invalidate()

    func inset() -> f64:
        return math.ceil(self.font.value().advance() * self.box.value().theme().header_inset_cells)

    func title_x() -> f64:
        return self.inset() if self.icon == IconKind.blank else self.inset() * 2.0 + self.font.value().height()

    pub func measure(available: Constraints) -> interop.Outcome[Size]:
        let width = self.font.value().measure(self.caption.value) catch failure:
            return result.failure[Size](failure.code, failure.message)
        let height = self.box.value().theme().row_height(self.font)
        return result.success[Size](Size(self.title_x() + width + self.inset(), height))

    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()
        if self.icon != IconKind.blank:
            let extent = self.font.value().height()
            try icons.draw(&painter, self.icon, gpu.Rect(self.inset(), (size.height - extent) * 0.5, extent, extent), theme.foreground)
        let x = self.title_x()
        let y = math.max(0.0, (size.height - self.font.value().height()) * 0.5)
        try painter.text(self.caption.value, x, y, theme.foreground, self.font)
        let detail_x = x + (try self.font.value().measure(self.caption.value)) + self.inset() * 2.0
        if detail_x < size.width - self.inset() and self.description.value.length > 0:
            try painter.text(self.description.value, detail_x, y, theme.muted, self.font)

    pub func event(event: Event) -> interop.Outcome[unit]:
        return result.success[unit](())

    pub func close():
        self.description.release()
        self.caption.release()
        self.font.release()
        self.box.release()

    func trace(visit: func(ownership.Object*, void*) -> unit, context: void*):
        self.description.trace(visit, context)
        self.caption.trace(visit, context)
        self.font.trace(visit, context)
        self.box.trace(visit, context)

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