dymokomi/luce-ui
Source of release 0.19.4
0.19.4 / src / layout / drops.lucb
#==============================================================================================
#
# layout/drops - Drags: files from other applications, and items one widget drags to
# another in the same window; their payloads and drop areas
#
#==============================================================================================
## The files of the drag in progress, or of the last drop, copied from the window
## (or given by a test); read through a drop area's `drop_path`. UI thread only.
var drop_payload: str[16]
var drop_payload_count: usize = 0
## Replace the dragged files the drop areas see; only the first 16 are kept. The
## application does this from the window when a drag enters; tests and
## embedders call it themselves.
pub func set_drop_payload(paths: const str[]) -> !:
for index in 0..<drop_payload_count:
let old = drop_payload[index]
free(u8[]((u8*)old.bytes.data, old.length + 1)) in memory.heap
drop_payload[index] = ""
drop_payload_count = 0
for path in paths:
if drop_payload_count >= drop_payload.length:
break
let copy = try new u8[path.length + 1] --- in memory.heap
for index in 0..<path.length:
copy[index] = path.bytes[index]
copy[path.length] = 0
drop_payload[drop_payload_count] = (str)copy[..<path.length]
drop_payload_count += 1
# mark: Drags inside the window ===============================================================
## The drag one widget started (`Layout.start_drag`): asked for while the widget handled
## an event (`pending`), carried by the tree from then on (`active`) until it drops, is
## cancelled, or the window loses focus. UI thread only.
var drag_pending: bool = false
var drag_active: bool = false
var drag_source: u64 = 0
var drag_kind_text: str = ""
var drag_items: i64[]
var drag_label_text: str = ""
var drag_image: interop.Reference[Image]? = none
var drag_font: interop.Reference[Font]? = none
var drag_copy_now: bool = false
## A heap copy of `text`, NUL-terminated; "" stays "".
func owned_text(text: str) -> str!:
if text.length == 0:
return ""
let copy = try new u8[text.length + 1] --- in memory.heap
for index in 0..<text.length:
copy[index] = text.bytes[index]
copy[text.length] = 0
return (str)copy[..<text.length]
func free_text(text: str):
if text.length > 0:
free(u8[]((u8*)text.bytes.data, text.length + 1)) in memory.heap
## The drag inside the window ends, whichever way: its payload goes.
func end_drag():
drag_pending = false
drag_active = false
drag_source = 0
drag_copy_now = false
free_text(drag_kind_text)
drag_kind_text = ""
free_text(drag_label_text)
drag_label_text = ""
if drag_items.length > 0:
free(drag_items) in memory.heap
var none_left: i64[]
drag_items = none_left
if let picture = drag_image:
picture.release()
drag_image = none
if let font = drag_font:
font.release()
drag_font = none
## Whether `kinds`, kinds joined by newlines (`set_drag_target`), names `kind`.
func names_kind(kinds: str, kind: str) -> bool:
var start: usize = 0
while start <= kinds.length:
var end = start
while end < kinds.length and kinds.bytes[end] != '\n':
end += 1
if (str)kinds.bytes[start..<end] == kind:
return true
start = end + 1
return false
extend Layout:
## Start dragging `items`, of `kind`, from this box: called from the widget's
## `pointer_moved` while the pointer is held, typically once it has moved a few
## points from the press. When the event returns the tree takes the pointer: the
## widget gets a cancellation, the drop areas taking `kind` (`set_drag_target`) get
## the drag's events, and `image` (the lead item's picture) and the count, with
## `label` when given, follow the pointer. What `items` mean (indices, ids) is the
## application's; the areas read them with `drag_item`.
pub func start_drag(kind: str, items: const i64[], image: interop.Reference[Image]? = none, label: str = "") -> !:
if kind.length == 0:
error(result.invalid, "a drag needs a kind")
if items.length == 0:
error(result.invalid, "a drag needs at least one item")
end_drag()
errdefer end_drag()
drag_kind_text = try owned_text(kind)
drag_label_text = try owned_text(label)
let copies = try new i64[items.length] --- in memory.heap
for index in 0..<items.length:
copies[index] = items[index]
drag_items = copies
if let picture = image:
drag_image = picture.clone()
drag_font = try selected_font(none)
drag_source = self.identifier
drag_pending = true
## Make this box an area that items dragged inside the window (`start_drag`) of any
## of `kinds` can be dropped on; no kinds makes it none. Its widget gets
## `drag_entered`, `drag_moved`, `drag_left` and `drop` in local coordinates, as a
## file drop area does, reads the drag with `drag_kind`, `drag_count`,
## `drag_item` and `drag_copy`, and refuses a drop at a point with
## `set_drop_accepted(false)` from its `drag_entered` or `drag_moved`. With
## `overlay` the area is lit in the accent while a drop would be taken; a widget
## lighting the row under the pointer itself passes false.
pub func set_drag_target(kinds: const str[], overlay: bool = true) -> !:
var length: usize = 0
for kind in kinds:
if kind.length == 0:
error(result.invalid, "a drag kind is empty")
for byte in kind.bytes:
if byte == '\n':
error(result.invalid, "a drag kind holds a line break")
length += kind.length + 1
var joined = ""
if length > 0:
let room = try new u8[length] --- in memory.heap
var at: usize = 0
for kind in kinds:
if at > 0:
room[at - 1] = '\n'
for byte in kind.bytes:
room[at] = byte
at += 1
at += 1
room[length - 1] = 0
joined = (str)room[..<length - 1]
free_text(self.drag_kinds)
self.drag_kinds = joined
self.drag_overlay = overlay
self.invalidate()
pub func is_drag_target() -> bool:
return self.drag_kinds.length > 0
## The kind of the drag inside the window under way; empty for files dragged
## from another application, or no drag.
pub func drag_kind() -> interop.Owned[str]!:
return try interop.copy_text(drag_kind_text if drag_active else "")
## How many items the drag inside the window carries (0 with none).
pub func drag_count() -> i64:
return (i64)drag_items.length if drag_active else 0
## Item `index` of the drag inside the window, as its source gave it.
pub func drag_item(index: i64) -> i64!:
if not drag_active or index < 0 or index >= (i64)drag_items.length:
error(result.invalid, "no dragged item has that index")
return drag_items[(usize)index]
## Whether the drag would copy rather than move: Option (Alt) is held.
pub func drag_copy() -> bool:
return drag_active and drag_copy_now
## Whether this box started the drag under way.
pub func is_drag_source() -> bool:
return (drag_active or drag_pending) and drag_source == self.identifier
extend Tree:
## Whether a drop would be taken where the drag is now: the application tells
## the window so after every drag event.
pub func drop_accepted() -> bool:
let index = self.find(self.drop_hover) else return false
return self.entries[index].box.value().drop_accepted
## The innermost visible, enabled drop area under a point (a popup's, while one is open).
func drop_at(x: f64, y: f64) -> u64:
let modal = self.has_popup()
var index = self.count
while index > 0:
index -= 1
let box = self.entries[index].box.value()
let taking = names_kind(box.drag_kinds, drag_kind_text) if drag_active else box.drop_target
if taking and (not modal or in_popup(self.entries, index)) and path_enabled(self.entries, index) and inside(box.clipping, x, y):
return box.identifier
return 0
## Route a drag: the area under the pointer gets entered/moved, the one it
## left gets left, and a drop goes to the area that takes it.
func dispatch_drag(kind: input.EventKind, x: f64, y: f64) -> interop.Outcome[unit]:
let target = 0 if kind == input.EventKind.drag_left else self.drop_at(x, y)
if target != self.drop_hover:
let left = self.leave_drop()
if not left.is_success():
return left
left.release()
if let index = self.find(target):
let box = self.entries[index].box.value()
box.drop_accepted = true
box.drop_hovered = true
box.invalidate()
self.drop_hover = target
let entered = self.send_drag(index, input.EventKind.drag_entered, x, y)
if not entered.is_success():
return entered
entered.release()
elif kind == input.EventKind.drag_moved:
if let index = self.find(target):
let moved = self.send_drag(index, input.EventKind.drag_moved, x, y)
if not moved.is_success():
return moved
moved.release()
if kind == input.EventKind.drop:
if let index = self.find(self.drop_hover):
let box = self.entries[index].box.value()
box.drop_hovered = false
box.invalidate()
self.drop_hover = 0
if box.drop_accepted:
return self.send_drag(index, input.EventKind.drop, x, y)
return result.success[unit](())
func leave_drop() -> interop.Outcome[unit]:
let found = self.find(self.drop_hover)
if found == none:
self.drop_hover = 0
return result.success[unit](())
let index = found else return result.success[unit](())
let box = self.entries[index].box.value()
box.drop_hovered = false
box.invalidate()
self.drop_hover = 0
return self.send_drag(index, input.EventKind.drag_left, 0.0, 0.0)
func send_drag(index: usize, kind: input.EventKind, x: f64, y: f64) -> interop.Outcome[unit]:
let box = self.entries[index].box.value()
return self.send(index, Event(kind = kind, x = x - box.rectangle.x, y = y - box.rectangle.y, inside = true))
## The lit drop area: the accent laid thinly over it with a two-point edge,
## so the place a drop would land is plain.
func draw_drop_overlay(target: interop.View[gpu.RenderTarget]) -> !:
let index = self.find(self.drop_hover) else return
let box = self.entries[index].box.value()
let overlay = box.drag_overlay if drag_active else box.drop_overlay
if not overlay or not box.drop_accepted or box.clipping.width <= 0.0 or box.clipping.height <= 0.0:
return
let native_target = try target.get()
let clipped = try native_target.clipped(box.clipping)
defer clipped.release()
let region = try (try clipped.get()).region(box.rectangle)
defer region.release()
var painter = try Painter(region)
defer painter.close()
let theme = box.appearance
let area = gpu.Rect(width = box.rectangle.width, height = box.rectangle.height)
try painter.rounded_rectangle(area, theme.accent, theme.control_radius, 0.14)
let edge = 2.0
try painter.rectangle(gpu.Rect(0.0, 0.0, area.width, edge), theme.accent)
try painter.rectangle(gpu.Rect(0.0, area.height - edge, area.width, edge), theme.accent)
try painter.rectangle(gpu.Rect(0.0, 0.0, edge, area.height), theme.accent)
try painter.rectangle(gpu.Rect(area.width - edge, 0.0, edge, area.height), theme.accent)
## Begin the drag a widget asked for while handling `event` (`Layout.start_drag`):
## the box holding the pointer lets go of it (a cancellation) and the drag is
## carried from where the pointer is.
func begin_drag(event: input.Event) -> interop.Outcome[unit]:
drag_pending = false
drag_active = true
drag_copy_now = event.modifiers.alt
let cancelled = self.cancel(self.capture)
if not cancelled.is_success():
end_drag()
return cancelled
cancelled.release()
self.capture = 0
return self.dispatch_drag(input.EventKind.drag_moved, event.x, event.y)
## While a drag inside the window is under way the pointer carries it: moves go to
## the drop areas, the primary release drops, and Escape or losing focus cancels
## it; Option (Alt) makes it a copy. Scrolling is routed as ever (`dispatch`).
func carry_drag(event: input.Event) -> interop.Outcome[unit]:
match event.kind:
.pointer_moved, .pointer_entered:
self.pointer_x = event.x
self.pointer_y = event.y
self.pointer_present = math.is_finite(event.x) and math.is_finite(event.y)
drag_copy_now = event.modifiers.alt
return self.dispatch_drag(input.EventKind.drag_moved, event.x, event.y)
.pointer_left:
self.pointer_present = false
return self.leave_drop()
.modifiers_changed:
drag_copy_now = event.modifiers.alt
if not self.pointer_present:
return result.success[unit](())
return self.dispatch_drag(input.EventKind.drag_moved, self.pointer_x, self.pointer_y)
.pointer_up:
if event.button != 0:
return result.success[unit](())
self.pointer_x = event.x
self.pointer_y = event.y
let dropped = self.dispatch_drag(input.EventKind.drop, event.x, event.y)
end_drag()
return dropped
.key_down, .focus_lost, .overflow:
if event.kind == input.EventKind.key_down and event.key != input.Key.escape:
return result.success[unit](())
let left = self.leave_drop()
end_drag()
return left
_:
return result.success[unit](())
## The drag inside the window at the pointer: its image (the lead item's picture,
## at most 72 points), and its label, or else its count when it carries more than
## one item or has no image; a plus while it would copy.
func draw_drag_badge(target: interop.View[gpu.RenderTarget]) -> !:
if not drag_active or not self.pointer_present:
return
let font = drag_font else return
var painter = try Painter(target)
defer painter.close()
let theme = self.appearance
var x = self.pointer_x + 14.0
let y = self.pointer_y + 14.0
if let picture = drag_image:
let width = (f64)picture.value().width()
let height = (f64)picture.value().height()
let scale = 72.0 / math.max(width, height) if width > 0.0 and height > 0.0 else 0.0
if scale > 0.0:
let frame = Rect(x, y, width * math.min(scale, 1.0), height * math.min(scale, 1.0))
try painter.rounded_rectangle(Rect(frame.x - 2.0, frame.y - 2.0, frame.width + 4.0, frame.height + 4.0), theme.background, 3.0, opacity = 0.85)
try painter.image(picture, frame, opacity = 0.8)
x = frame.x + frame.width - 8.0
var text = drag_label_text
var digits: u8[24]
if text.length == 0 and (drag_items.length > 1 or drag_image == none):
text = try strings.format(digits, f"{drag_items.length}")
if drag_copy_now:
let plus = font.value().line_height()
try painter.rounded_rectangle(Rect(x - plus - 4.0, y - 6.0, plus, plus), theme.accent, plus * 0.5)
try painter.text("+", x - plus - 4.0 + (plus - try font.value().measure("+")) * 0.5, y - 6.0 + (plus - font.value().height()) * 0.5, theme.on_selection(theme.foreground), font)
if text.length == 0:
return
let height = font.value().line_height()
let width = try font.value().measure(text) + 12.0
try painter.rounded_rectangle(Rect(x, y - 6.0, width, height), theme.accent, height * 0.5)
try painter.text(text, x + 6.0, y - 6.0 + (height - font.value().height()) * 0.5, theme.on_selection(theme.foreground), font)