dymokomi/luce-ui
Source of release 0.19.5
0.19.5 / src / widgets / split_view.lucb
## A two-pane splitter nests to build larger workspaces. Its divider participates
## in normal pointer capture and keyboard focus, and holds only a weak parent.
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, Axis
from painter import Painter
struct Divider: Widget:
let box: interop.Reference[Layout]
let parent: interop.WeakReference[Layout]
let horizontal: bool
let thickness: f64
var dragging: bool
var grab: f64
pub func init(parent: interop.Reference[Layout], horizontal: bool, thickness: f64) -> !:
let box = try layout.make_layout()
box.value().set_focusable(true)
box.value().set_cursor(input.Cursor.resize_horizontal if horizontal else input.Cursor.resize_vertical)
self.box = box
self.parent = interop.WeakReference[Layout](parent)
self.horizontal = horizontal
self.thickness = thickness
self.dragging = false
self.grab = 0.0
pub func layout() -> interop.Reference[Layout]:
return self.box.clone()
pub func measure(available: Constraints) -> interop.Outcome[Size]:
return result.success[Size](Size(self.thickness, self.thickness))
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()
try painter.rectangle(gpu.Rect(width = size.width, height = size.height), theme.background)
# Pane edges define the resting boundary. The center grip appears only
# during interaction, keeping a wide hit target without a third idle rule.
if not self.dragging and not self.box.value().is_focused() and not self.box.value().contains_pointer():
return
let line = gpu.Rect(x = (size.width - 1.0) * 0.5, width = 1.0, height = size.height) if self.horizontal else gpu.Rect(y = (size.height - 1.0) * 0.5, width = size.width, height = 1.0)
try painter.rectangle(line, theme.accent)
pub func event(event: Event) -> interop.Outcome[unit]:
self.handle(event) catch failure:
return result.failure[unit](failure.code, failure.message)
return result.success[unit](())
func handle(event: Event) -> !:
if event.cancelled:
self.dragging = false
self.box.value().invalidate()
return
let parent = self.parent.get() else return
defer parent.release()
let bounds = parent.value().bounds()
let own = self.box.value().bounds()
let available = math.max(0.0, (bounds.width if self.horizontal else bounds.height) - self.thickness)
if available == 0.0:
return
let position = own.x - bounds.x if self.horizontal else own.y - bounds.y
if event.kind == input.EventKind.pointer_down and event.button == 0 and event.inside:
self.dragging = true
self.grab = event.x if self.horizontal else event.y
self.box.value().invalidate()
elif event.kind == input.EventKind.pointer_moved and self.dragging:
let coordinate = event.x if self.horizontal else event.y
try parent.value().set_split(math.clamp((position + coordinate - self.grab) / available, 0.0, 1.0))
elif event.kind == input.EventKind.pointer_up and event.button == 0:
self.dragging = false
self.box.value().invalidate()
elif event.kind == input.EventKind.key_down:
let backward = event.key == input.Key.left if self.horizontal else event.key == input.Key.up
let forward = event.key == input.Key.right if self.horizontal else event.key == input.Key.down
if backward or forward:
let step = 32.0 if event.shift else 8.0
try parent.value().set_split(math.clamp((position + (step if forward else -step)) / available, 0.0, 1.0))
elif event.key == input.Key.home:
try parent.value().set_split(0.0)
elif event.key == input.Key.end:
try parent.value().set_split(1.0)
pub func close():
self.parent.release()
self.box.release()
func trace(visit: func(ownership.Object*, void*) -> unit, context: void*):
self.box.trace(visit, context)
let divider_type: interop.Type[Divider] = interop.Type[Divider]("Split divider", Divider.close, Divider.trace, closeable = true, main_thread = true)
pub struct SplitView: Widget:
let box: interop.Reference[Layout]
pub func init(first: interop.Interface[Widget], second: interop.Interface[Widget],
axis: Axis = Axis.horizontal, fraction: f64 = 0.5, handle_width: f64 = 5.0) -> !:
if not math.is_finite(handle_width) or handle_width < 3.0 or handle_width > 32.0:
error(result.invalid, "split handle width must be in 3..32")
let box = try layout.make_layout(axis)
errdefer box.release()
try box.value().set_flex()
let divider = try interop.Reference[Divider].adopt(new Divider(box, axis == Axis.horizontal, handle_width) in memory.heap, divider_type, memory.heap)
defer divider.release()
let widget = divider.as_interface[Widget](divider.value())
defer widget.release()
try box.value().set_children([first, widget, second])
try box.value().set_split(fraction)
let leading = try layout.widget_layout(first)
defer leading.release()
let trailing = try layout.widget_layout(second)
defer trailing.release()
let a = leading.value().minimum_size()
let b = trailing.value().minimum_size()
let minimum = Size(a.width + b.width + handle_width, math.max(a.height, b.height)) if axis == Axis.horizontal else Size(math.max(a.width, b.width), a.height + b.height + handle_width)
try box.value().set_limits(minimum, Size(16384.0, 16384.0))
self.box = box
pub func layout() -> interop.Reference[Layout]:
return self.box.clone()
pub func fraction() -> f64:
return self.box.value().split_fraction()
pub func set_fraction(fraction: f64) -> !:
try self.box.value().set_split(fraction)
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]:
return result.success[unit](())
pub func close():
self.box.release()
func trace(visit: func(ownership.Object*, void*) -> unit, context: void*):
self.box.trace(visit, context)
pub let split_view_type: interop.Type[SplitView] = interop.Type[SplitView]("SplitView", SplitView.close, SplitView.trace, closeable = true, main_thread = true)