dymokomi/luce-ui
Source of release 0.19.6
0.19.6 / 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)