Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-ui

Source of release 0.19.3

0.19.3 / src / widgets / menu.lucb

## A menu composes a compact trigger and a popup action list. Layout owns popup
## placement, clipping, modal dispatch and focus restoration; this module owns
## only menu selection and command presentation.
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 font import Font, selected_font
from command import Command, Commands
from painter import Painter

from widgets.action_popup import ActionPopup, action_popup_type

pub struct Menu: Widget:
    let box: interop.Reference[Layout]
    var caption: interop.Owned[str]
    let font: interop.Reference[Font]
    let popup: interop.Reference[ActionPopup]
    var pressed: bool

    pub func init(text: str, actions: const interop.Reference[Command][], font: interop.Reference[Font]? = none) -> !:
        let selected = try selected_font(font)
        errdefer selected.release()
        _ = try selected.value().measure(text)
        let caption = try interop.copy_text(text)
        errdefer caption.release()
        let box = try layout.make_layout()
        errdefer box.release()
        try box.value().set_shrink(vertical = 0.0)
        box.value().set_focusable(true)
        box.value().set_cursor(input.Cursor.pointer)
        box.value().set_menu_trigger(true)
        let popup = try interop.Reference[ActionPopup].adopt(new ActionPopup(actions, selected) in memory.heap, action_popup_type, memory.heap)
        errdefer popup.release()
        let widget = popup.as_interface[Widget](popup.value())
        defer widget.release()
        try box.value().set_children([widget])
        self.box = box
        self.caption = caption
        self.font = selected
        self.popup = popup
        self.pressed = false

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

    ## Retitle the menu, for one whose title names the current choice.
    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()

    ## Offer `actions` from now on, as a menu whose choices depend on another
    ## (a font's styles on its family).
    pub func set_actions(actions: const interop.Reference[Command][]) -> !:
        try self.popup.value().set_commands(actions)

    pub func open() -> !:
        try self.popup.value().open()

    pub func is_open() -> bool:
        return self.popup.value().is_open()

    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 theme = self.box.value().theme()
        return result.success[Size](Size(width + theme.inset(self.font) * 2.0, theme.row_height(self.font)))

    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()
        # An open title is the selected control; focus and hover show only the wash.
        let whole = gpu.Rect(width = size.width, height = size.height)
        if self.is_open():
            try painter.rounded_rectangle(whole, theme.menu_selection, theme.control_radius)
        elif self.box.value().is_focused() or self.box.value().contains_pointer():
            try painter.rounded_rectangle(whole, theme.menu_hover, theme.control_radius)
        let plain = theme.foreground if self.box.value().is_enabled() else theme.muted
        let ink = theme.on_menu_selection(plain) if self.is_open() else plain
        try painter.text(self.caption.value, theme.inset(self.font), (size.height - self.font.value().height()) * 0.5, ink, self.font)

    pub func event(event: Event) -> interop.Outcome[unit]:
        if event.menu_requested:
            self.open() catch failure:
                return result.failure[unit](failure.code, failure.message)
        elif event.cancelled:
            self.pressed = false
        elif event.kind == input.EventKind.pointer_down and event.button == 0 and event.inside:
            self.pressed = true
        elif event.kind == input.EventKind.pointer_up and event.button == 0:
            let activate = self.pressed and event.inside
            self.pressed = false
            if activate:
                self.open() catch failure:
                    return result.failure[unit](failure.code, failure.message)
        elif event.kind == input.EventKind.key_down and not event.repeated and (event.key == input.Key.enter or event.key == input.Key.space or event.key == input.Key.down):
            self.open() catch failure:
                return result.failure[unit](failure.code, failure.message)
        return result.success[unit](())

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

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

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