Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-ui

Source of release 0.19.5

0.19.5 / src / widgets / dialog.lucb

## The Dialog widget: a centered, non-modal floating card of rows that the host opens and hides.
from luce_gpu import gpu
from theme import default_spacing, default_padding
import interop
from luce_std import math
import ownership
import layout
import result
from layout import Widget, Layout, Size, Constraints, Event
from painter import Painter
from geometry import Point
from luce_window import input

## A floating card after Compositor's live-previewing panels: a raised face with
## a one-point border and the surface radius, centered in the window over the
## content, holding a column of rows. It is a non-modal popup: drawn over
## everything and hit first, while the rest of the window keeps working — a
## click on the canvas behind it reaches the canvas (a picker samples there),
## its own fields take focus and keys, and shortcuts stay live except plain
## keys while one of its fields is taking text. The host shows and hides it
## (`open`, `hide`) around an edit and gives it Cancel/OK buttons in its last row;
## while it is open Escape reports `on_cancel` and Enter `on_accept`, which the
## host connects to what those buttons do. Dragged by its face (anywhere a
## row does not take the press) it floats elsewhere and stays there.
pub struct Dialog: Widget:
    let box: interop.Reference[Layout]
    var width: f64
    let cancelled: interop.Signal[unit]
    let accepted: interop.Signal[unit]
    ## A drag of the face: where it began in the window, and the offset then.
    var dragging: bool
    var grab_x: f64
    var grab_y: f64
    var grab_offset: Point

    ## `width` is the card's fixed width in points (Compositor uses 340–460).
    pub func init(children: const interop.Interface[Widget][], width: f64 = 380.0, spacing: f64 = default_spacing, padding: f64 = default_padding) -> !:
        if not math.is_finite(width) or width < 40.0 or width > 4096.0:
            error(result.invalid, "a dialog needs a width between 40 and 4096 points")
        let box = try layout.make_layout(layout.Axis.vertical, spacing, padding, layout.Alignment.stretch)
        errdefer box.release()
        box.value().set_popup(true)
        box.value().set_modal(false)
        box.value().set_dialog(true)
        box.value().set_popup_placement(layout.PopupPlacement.window_center)
        box.value().set_visible(false)
        box.value().set_interactive(true)
        try box.value().set_children(children)
        let cancelled = try interop.Signal[unit]()
        errdefer cancelled.release()
        let accepted = try interop.Signal[unit]()
        self.box = box
        self.width = width
        self.cancelled = cancelled
        self.accepted = accepted
        self.dragging = false
        self.grab_x = 0.0
        self.grab_y = 0.0
        self.grab_offset = Point(0.0, 0.0)

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

    ## Replace the card's rows.
    pub func set_children(children: const interop.Interface[Widget][]) -> !:
        try self.box.value().set_children(children)

    ## Escape pressed while the dialog is open: what its Cancel button does.
    pub func on_cancel(callback: interop.Callback[unit, unit]) -> interop.Reference[interop.Connection]!:
        return try self.cancelled.connect(callback)

    ## Enter pressed while the dialog is open: what its OK button does.
    pub func on_accept(callback: interop.Callback[unit, unit]) -> interop.Reference[interop.Connection]!:
        return try self.accepted.connect(callback)

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

    pub func open():
        self.box.value().set_visible(true)

    pub func hide():
        self.box.value().set_visible(false)

    pub func measure(available: Constraints) -> interop.Outcome[Size]:
        let fixed = Constraints(self.width, available.height)
        let size = self.box.value().content_size(fixed) catch failure:
            return result.failure[Size](failure.code, failure.message)
        return result.success[Size](Size(self.width, size.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()
        let radius = math.min(theme.control_radius + 1.0, 8.0)
        try painter.rounded_rectangle(gpu.Rect(width = size.width, height = size.height), theme.border, radius)
        try painter.rounded_rectangle(gpu.Rect(1.0, 1.0, size.width - 2.0, size.height - 2.0), theme.raised, math.max(0.0, radius - 1.0))

    ## The tree hands an open dialog Escape and Enter (see `set_dialog`).
    pub func event(event: Event) -> interop.Outcome[unit]:
        # Positions in the window: the face moves under the pointer as it drags.
        let bounds = self.box.value().bounds()
        let x = bounds.x + event.x
        let y = bounds.y + event.y
        if event.kind == input.EventKind.pointer_down and event.button == 0 and event.inside and self.is_open():
            self.dragging = true
            self.grab_x = x
            self.grab_y = y
            let offset = self.box.value().popup_offset()
            self.grab_offset = Point(offset.x, offset.y)
            return result.success[unit](())
        if event.kind == input.EventKind.pointer_moved and self.dragging:
            self.box.value().set_popup_offset(self.grab_offset.x + x - self.grab_x, self.grab_offset.y + y - self.grab_y) catch failure:
                return result.failure[unit](failure.code, failure.message)
            return result.success[unit](())
        if (event.kind == input.EventKind.pointer_up and event.button == 0) or event.cancelled:
            self.dragging = false
        if event.kind == input.EventKind.key_down and self.is_open():
            if event.key == input.Key.escape:
                return self.cancelled.emit(())
            if event.key == input.Key.enter:
                return self.accepted.emit(())
        return result.success[unit](())

    pub func close():
        self.cancelled.close()
        self.cancelled.release()
        self.accepted.close()
        self.accepted.release()
        self.box.release()

    func trace(visit: func(ownership.Object*, void*) -> unit, context: void*):
        self.box.trace(visit, context)
        self.cancelled.trace(visit, context)
        self.accepted.trace(visit, context)

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

test "a dialog starts hidden, opens and hides":
    var empty: interop.Interface[Widget][]
    var card = try Dialog(empty, 340.0)
    defer card.close()
    assert(not card.is_open())
    card.open()
    assert(card.is_open())
    card.hide()
    assert(not card.is_open())
    var rejected = false
    _ = Dialog(empty, 10.0) catch failure:
        assert(failure.code == result.invalid)
        rejected = true
        recover try Dialog(empty)
    assert(rejected)

test "a dialog dragged by its face keeps its offset from the centre":
    var empty: interop.Interface[Widget][]
    var card = try Dialog(empty, 340.0)
    defer card.close()
    card.open()
    _ = card.event(Event(kind = input.EventKind.pointer_down, x = 10.0, y = 10.0, button = 0, inside = true))
    _ = card.event(Event(kind = input.EventKind.pointer_moved, x = 30.0, y = 25.0, inside = true))
    _ = card.event(Event(kind = input.EventKind.pointer_up, x = 30.0, y = 25.0, button = 0, inside = true))
    let offset = card.layout().value().popup_offset()
    assert(offset.x == 20.0 and offset.y == 15.0)
    # Moves after letting go leave it where it is.
    _ = card.event(Event(kind = input.EventKind.pointer_moved, x = 90.0, y = 90.0, inside = true))
    assert(card.layout().value().popup_offset().x == 20.0)