dymokomi/luce-ui
Source of release 0.19.2
0.19.2 / src / docking / state / panels.lucb
#==============================================================================================
#
# docking/state/panels - Adding, selecting, moving and closing panels
#
#==============================================================================================
extend State:
## Attach the preview overlay and the add menu and rebuild the stack's
## children; the DStack does this once, before adding panels.
pub func install(overlay: interop.Interface[Widget], popup: interop.Reference[ActionPopup]) -> !:
self.overlay = overlay.clone()
self.popup = popup.clone()
try self.children()
## Dock `panel` in the first free slot relative to `relative`, or to the active
## panel when there is none; a floating relative stands for the model's active
## panel. Cancels any gesture, then selects and focuses the new panel.
pub func add(panel: interop.Reference[Panel], relative: interop.Reference[Panel]?, position: DockPosition) -> !:
self.cancel()
var slot: usize = 0
for index in 1..<self.panels.length:
if self.panels[index] == none:
slot = index
break
if slot == 0: error(result.limit, "a dynamic stack supports at most 128 panels")
var target = self.active()
if self.floating(target): target = self.model.active
if let other = relative:
target = try self.index(other)
if self.floating(target): target = self.model.active
let caption = (try panel.get()).text()
defer caption.release()
_ = try self.font.value().measure(caption.value)
var next = self.model
try next.add(slot, target, position)
try self.children(slot, panel)
self.panels[slot] = panel.clone()
self.publish(next)
try self.select(slot)
## Show slot `index`: raise its window when it floats, else make it its
## group's tab and the active panel. With `focus`, also request focus for its
## content and emit `selected`.
pub func select(index: usize, focus: bool = true) -> !:
if self.floating(index):
try self.raise_window(index)
else:
var next = self.model
try next.select(index)
self.publish(next)
if focus:
let panel = try self.panel(index)
defer panel.release()
let box = panel.value().layout()
defer box.release()
box.value().request_focus()
let delivered = self.selected.emit(panel)
defer delivered.release()
try delivered.get()
## Redock `panel` relative to `relative` and select it. A floating panel docks
## back, beside the model's active panel when `relative` floats too.
pub func move(panel: interop.Reference[Panel], relative: interop.Reference[Panel], position: DockPosition) -> !:
self.cancel()
let index = try self.index(panel)
let target = try self.index(relative)
if self.floating(index):
var next = self.model
try next.add(index, 0 if next.root == 0 else (self.model.active if self.floating(target) else target), position)
try self.dock(index, next)
return
var next = self.model
try next.move(index, target, position)
self.publish(next)
try self.select(index)
## Take `panel` out, docked or floating, release it, select the new active
## panel and emit `closed`. The close handler is not consulted here.
pub func remove(panel: interop.Reference[Panel]) -> !:
self.cancel()
let index = try self.index(panel)
let removed = panel.clone()
defer removed.release()
var next = self.model
let floated = self.floating(index)
if not floated: try next.remove(index)
try self.children(remove = index)
if floated:
self.unstack(index)
if let frame = self.frames[index]:
self.frames[index] = none
frame.release()
let previous = self.panels[index] else trap("missing retained panel")
self.panels[index] = none
previous.release()
self.publish(next)
if next.active != 0: try self.select(next.active)
let delivered = self.closed.emit(removed)
defer delivered.release()
try delivered.get()
## Consulted before a user close; returning false keeps the panel.
pub func set_close_handler(callback: interop.Callback[interop.Reference[Panel], bool]):
let replacement = callback.clone()
if let previous = self.close_handler: previous.release()
self.close_handler = replacement
func request_close(index: usize) -> !:
let panel = try self.panel(index)
defer panel.release()
if not panel.value().is_closable(): return
if let callback = self.close_handler:
let allowed = callback.invoke(panel)
defer allowed.release()
if not (try allowed.get()): return
try self.remove(panel)