Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-ui

Source of release 0.19.5

0.19.5 / 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()

    ## 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()