dymokomi/luce-ui
Source of release 0.19.1
0.19.1 / src / widgets / context_menu.lucb
## A context menu decorates any widget. The tree routes requests to the nearest
## provider after the clicked control has updated its selection.
from luce_gpu import gpu
import interop
import memory
import ownership
from luce_window import input
import layout
import result
from layout import Widget, Layout, Size, Constraints, Event
from command import Command
from font import Font, selected_font
from widgets.action_popup import ActionPopup, action_popup_type
pub struct ContextMenu: Widget:
let box: interop.Reference[Layout]
let popup: interop.Reference[ActionPopup]
let opening: interop.Signal[unit]
pub func init(content: interop.Interface[Widget], commands: const interop.Reference[Command][],
font: interop.Reference[Font]? = none) -> !:
let selected = try selected_font(font)
defer selected.release()
let box = try layout.make_layout()
errdefer box.release()
let content_box = try layout.widget_layout(content)
defer content_box.release()
try box.value().copy_sizing_from(content_box)
box.value().set_context_menu(true)
let popup = try interop.Reference[ActionPopup].adopt(new ActionPopup(commands, 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([content, widget])
let opening = try interop.Signal[unit]()
self.box = box
self.popup = popup
self.opening = opening
pub func layout() -> interop.Reference[Layout]:
return self.box.clone()
pub func on_open(callback: interop.Callback[unit, unit]) -> interop.Reference[interop.Connection]!:
return try self.opening.connect(callback)
## Choose the entries for the next opening, typically from an `on_open` handler
## that inspects the current selection before the menu is placed and shown.
pub func set_commands(commands: const interop.Reference[Command][]) -> !:
try self.popup.value().set_commands(commands)
## Open at (`x`, `y`) in the menu's own space; `held` when a press still
## under way opens it, so letting go over an item chooses that item.
pub func open_at(x: f64, y: f64, held: bool = false) -> !:
let notified = self.opening.emit(())
defer notified.release()
try notified.get()
let box = self.popup.value().layout()
defer box.release()
try box.value().set_popup_point(x, y)
try self.popup.value().open(held)
pub func is_open() -> bool:
return self.popup.value().is_open()
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)
pub func draw(target: interop.View[gpu.RenderTarget]) -> interop.Outcome[unit]:
return result.success[unit](())
pub func event(event: Event) -> interop.Outcome[unit]:
if event.kind == input.EventKind.pointer_down and event.button == 1:
self.open_at(event.x, event.y) catch failure:
return result.failure[unit](failure.code, failure.message)
return result.success[unit](())
pub func close():
self.opening.close()
self.opening.release()
self.popup.release()
self.box.release()
func trace(visit: func(ownership.Object*, void*) -> unit, context: void*):
self.opening.trace(visit, context)
self.popup.trace(visit, context)
self.box.trace(visit, context)
pub let context_menu_type: interop.Type[ContextMenu] = interop.Type[ContextMenu]("ContextMenu", ContextMenu.close, ContextMenu.trace, closeable = true, main_thread = true)