dymokomi/luce-ui
Source of release 0.19.6
0.19.6 / src / docking / state / input.lucb
#==============================================================================================
#
# docking/state/input - Presses, keys and cursors on the stack's own chrome
#
#==============================================================================================
extend State:
pub func cursor(position: Point, captured: bool) -> input.Cursor:
if self.dragging: return input.Cursor.grabbing
let model = self.visible_model()
if captured and self.resize != 0:
return input.Cursor.resize_horizontal if model.nodes[self.resize].horizontal else input.Cursor.resize_vertical
let geometry = self.geometry(self.size())
for node in 1..<model.nodes.length:
if not model.nodes[node].used: continue
if model.nodes[node].first != 0:
if strip.contains(geometry.dividers[node], position.x, position.y):
return input.Cursor.resize_horizontal if model.nodes[node].horizontal else input.Cursor.resize_vertical
continue
let bounds = geometry.panes[node]
let header = self.strip(node, bounds)
if strip.contains(header.add, position.x, position.y) or strip.contains(header.previous, position.x, position.y) or strip.contains(header.next, position.x, position.y):
return input.Cursor.pointer
if strip.contains(gpu.Rect(bounds.x, bounds.y, bounds.width, self.height() + 1.0), position.x, position.y):
for order in header.first..<header.first + header.count:
let tab = header.tab(order)
if strip.contains(tab, position.x, position.y) and position.x >= tab.x + tab.width - self.height():
if let panel = self.panels[model.at(node, order)]:
if panel.value().is_closable(): return input.Cursor.pointer
return input.Cursor.grab
if model.root == 0 and strip.contains(gpu.Rect(math.max(0.0, self.size().width - self.height()), 0.0, self.height(), self.height()), position.x, position.y):
return input.Cursor.pointer
return input.Cursor.arrow
## Abandon any press, divider drag, tab drag or window gesture, and show the
## committed model again.
pub func cancel():
self.gesture = Gesture.idle
self.float_pressed = 0
self.detached = none
self.pressed_tab = 0
self.pressed_close = 0
self.pressed_add = 0
self.resize = 0
self.dragging = false
self.drag_inside = false
self.show_visible()
## Which piece of the chrome lights under (`x`, `y`), as the chrome draws its
## hover (a divider, a tab or its close button, a strip button), as one number;
## 0 for none. The stack draws again only when it changes (`Layout.hover_part`).
pub func chrome_part(x: f64, y: f64) -> i64:
let geometry = self.geometry(self.size())
if self.model.root == 0:
let add = gpu.Rect(math.max(0.0, self.size().width - self.height()), 0.0, self.height(), self.height())
return 1 if strip.contains(add, x, y) else 0
for group in 1..<self.model.nodes.length:
let node = self.model.nodes[group]
if not node.used: continue
let base = (i64)group * 4096
if node.first != 0:
if strip.contains(geometry.dividers[group], x, y): return base + 1
continue
let header = self.strip(group, geometry.panes[group])
if strip.contains(header.previous, x, y): return base + 2
if strip.contains(header.next, x, y): return base + 3
if strip.contains(header.add, x, y): return base + 4
for order in header.first..<header.first + header.count:
let bounds = header.tab(order)
if bounds.width > 0.0 and strip.contains(bounds, x, y):
let closing = x >= bounds.x + bounds.width - bounds.height
return base + 8 + (i64)order * 2 + (1 if closing else 0)
return 0
## The stack's own input, for presses on its chrome rather than panel content.
## A press on a divider drags it; on an add button it opens the menu on
## release; on a tab it selects it, or on the tab's close button asks to close
## it on release. A tab dragged four points detaches and, on release, docks
## where it is dropped or floats. The wheel over a header and Left/Right step
## through tabs, Enter or Down focuses the active tab's content, Control-N
## opens the add menu, and arrows (Shift for bigger steps), Home and End move
## a divider pressed last. Escape or cancellation abandons the gesture.
pub func handle(event: Event) -> !:
if event.cancelled or (event.kind == input.EventKind.key_down and event.key == input.Key.escape):
self.cancel()
return
let geometry = self.geometry(self.size())
if event.kind == input.EventKind.pointer_down and event.button == 0 and event.inside:
self.cancel()
self.focused_divider = 0
self.divider_keyed = false
self.start = Point(event.x, event.y)
for node in 1..<self.model.nodes.length:
if self.model.nodes[node].used and self.model.nodes[node].first != 0 and strip.contains(geometry.dividers[node], event.x, event.y):
self.resize = node
self.focused_divider = node
self.grab = event.x - geometry.dividers[node].x if self.model.nodes[node].horizontal else event.y - geometry.dividers[node].y
return
if self.model.root == 0:
let add = gpu.Rect(math.max(0.0, self.size().width - self.height()), 0.0, self.height(), self.height())
if strip.contains(add, event.x, event.y): self.pressed_add = 65
return
for group in 1..<self.model.nodes.length:
if not self.model.nodes[group].used or self.model.nodes[group].first != 0: continue
let header = self.strip(group, geometry.panes[group])
if strip.contains(header.add, event.x, event.y):
self.pressed_add = group
return
if strip.contains(header.previous, event.x, event.y) or strip.contains(header.next, event.x, event.y):
try self.step(group, strip.contains(header.previous, event.x, event.y))
return
if event.y < geometry.panes[group].y + 1.0 or event.y >= geometry.panes[group].y + 1.0 + self.height() or not strip.contains(geometry.panes[group], event.x, event.y): continue
var selected = self.model.nodes[group].selected
for order in header.first..<header.first + header.count:
let bounds = header.tab(order)
if strip.contains(bounds, event.x, event.y):
selected = self.model.at(group, order)
let panel = try self.panel(selected)
defer panel.release()
if panel.value().is_closable() and event.x >= bounds.x + bounds.width - self.height():
self.pressed_close = selected
return
break
self.pressed_tab = selected
try self.select(selected, focus = false)
return
elif event.kind == input.EventKind.pointer_moved:
if self.resize != 0:
try self.resize_to(geometry, event.x, event.y)
elif self.pressed_tab != 0:
let dx = event.x - self.start.x
let dy = event.y - self.start.y
if not self.dragging and dx * dx + dy * dy >= 16.0:
var detached = self.model
try detached.remove(self.pressed_tab)
self.detached = detached
self.dragging = true
self.show_visible()
if self.dragging:
self.drag_pointer = Point(event.x, event.y)
self.drag_inside = event.inside
# The detached model was laid out when the drag began; a move
# only moves the drop preview.
self.repaint()
elif event.kind == input.EventKind.pointer_up and event.button == 0:
let tab = self.pressed_tab
let closing = self.pressed_close
let adding = self.pressed_add
let dragged = self.dragging
let drop = self.drop_at(event.x, event.y) if dragged and event.inside else drag.Drop()
# Prepare the final topology while the detached geometry is still
# available, then restore/cancel the gesture before publishing it.
var committed: Model? = none
if dragged and drop.accepted:
committed = try self.insertion(drop, event.x, event.y)
let window = self.float_window(tab, Point(event.x, event.y)) if dragged and not drop.accepted else gpu.Rect()
self.cancel()
if adding != 0 and event.inside:
let group = 0 if adding == 65 else adding
if group == 0 or strip.contains(self.strip(group, geometry.panes[group]).add, event.x, event.y):
try self.open_menu(group)
elif closing != 0 and event.inside:
let bounds = try self.tab_bounds(closing)
if strip.contains(bounds, event.x, event.y) and event.x >= bounds.x + bounds.width - self.height():
try self.request_close(closing)
elif tab != 0:
if window.width > 0.0:
try self.make_floating(tab, window)
return
if let next = committed: self.publish(next)
try self.select(tab)
elif event.kind == input.EventKind.scroll:
for group in 1..<self.model.nodes.length:
if self.model.nodes[group].used and self.model.nodes[group].first == 0:
let bounds = geometry.panes[group]
if strip.contains(gpu.Rect(bounds.x, bounds.y, bounds.width, self.height() + 1.0), event.x, event.y):
try self.step(group, event.scroll_y > 0.0 or event.scroll_x > 0.0)
return
elif event.kind == input.EventKind.key_down and not event.repeated:
if self.focused_divider != 0 and self.model.nodes[self.focused_divider].used and self.model.nodes[self.focused_divider].first != 0:
let node = self.focused_divider
let horizontal = self.model.nodes[node].horizontal
let backward = event.key == input.Key.left if horizontal else event.key == input.Key.up
let forward = event.key == input.Key.right if horizontal else event.key == input.Key.down
if event.key == input.Key.home or event.key == input.Key.end or backward or forward:
self.divider_keyed = true
if event.key == input.Key.home or event.key == input.Key.end:
self.model.nodes[node].fraction = 0.0 if event.key == input.Key.home else 1.0
self.invalidate()
elif backward or forward:
let bounds = geometry.dividers[node]
let delta = (32.0 if event.shift else 8.0) * (-1.0 if backward else 1.0)
self.resize = node
self.grab = 0.0
try self.resize_to(geometry, bounds.x + (delta if horizontal else 0.0), bounds.y + (0.0 if horizontal else delta))
self.resize = 0
elif self.active() != 0:
let group = self.model.tabs[self.active()].group
if event.key == input.Key.left or event.key == input.Key.right:
try self.step(group, event.key == input.Key.left)
elif event.key == input.Key.enter or event.key == input.Key.down:
try self.select(self.model.nodes[group].selected)
elif event.key == input.Key.n and event.control:
try self.open_menu(group)
func step(group: usize, backwards: bool) -> !:
let current = self.model.tabs[self.model.nodes[group].selected].order
let count = self.model.tab_count(group)
let next = (current + count - 1) % count if backwards else (current + 1) % count
let index = self.model.at(group, next)
try self.select(index, focus = false)
let panel = try self.panel(index)
defer panel.release()
let delivered = self.selected.emit(panel)
defer delivered.release()
try delivered.get()
func resize_to(geometry: Geometry, x: f64, y: f64) -> !:
if not math.is_finite(x) or not math.is_finite(y):
error(result.invalid, "divider position must be finite")
let bounds = geometry.panes[self.resize]
let horizontal = self.model.nodes[self.resize].horizontal
let available = math.max(0.0, (bounds.width if horizontal else bounds.height) - 5.0)
if available == 0.0: return
self.model.nodes[self.resize].fraction = math.clamp(((x - bounds.x if horizontal else y - bounds.y) - self.grab) / available, 0.0, 1.0)
self.reposition()