Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-ui

Source of release 0.19.5

0.19.5 / src / layout / tree_dispatch.lucb

#==============================================================================================
#
#   layout/tree_dispatch - Routing input: pointer, keys, menus, dialogs, hover and cursors
#
#==============================================================================================

extend Tree:
    ## Route one window event, arranging before and after. Pointer events go to
    ## the capturing box or the one hit, which a primary press focuses (when
    ## focusable) and captures until release; keys and text go to the focused box,
    ## and Tab moves focus unless the focused box keeps Tab. Secondary clicks and
    ## Shift-F10 open the nearest context menu. Focus loss cancels capture and
    ## focus. While a modal popup is open input is modal: only its subtree is hit,
    ## key and text input go to the popup's root widget, and a press outside it
    ## is swallowed after sending the popup a cancellation. A non-modal popup is
    ## only hit first.
    pub func dispatch(event: input.Event) -> interop.Outcome[unit]:
        # A move while a widget holds the pointer (a stroke, a drag) goes to it on
        # the arrangement already made: a fast pointer sends hundreds a frame, and
        # arranging the whole tree for each is what would slow the frame down.
        # A drag inside the window carries the pointer and keys until it ends; the
        # arrangement made when it began places its drop areas.
        if drag_active and event.kind != input.EventKind.scroll and event.kind != input.EventKind.magnify:
            return self.carry_drag(event)
        if not self.captured_move(event):
            let arranged = self.arrange(self.width, self.height)
            if not arranged.is_success():
                return arranged
            arranged.release()
        if event.kind == input.EventKind.pointer_left:
            self.pointer_present = false
            self.update_hover()
            return self.tell_left()
        if event.kind == input.EventKind.drag_entered or event.kind == input.EventKind.drag_moved or event.kind == input.EventKind.drag_left or event.kind == input.EventKind.drop:
            return self.dispatch_drag(event.kind, event.x, event.y)
        if event.kind == input.EventKind.pointer_moved or event.kind == input.EventKind.pointer_entered or event.kind == input.EventKind.pointer_down or event.kind == input.EventKind.pointer_up or event.kind == input.EventKind.scroll or event.kind == input.EventKind.magnify:
            self.pointer_x = event.x
            self.pointer_y = event.y
            self.pointer_present = math.is_finite(event.x) and math.is_finite(event.y)
            self.update_hover()
            let told = self.tell_left()
            if not told.is_success():
                return told
            told.release()
        if event.kind == input.EventKind.focus_lost or event.kind == input.EventKind.overflow:
            self.pointer_present = false
            self.update_hover()
            let told = self.tell_left()
            if not told.is_success():
                return told
            told.release()
            let capture_cancelled = self.cancel(self.capture)
            if not capture_cancelled.is_success():
                return capture_cancelled
            capture_cancelled.release()
            if self.focus != self.capture:
                let focus_cancelled = self.cancel(self.focus)
                if not focus_cancelled.is_success():
                    return focus_cancelled
                focus_cancelled.release()
            self.capture = 0
            self.return_focus = 0
            self.requested_focus = 0
            self.set_focus(0)
            return result.success[unit](())
        if let popup = self.popup_index():
            let box = self.entries[popup].box.value()
            # A submenu belongs to the menu it opened from: the outermost one
            # switches with the menu bar.
            let root = self.menu_root(popup)
            if event.kind == input.EventKind.pointer_moved or (event.kind == input.EventKind.pointer_down and event.button == 0):
                if let peer = self.menu_at(root, event.x, event.y):
                    if self.entries[root].parent != (i64)peer:
                        return self.switch_menu(root, peer)
            if event.kind == input.EventKind.key_down and not event.repeated and (event.key == input.Key.left or event.key == input.Key.right):
                # Left leaves a submenu, Right opens the selected row's.
                let left = event.key == input.Key.left
                if (left and not box.submenu) or (not left and not box.submenu_selected):
                    if let peer = self.next_menu(root, left):
                        return self.switch_menu(root, peer)
            if event.kind == input.EventKind.pointer_down and not inside(box.clipping, event.x, event.y):
                let cancelled = self.cancel(box.identifier)
                if not cancelled.is_success():
                    return cancelled
                cancelled.release()
                # A press outside a submenu and the menus holding it closes them all.
                var current = popup
                while self.entries[current].box.value().submenu:
                    let holder = self.holding_popup(current) else break
                    if inside(self.entries[holder].box.value().clipping, event.x, event.y):
                        break
                    let closed = self.cancel(self.entries[holder].box.value().identifier)
                    if not closed.is_success():
                        return closed
                    closed.release()
                    current = holder
                self.capture = 0
                return self.arrange(self.width, self.height)
            # Tab stays within the popup; its widget chooses how to navigate.
            if event.kind == input.EventKind.key_down or event.kind == input.EventKind.key_up or event.kind == input.EventKind.text_input or event.kind == input.EventKind.modifiers_changed:
                let delivered = self.send(popup, Event(kind = event.kind, key = event.key,
                                                       repeated = event.repeated, shift = event.modifiers.shift,
                                                       control = event.modifiers.control, alt = event.modifiers.alt, meta = event.modifiers.super,
                                                       codepoint = (i64)event.codepoint))
                if not delivered.is_success():
                    return delivered
                delivered.release()
                return self.arrange(self.width, self.height)
        let secondary = event.kind == input.EventKind.pointer_down and event.button == 1
        let keyboard_context = event.kind == input.EventKind.key_down and event.key == input.Key.f10 and event.modifiers.shift and not event.repeated
        if (secondary or keyboard_context) and not self.has_popup():
            let destination = self.hit(event.x, event.y) if secondary else self.focus
            if let target = self.find(destination):
                let box = self.entries[target].box.value()
                if secondary:
                    let cancelled = self.cancel(self.capture)
                    if not cancelled.is_success():
                        return cancelled
                    cancelled.release()
                    self.capture = 0
                    if box.accepts_focus:
                        if self.focus != destination:
                            let cancelled_focus = self.leave(self.focus)
                            if not cancelled_focus.is_success():
                                return cancelled_focus
                            cancelled_focus.release()
                        self.set_focus(destination)
                    if not box.context_menu:
                        self.secondary_holder = destination
                        let selected = self.send(target, Event(kind = event.kind, button = 1,
                                                               x = event.x - box.rectangle.x, y = event.y - box.rectangle.y, inside = true))
                        if not selected.is_success():
                            return selected
                        selected.release()
                var ancestor = (i64)target
                while ancestor >= 0:
                    let provider = self.entries[(usize)ancestor].box.value()
                    if provider.context_menu and path_enabled(self.entries, (usize)ancestor):
                        let x = event.x - provider.rectangle.x if secondary else 0.0
                        let y = event.y - provider.rectangle.y if secondary else math.min(box.rectangle.y - provider.rectangle.y + box.rectangle.height, provider.rectangle.height)
                        let opened = self.send((usize)ancestor, Event(kind = input.EventKind.pointer_down, button = 1, x = x, y = y, inside = true))
                        if not opened.is_success():
                            return opened
                        opened.release()
                        return self.arrange(self.width, self.height)
                    ancestor = self.entries[(usize)ancestor].parent
            return result.success[unit](())
        var text_tab = false
        if let focused = self.find(self.focus):
            text_tab = self.entries[focused].box.value().accepts_tab and not event.modifiers.control
        if event.kind == input.EventKind.key_down and event.key == input.Key.tab and not text_tab:
            if not event.repeated:
                let capture_cancelled = self.cancel(self.capture)
                if not capture_cancelled.is_success():
                    return capture_cancelled
                capture_cancelled.release()
                let focus_cancelled = self.leave(self.focus)
                if not focus_cancelled.is_success():
                    return focus_cancelled
                focus_cancelled.release()
                self.capture = 0
                self.advance_focus(event.modifiers.shift)
            return result.success[unit](())
        var destination: u64 = 0
        if event.kind == input.EventKind.pointer_down and event.button == 0:
            destination = self.hit(event.x, event.y)
            let capture_cancelled = self.cancel(self.capture)
            if not capture_cancelled.is_success():
                return capture_cancelled
            capture_cancelled.release()
            let selected = self.find(destination)
            # A box that keeps focus (a completion list) takes the press alone.
            var keeps = false
            if let index = selected:
                keeps = self.entries[index].box.value().keeps_focus
            if destination != self.focus and not keeps:
                let focus_cancelled = self.leave(self.focus)
                if not focus_cancelled.is_success():
                    return focus_cancelled
                focus_cancelled.release()
            self.capture = destination
            if let index = selected:
                if not keeps:
                    self.set_focus(destination if self.entries[index].box.value().accepts_focus else 0)
            else:
                self.set_focus(0)
        elif event.kind == input.EventKind.pointer_down and event.button >= 2:
            # Middle and extra buttons go to what is under the pointer and hold it for
            # the drag, as the primary button does, but leave keyboard focus alone.
            destination = self.hit(event.x, event.y)
            let held_cancelled = self.cancel(self.capture)
            if not held_cancelled.is_success():
                return held_cancelled
            held_cancelled.release()
            self.capture = destination
        elif event.kind == input.EventKind.pointer_up and (event.button == 0 or event.button >= 2):
            destination = self.capture if self.capture != 0 else self.hit(event.x, event.y)
            self.capture = 0
        elif event.kind == input.EventKind.pointer_up and event.button == 1 and self.secondary_holder != 0:
            # A right-button drag (a brush sized by it) ends where it began.
            destination = self.secondary_holder
            self.secondary_holder = 0
        elif event.kind == input.EventKind.pointer_moved:
            destination = self.capture if self.capture != 0 else self.hit(event.x, event.y)
        elif event.kind == input.EventKind.scroll or event.kind == input.EventKind.magnify:
            destination = self.scroll_target(self.hit(event.x, event.y))
        elif event.kind == input.EventKind.key_down or event.kind == input.EventKind.key_up or event.kind == input.EventKind.text_input or event.kind == input.EventKind.modifiers_changed:
            destination = self.focus
        if let index = self.find(destination):
            let box = self.entries[index].box.value()
            let translated = Event(kind = event.kind, key = event.key,
                                   x = event.x - box.rectangle.x, y = event.y - box.rectangle.y,
                                   button = (i64)event.button, repeated = event.repeated, shift = event.modifiers.shift,
                                   control = event.modifiers.control, alt = event.modifiers.alt, meta = event.modifiers.super,
                                   codepoint = (i64)event.codepoint, scroll_unit = event.scroll_unit,
                                   inside = inside(box.clipping, event.x, event.y), scroll_x = event.scroll_x, scroll_y = event.scroll_y, pressure = event.pressure,
                                   pointer_kind = event.pointer_kind, tilt_x = event.tilt_x, tilt_y = event.tilt_y, azimuth = event.azimuth,
                                   altitude = event.altitude, rotation = event.rotation, tangential = event.tangential)
            let delivered = self.send(index, translated)
            if not delivered.is_success():
                return delivered
            delivered.release()
            if drag_pending:
                return self.begin_drag(event)
        # A captured move changes no arrangement: the run loop arranges once
        # before it draws, so a fast pointer does not arrange hundreds of times.
        if self.captured_move(event):
            return result.success[unit](())
        let refreshed = self.arrange(self.width, self.height)
        if not refreshed.is_success():
            return refreshed
        refreshed.release()
        return result.success[unit](())

    ## Escape or Enter while a dialog is open goes to the topmost open one (a
    ## picker opened over another dialog takes them first), to cancel or
    ## accept; true when one took it. A focused field first drops (Escape) or keeps
    ## (Enter) what was typed. Enter stays with a multi-line editor.
    pub func dialog_key(event: input.Event) -> interop.Outcome[bool]:
        if event.kind != input.EventKind.key_down or event.repeated or (event.key != input.Key.escape and event.key != input.Key.enter):
            return result.success[bool](false)
        if event.modifiers.control or event.modifiers.alt or event.modifiers.super or event.modifiers.shift or self.has_popup():
            return result.success[bool](false)
        let focused = self.find(self.focus)
        var target: usize? = none
        var index = self.count
        while index > 0 and target == none:
            index -= 1
            let box = self.entries[index].box.value()
            if box.dialog and box.visible and path_enabled(self.entries, index):
                target = index
        let dialog = target else return result.success[bool](false)
        if let field = focused:
            let box = self.entries[field].box.value()
            if box.accepts_text:
                if event.key == input.Key.enter and box.accepts_tab:
                    return result.success[bool](false)
                # A field left by Enter keeps its text, as focus moving away would.
                let resolved = self.send(field, Event(kind = input.EventKind.focus_lost) if event.key == input.Key.enter else Event(kind = input.EventKind.key_down, key = input.Key.escape))
                defer resolved.release()
                _ = resolved.get() catch failure:
                    return result.failure[bool](failure.code, failure.message)
        let delivered = self.send(dialog, Event(kind = input.EventKind.key_down, key = event.key))
        defer delivered.release()
        _ = delivered.get() catch failure:
            return result.failure[bool](failure.code, failure.message)
        let arranged = self.arrange(self.width, self.height)
        defer arranged.release()
        _ = arranged.get() catch failure:
            return result.failure[bool](failure.code, failure.message)
        return result.success[bool](true)

    ## The open modal popup, if any; a non-modal one does not hold input.
    func popup_index() -> usize?:
        var index = self.count
        while index > 0:
            index -= 1
            let box = self.entries[index].box.value()
            if box.popup and box.modal and box.visible:
                return index
        return none

    ## The popup holding the box at `index` (above it in the tree), if any.
    func holding_popup(index: usize) -> usize?:
        var cursor = self.entries[index].parent
        while cursor >= 0:
            if self.entries[(usize)cursor].box.value().popup:
                return (usize)cursor
            cursor = self.entries[(usize)cursor].parent
        return none

    ## The outermost menu of a submenu chain: `popup` itself when it is no submenu.
    func menu_root(popup: usize) -> usize:
        var current = popup
        while self.entries[current].box.value().submenu:
            current = self.holding_popup(current) else break
        return current

    func menu_owner(popup: usize) -> usize?:
        let parent = self.entries[popup].parent
        if parent < 0 or not self.entries[(usize)parent].box.value().menu_trigger:
            return none
        return (usize)parent

    func menu_at(popup: usize, x: f64, y: f64) -> usize?:
        let owner = self.menu_owner(popup) else return none
        let group = self.entries[owner].parent
        for index in 0..<self.count:
            let box = self.entries[index].box.value()
            if self.entries[index].parent == group and box.menu_trigger and path_enabled(self.entries, index) and inside(box.clipping, x, y):
                return index
        return none

    func next_menu(popup: usize, backwards: bool) -> usize?:
        let owner = self.menu_owner(popup) else return none
        let group = self.entries[owner].parent
        var index = owner
        for visited in 0..<self.count:
            index = (self.count - 1 if index == 0 else index - 1) if backwards else (index + 1) % self.count
            let box = self.entries[index].box.value()
            if self.entries[index].parent == group and box.menu_trigger and path_enabled(self.entries, index) and box.clipping.width > 0.0 and box.clipping.height > 0.0:
                return index
        return none

    func switch_menu(popup: usize, peer: usize) -> interop.Outcome[unit]:
        let cancelled = self.cancel(self.entries[popup].box.value().identifier)
        if not cancelled.is_success():
            return cancelled
        cancelled.release()
        let capture_cancelled = self.cancel(self.capture)
        if not capture_cancelled.is_success():
            return capture_cancelled
        capture_cancelled.release()
        self.capture = 0
        self.return_focus = self.entries[peer].box.value().identifier
        let opened = self.send(peer, Event(menu_requested = true))
        if not opened.is_success():
            return opened
        opened.release()
        return self.arrange(self.width, self.height)

    ## Hover is derived from current geometry, including after layout changes
    ## beneath a stationary pointer. Updating it never remeasures the widget tree.
    func update_hover():
        for entry in self.entries[..<self.count]:
            let box = entry.box.value()
            box.hovered = false
            box.pointer_within = false
            box.pointer = Point(self.pointer_x - box.rectangle.x, self.pointer_y - box.rectangle.y)
        if not self.pointer_present:
            return
        var hovered: usize? = none
        let popup = self.popup_index()
        if let active = popup:
            if not inside(self.entries[active].box.value().clipping, self.pointer_x, self.pointer_y):
                hovered = self.menu_at(self.menu_root(active), self.pointer_x, self.pointer_y)
        if hovered == none:
            var index = self.count
            while index > 0:
                index -= 1
                let box = self.entries[index].box.value()
                if (popup == none or in_popup(self.entries, index)) and path_enabled(self.entries, index) and not box.hover_transparent and inside(box.clipping, self.pointer_x, self.pointer_y):
                    hovered = index
                    break
        let index = hovered else return
        self.entries[index].box.value().hovered = true
        var ancestor = (i64)index
        while ancestor >= 0:
            self.entries[(usize)ancestor].box.value().pointer_within = true
            ancestor = self.entries[(usize)ancestor].parent

    ## The pointer moved off the box it was over (onto another, or out of the
    ## window): that box's widget hears pointer_left, as when it leaves the
    ## window, and draws again without its hover. A widget holding the pointer
    ## (a drag) hears it too, and keeps its drag.
    func tell_left() -> interop.Outcome[unit]:
        var now: u64 = 0
        for entry in self.entries[..<self.count]:
            if entry.box.value().hovered:
                now = entry.box.value().identifier
        let before = self.hover_box
        self.hover_box = now
        if before == 0 or before == now:
            return result.success[unit](())
        let index = self.find(before) else return result.success[unit](())
        let box = self.entries[index].box.value()
        box.repaint()
        return self.send(index, Event(kind = input.EventKind.pointer_left, x = self.pointer_x - box.rectangle.x,
                                      y = self.pointer_y - box.rectangle.y, inside = false))

    ## Whether `event` is a pointer move while a widget holds the pointer.
    pub func captured_move(event: input.Event) -> bool:
        return event.kind == input.EventKind.pointer_moved and self.capture != 0 and self.count > 0

    ## Whether a visible modal popup is open, which makes input modal.
    pub func has_popup() -> bool:
        return self.popup_index() != none

    ## Whether the focused box takes text input, so the window should deliver it.
    pub func wants_text_input() -> bool:
        let index = self.find(self.focus) else return false
        return self.entries[index].box.value().accepts_text

    ## The cursor for the capturing box, or else the box under the pointer: its
    ## cursor source's choice or its fixed cursor. The arrow when the pointer is
    ## away, over nothing, or over a disabled box.
    pub func cursor() -> input.Cursor!:
        if not self.pointer_present and self.capture == 0: return input.Cursor.arrow
        var target = self.capture
        if target == 0:
            if let popup = self.popup_index():
                if let menu = self.menu_at(self.menu_root(popup), self.pointer_x, self.pointer_y):
                    target = self.entries[menu].box.value().identifier
            if target == 0: target = self.hit(self.pointer_x, self.pointer_y)
        let index = self.find(target) else return input.Cursor.arrow
        if not path_enabled(self.entries, index): return input.Cursor.arrow
        let box = self.entries[index].box.value()
        if let source = box.cursor_source:
            try source.enter()
            defer source.leave()
            let started = layout_epoch()
            let cursor = source.value().cursor(Point(self.pointer_x - box.rectangle.x, self.pointer_y - box.rectangle.y), self.capture == target)
            if layout_epoch() != started: error(result.busy, "a cursor query changed the widget tree")
            return cursor
        return box.pointer_cursor

    ## The box a press at a point reaches: popups first, as they draw on top;
    ## while a modal one is open, nothing else.
    func hit(x: f64, y: f64) -> u64:
        let modal = self.has_popup()
        # Popups first, the innermost (a dropdown's list inside a dialog) above
        # the popup it opens from, whatever their order in the tree.
        var best: u64 = 0
        var best_depth: usize = 0
        var index = self.count
        while index > 0:
            index -= 1
            let depth = popup_depth(self.entries, index)
            if depth <= best_depth:
                continue
            let box = self.entries[index].box.value()
            if path_enabled(self.entries, index) and box.accepts_pointer and inside(box.clipping, x, y):
                best = box.identifier
                best_depth = depth
        if best != 0 or modal:
            return best
        index = self.count
        while index > 0:
            index -= 1
            let box = self.entries[index].box.value()
            if not in_popup(self.entries, index) and path_enabled(self.entries, index) and box.accepts_pointer and inside(box.clipping, x, y):
                return box.identifier
        return 0

    ## Where a scroll over box `hit` goes: the nearest box at or above it that
    ## takes scroll, or `hit` itself when none does.
    func scroll_target(hit: u64) -> u64:
        let found = self.find(hit) else return hit
        var at = (i64)found
        while at >= 0:
            let box = self.entries[(usize)at].box.value()
            if box.takes_scroll():
                return (u64)box.id()
            at = self.entries[(usize)at].parent
        return hit