Luce packages
LuceLuce BaseLuciaOS

dymokomi/luced-3d

Source of release 0.11.2

0.11.2 / src / network_view.luc

from luce_ui.ui import Widget, Layout, Constraints, Size, Event, Painter, Point, Font
from luce_gpu.gpu import RenderTarget, Rect
from luce_window.input import EventKind, Key, ScrollUnit
from network import Node
from workspace import Workspace
from actions import Actions
from luce_std import math
import theme
import time
from tool_icons import draw_icon
from edit_kinds import is_edit
import node_commands
import shader_nodes
from luce_ui import ui
from material_preview import MaterialPreview
import node_catalog

pub let node_width: float = 96.0
pub let node_height: float = 40.0
## Inside a Material, shader nodes: a header, then a row a socket (outputs on
## the right, then inputs on the left), wired left to right.
let shader_width: float = 176.0
let shader_header: float = 24.0
let shader_row: float = 19.0

pub class NetworkView: Widget:
    let box: Layout
    let workspace: Workspace
    let actions: Actions
    let base_font: Font
    var font: Font
    pub var zoom: float = 1.0
    pub var pan_x: float = 0.0
    pub var pan_y: float = 0.0
    pub var pointer_x: float = 100.0
    pub var pointer_y: float = 70.0
    pub var on_search: func() -> unit!? = none
    pub var on_inspect: func(int) -> unit!? = none
    var mode: str = ""
    var moving: int = -1
    var wire_node: int = -1
    var wire_port: int = -1
    var from_output: bool = true
    var start_x: float = 0.0
    var start_y: float = 0.0
    var last_x: float = 0.0
    var last_y: float = 0.0
    var node_x: float = 0.0
    var node_y: float = 0.0
    var space: bool = false
    var hovered: int = -1
    var last_click: int = 0
    var last_node: int = -1
    ## Frame the nodes at the next draw (a new scope shows them whole).
    var frame_pending: bool = false
    ## A move drags every picked node: their ids and where each started.
    var moving_ids: list[int]
    var moving_from: list[Point]
    ## The Material's look, while its shader nodes are shown (made at first use).
    var preview: MaterialPreview? = none

    pub func reset_scope(self) -> unit!:
        self.mode = ""
        self.hovered = -1
        self.pan_x = 20.0
        self.pan_y = 20.0
        self.zoom = 1.0
        self.last_node = -1
        self.frame_pending = true
        self.box.invalidate()

    pub func init(self, workspace: Workspace, actions: Actions, font: Font) -> unit!:
        self.workspace = workspace
        self.actions = actions
        self.base_font = font
        self.font = font
        self.moving_ids = []
        self.moving_from = []
        self.box = Layout()
        self.box.set_flex()
        self.box.set_interactive(true)
        self.box.set_focusable(true)
        self.box.set_accepts_tab(true)

    pub func layout(self) -> Layout:
        return self.box
    pub func measure(self, available: Constraints) -> Size!:
        return Size(460.0, 220.0)
    pub func to_graph(self, x: float, y: float) -> Point:
        return Point((x - self.pan_x) / self.zoom, (y - self.pan_y) / self.zoom)
    pub func to_screen(self, x: float, y: float) -> Point:
        return Point(x * self.zoom + self.pan_x, y * self.zoom + self.pan_y)
    ## Whether the network shown is a Material's shader nodes.
    func shading(self) -> bool:
        return self.workspace.network.in_material()

    ## A node's box in graph units.
    func size_of(self, node: Node) -> Size:
        if not self.shading():
            return Size(node_width, node_height)
        let rows = shader_nodes.outputs(node.kind).length + shader_nodes.inputs(node.kind).length
        return Size(shader_width, shader_header + shader_row * float(rows) + 6.0)

    pub func port_point(self, node: Node, output: bool, port: int = 0) -> Point:
        if self.shading():
            let outputs = shader_nodes.outputs(node.kind).length
            let row = float(port) if output else float(outputs + port)
            return self.to_screen(node.x + (shader_width if output else 0.0), node.y + shader_header + shader_row * (row + 0.5))
        return self.to_screen(node.x + (node_width * 0.5 if output else node_width * float(port + 1) / float(node.inputs.length + 1)), node.y + (node_height if output else 0.0))

    func inside_node(self, node: Node, at: Point) -> bool:
        let size = self.size_of(node)
        return at.x >= node.x and at.x <= node.x + size.width and at.y >= node.y and at.y <= node.y + size.height

    pub func zoom_about(self, factor: float, x: float, y: float):
        let before = self.to_graph(x, y)
        self.zoom = math.max(0.3, math.min(2.5, self.zoom * factor))
        self.pan_x = x - before.x * self.zoom
        self.pan_y = y - before.y * self.zoom
        self.box.invalidate()

    pub func frame_all(self) -> unit!:
        let nodes = self.workspace.network.local_nodes()
        if nodes.length == 0:
            return
        # Geometry nodes' captions run to their right.
        let caption = 0.0 if self.shading() else 170.0
        var left = nodes[0].x
        var top = nodes[0].y
        var right = left + self.size_of(nodes[0]).width + caption
        var bottom = top + self.size_of(nodes[0]).height
        for node in nodes:
            let box = self.size_of(node)
            left = math.min(left, node.x)
            top = math.min(top, node.y)
            right = math.max(right, node.x + box.width + caption)
            bottom = math.max(bottom, node.y + box.height)
        let bounds = self.box.bounds()
        self.zoom = math.max(0.3, math.min(1.4, math.min((bounds.width - 80.0) / (right - left), (bounds.height - 70.0) / (bottom - top))))
        self.pan_x = (bounds.width - (right - left) * self.zoom) * 0.5 - left * self.zoom
        self.pan_y = (bounds.height - (bottom - top) * self.zoom) * 0.5 - top * self.zoom
        self.box.invalidate()

    pub func draw(self, target: RenderTarget) -> unit!:
        if self.frame_pending and self.box.bounds().width > 0.0:
            self.frame_pending = false
            self.frame_all()
        let size = target.size()
        let p = Painter(target)
        p.rectangle(Rect(0.0, 0.0, size.width, size.height), theme.backdrop())
        let step = 32.0 * self.zoom
        var x = self.pan_x - math.floor(self.pan_x / step) * step
        while x < size.width:
            var y = self.pan_y - math.floor(self.pan_y / step) * step
            while y < size.height:
                p.rectangle(Rect(x, y, 1.0, 1.0), theme.border())
                y += step
            x += step
        let wanted = float(int(math.max(8.0, self.base_font.size() * self.zoom)))
        if wanted != self.font.size():
            self.font = self.base_font if wanted == self.base_font.size() else Font(wanted)
        let graph = self.workspace.network
        let exposed: list[int] = []
        for node in graph.outputs(graph.scope):
            exposed.append(node.id)
        for node in graph.local_nodes():
            for port in 0..<node.inputs.length:
                if let source = graph.find(node.inputs[port]):
                    self.wire(p, self.port_point(source, true, node.sources[port]), self.port_point(node, false, port))
        let shading = self.shading()
        let picked = graph.selection()
        for node in graph.local_nodes():
            if shading:
                self.draw_shader_node(p, node, node.id in picked, size.width, size.height)
                continue
            let at = self.to_screen(node.x, node.y)
            let w = node_width * self.zoom
            let h = node_height * self.zoom
            if at.x + w + 170.0 * self.zoom < 0.0 or at.x > size.width or at.y + h < 0.0 or at.y > size.height:
                continue
            let selected = node.id in picked
            let radius = 10.0 * self.zoom if node.kind in ["Cube", "Grid", "Sphere", "Cylinder", "Cone", "Torus"] else 3.0 * self.zoom
            p.rounded_rectangle(Rect(at.x - 1.5, at.y - 1.5, w + 3.0, h + 3.0), theme.accent() if selected else (theme.text_muted() if self.hovered == node.id else theme.grey(78.0)), radius + 1.0)
            p.rounded_rectangle(Rect(at.x, at.y, w, h), theme.frozen() if node.frozen != "" else (theme.grey(64.0) if node.enabled else theme.tab_strip()), radius)
            if node.computing:
                p.rectangle(Rect(at.x, at.y + h - 3.0, w * math.max(0.02, math.min(1.0, node.progress)), 3.0), theme.accent())
            draw_icon(p, node.kind, at.x + 36.0 * self.zoom, at.y + 8.0 * self.zoom, 24.0 * self.zoom, theme.text() if node.enabled else theme.text_muted())
            let caption = node.name[0..<24] + "…" if node.name.length > 24 else node.name
            p.text(caption, at.x + 109.0 * self.zoom, at.y + (1.0 if self.zoom >= 0.65 else 10.0) * self.zoom, theme.text() if node.enabled else theme.text_muted(), self.font)
            let detail = (f"{node.phase} {int(node.progress * 100.0)}%" if node.progress > 0.0 else node.phase) if node.computing else ("ERROR" if node.failure != "" else ("WARNING" if node.warning != "" else ("bypassed" if not node.enabled else ("frozen" if node.frozen != "" else (f"{node.edits.length} edits" if is_edit(node.kind) else "geometry")))))
            if self.zoom >= 0.65:
                let shown = node.computing or node.failure != "" or node.warning != "" or not node.enabled or is_edit(node.kind)
                let ink = theme.accent() if node.failure != "" or node.computing else (theme.warning() if node.warning != "" else theme.text_muted())
                p.text(detail if shown else node.kind, at.x + 109.0 * self.zoom, at.y + 22.0 * self.zoom, ink, self.font)
            # Two distinct flags, with matching commands in the inspector.
            p.rectangle(Rect(at.x + 84.0 * self.zoom, at.y + 5.0 * self.zoom, 9.0 * self.zoom, 30.0 * self.zoom), theme.accent() if node.id in exposed else theme.border())
            p.rectangle(Rect(at.x + 3.0 * self.zoom, at.y + 5.0 * self.zoom, 9.0 * self.zoom, 30.0 * self.zoom), theme.accent() if not node.enabled else theme.border())
            if not node.enabled:
                p.line(Point(at.x + 18.0 * self.zoom, at.y + 31.0 * self.zoom), Point(at.x + 78.0 * self.zoom, at.y + 9.0 * self.zoom), 1.0, theme.text_muted())
            for port in 0..<node.inputs.length:
                self.draw_port(p, self.port_point(node, false, port), node.inputs[port] >= 0)
            self.draw_port(p, self.port_point(node, true), true)
        if self.mode == "box":
            let left = math.min(self.start_x, self.last_x)
            let top = math.min(self.start_y, self.last_y)
            let width = math.abs(self.last_x - self.start_x)
            let height = math.abs(self.last_y - self.start_y)
            for edge in [Rect(left, top, width, 1.0), Rect(left, top + height - 1.0, width, 1.0), Rect(left, top, 1.0, height), Rect(left + width - 1.0, top, 1.0, height)]:
                p.rectangle(edge, theme.accent())
        if self.mode == "wire":
            if let node = graph.find(self.wire_node):
                let port = self.port_point(node, self.from_output, self.wire_port)
                let pointer = Point(self.pointer_x, self.pointer_y)
                self.wire(p, port if self.from_output else pointer, pointer if self.from_output else port)
        if self.hovered >= 0 and self.mode == "" and not shading:
            if let node = graph.find(self.hovered):
                let at = self.to_graph(self.pointer_x, self.pointer_y)
                let hint = "Bypass (B), Freeze (Shift+B)" if at.x < node.x + 15.0 else ("Out (O)" if at.x > node.x + 81.0 else node.kind + " / geometry")
                p.text(hint, 12.0, size.height - 24.0, theme.text_muted())
                # Fixed screen-size hover controls keep flags usable zoomed out.
                for flag in 0..<4:
                    let (flag_x, flag_y) = self.flag_at(node, flag)
                    p.rounded_rectangle(Rect(flag_x, flag_y, 20.0, 20.0), theme.frozen() if flag == 3 and node.frozen != "" else theme.surface(), 4.0)
                    p.text(["B", "O", "i", "F"][flag], flag_x + 5.0, flag_y + 2.0, theme.accent() if (flag == 0 and not node.enabled) or (flag == 1 and node.id in exposed) else theme.text())
        if shading:
            let side = math.min(230.0, math.min(size.width, size.height) * 0.4)
            p.rectangle(Rect(size.width - side - 13.0, size.height - side - 13.0, side + 2.0, side + 2.0), theme.border())
        p.close()
        if shading:
            # A preview that cannot render says why in its place, not stopping the app.
            self.draw_preview(target, size.width, size.height) catch failure:
                let side = math.min(230.0, math.min(size.width, size.height) * 0.4)
                let note = Painter(target)
                note.text(failure.message, size.width - side - 12.0, size.height - side - 32.0, theme.warning())
                note.close()

    ## The Material's render in the bottom-right corner, restarted when its
    ## nodes change (at twice the size, for sharp high-density screens);
    ## redrawn while passes come.
    func draw_preview(self, target: RenderTarget, width: float, height: float) -> unit!:
        let side = math.min(230.0, math.min(width, height) * 0.4)
        if self.preview == none:
            self.preview = MaterialPreview()
        let preview = self.preview else return
        let graph = self.workspace.network
        preview.update(graph, graph.require(graph.scope), int(side * 2.0))
        if preview.draw(target, width - side - 12.0, height - side - 12.0, side):
            self.box.invalidate()
        let problem = preview.problem()
        if problem != "":
            error(ui.invalid, problem)

    ## A shader node: its name over its outputs (right) and inputs (left),
    ## each a labeled socket.
    func draw_shader_node(self, p: Painter, node: Node, selected: bool, view_width: float, view_height: float) -> unit!:
        let at = self.to_screen(node.x, node.y)
        let box = self.size_of(node)
        let w = box.width * self.zoom
        let h = box.height * self.zoom
        if at.x + w < 0.0 or at.x > view_width or at.y + h < 0.0 or at.y > view_height:
            return
        let radius = 4.0 * self.zoom
        p.rounded_rectangle(Rect(at.x - 1.5, at.y - 1.5, w + 3.0, h + 3.0), theme.accent() if selected else (theme.text_muted() if self.hovered == node.id else theme.grey(78.0)), radius + 1.0)
        p.rounded_rectangle(Rect(at.x, at.y, w, h), theme.grey(64.0) if node.enabled else theme.tab_strip(), radius)
        p.rectangle(Rect(at.x, at.y + shader_header * self.zoom - 1.0, w, 1.0), theme.grey(78.0))
        let ink = theme.text() if node.enabled else theme.text_muted()
        p.text(node.name, at.x + 8.0 * self.zoom, at.y + 4.0 * self.zoom, ink, self.font)
        let outputs = shader_nodes.outputs(node.kind)
        for port in 0..<outputs.length:
            let point = self.port_point(node, true, port)
            let label = outputs[port].label
            p.text(label, point.x - (10.0 + 7.0 * float(label.length)) * self.zoom, point.y - 8.0 * self.zoom, theme.text_muted(), self.font)
            self.draw_socket(p, point, outputs[port].width, true)
        let inputs = shader_nodes.inputs(node.kind)
        for port in 0..<inputs.length:
            let point = self.port_point(node, false, port)
            p.text(inputs[port].label, point.x + 10.0 * self.zoom, point.y - 8.0 * self.zoom, ink if node.inputs[port] >= 0 else theme.text_muted(), self.font)
            self.draw_socket(p, point, inputs[port].width, node.inputs[port] >= 0)

    ## A socket: grey for a value, accent for a color or vector.
    ## Hover flag `flag`'s top left on screen, a fixed size whatever the
    ## zoom: Bypass left, Out right, info above, Freeze below.
    func flag_at(self, node: Node, flag: int) -> (float, float):
        let screen = self.to_screen(node.x, node.y)
        if flag == 0:
            return (screen.x - 26.0, screen.y + node_height * self.zoom * 0.5 - 10.0)
        if flag == 1:
            return (screen.x + node_width * self.zoom + 6.0, screen.y + node_height * self.zoom * 0.5 - 10.0)
        let middle = screen.x + node_width * self.zoom * 0.5 - 10.0
        return (middle, screen.y - 27.0) if flag == 2 else (middle, screen.y + node_height * self.zoom + 7.0)

    func draw_socket(self, p: Painter, at: Point, width: int, filled: bool) -> unit!:
        let r = math.max(3.0, 4.5 * self.zoom)
        p.rounded_rectangle(Rect(at.x - r, at.y - r, 2.0 * r, 2.0 * r), theme.accent() if width == 3 else theme.grey(170.0), r)
        if not filled:
            p.rounded_rectangle(Rect(at.x - r * 0.45, at.y - r * 0.45, r * 0.9, r * 0.9), theme.grey(64.0), r * 0.45)

    func draw_port(self, p: Painter, at: Point, connected: bool) -> unit!:
        let width = math.max(8.0, 14.0 * self.zoom)
        let height = math.max(3.0, 4.0 * self.zoom)
        p.rounded_rectangle(Rect(at.x - width * 0.5, at.y - height * 0.5, width, height), theme.text() if connected else theme.grey(90.0), 1.5)

    func wire(self, p: Painter, a: Point, b: Point) -> unit!:
        # Downward between geometry nodes, rightward between shader nodes.
        let across = self.shading()
        let reach = math.max(35.0, math.abs(b.x - a.x if across else b.y - a.y) * 0.5)
        let ax = a.x + reach if across else a.x
        let ay = a.y if across else a.y + reach
        let bx = b.x - reach if across else b.x
        let by = b.y if across else b.y - reach
        var previous = a
        for step in 1..<21:
            let t = float(step) / 20.0
            let u = 1.0 - t
            let point = Point(u * u * u * a.x + 3.0 * u * u * t * ax + 3.0 * u * t * t * bx + t * t * t * b.x,
                u * u * u * a.y + 3.0 * u * u * t * ay + 3.0 * u * t * t * by + t * t * t * b.y)
            p.line(previous, point, math.max(1.0, 1.5 * self.zoom), theme.grey(150.0))
            previous = point

    ## [node ID, port index, output flag]. Port hit radius stays usable zoomed out.
    pub func hit_port(self, x: float, y: float) -> list[int]:
        for node in self.workspace.network.local_nodes().reversed():
            let outputs = shader_nodes.outputs(node.kind).length if self.shading() else 1
            for port in 0..<outputs:
                let output = self.port_point(node, true, port)
                if math.abs(output.x - x) <= 10.0 and math.abs(output.y - y) <= 10.0:
                    return [node.id, port, 1]
            for port in 0..<node.inputs.length:
                let input = self.port_point(node, false, port)
                if math.abs(input.x - x) <= 10.0 and math.abs(input.y - y) <= 10.0:
                    return [node.id, port, 0]
        return []

    pub func event(self, event: Event) -> unit!:
        self.pointer_x = event.x if event.kind == EventKind.pointer_moved or event.kind == EventKind.pointer_down else self.pointer_x
        self.pointer_y = event.y if event.kind == EventKind.pointer_moved or event.kind == EventKind.pointer_down else self.pointer_y
        if event.cancelled or event.kind == EventKind.focus_lost or event.kind == EventKind.overflow:
            if self.mode == "move":
                self.workspace.cancel()
            self.mode = ""
            self.space = false
        elif event.kind == EventKind.key_down:
            if event.key == Key.space:
                self.space = true
            elif event.key == Key.tab:
                if let search = self.on_search:
                    search()
            elif event.key == Key.delete or event.key == Key.backspace:
                self.actions.delete.trigger()
            elif event.key == Key.home:
                self.frame_all()
            elif event.key == Key.enter:
                if self.workspace.selected() != none:
                    node_commands.enter_group(self.workspace, self.workspace.network.selected)
            elif event.key == Key.escape:
                if self.mode == "move":
                    self.workspace.cancel()
                self.mode = ""
        elif event.kind == EventKind.key_up and event.key == Key.space:
            self.space = false
        elif event.kind == EventKind.magnify:
            self.zoom_about(math.max(0.1, 1.0 + event.scroll_y), event.x, event.y)
        elif event.kind == EventKind.scroll:
            if event.scroll_unit == ScrollUnit.points and not event.control and not event.meta:
                self.pan_x += event.scroll_x
                self.pan_y += event.scroll_y
            else:
                self.zoom_about(math.exp(event.scroll_y * (0.01 if event.scroll_unit == ScrollUnit.points else 0.12)), event.x, event.y)
        elif event.kind == EventKind.pointer_down and event.inside:
            if event.button == 1:
                self.mode = ""
                if let search = self.on_search:
                    search()
                return
            if event.button == 0 and self.mode == "" and self.hovered >= 0:
                if let node = self.workspace.network.find(self.hovered):
                    for flag in 0..<4:
                        let (x, y) = self.flag_at(node, flag)
                        if event.x >= x and event.x <= x + 20.0 and event.y >= y and event.y <= y + 20.0:
                            node_commands.select_node(self.workspace, node.id)
                            if flag == 0:
                                self.actions.enabled.trigger()
                            elif flag == 1:
                                self.actions.output.trigger()
                            elif flag == 3:
                                self.actions.freeze.trigger()
                            elif let inspect = self.on_inspect:
                                inspect(node.id)
                            self.box.invalidate()
                            return
            self.last_x = event.x
            self.last_y = event.y
            self.start_x = event.x
            self.start_y = event.y
            if event.button == 2 or self.space:
                self.mode = "pan"
            elif self.mode == "wire":
                let port = self.hit_port(event.x, event.y)
                self.finish_wire(port)
                self.mode = ""
            else:
                let port = self.hit_port(event.x, event.y)
                if port.length > 0:
                    if event.alt and port[2] == 0:
                        node_commands.disconnect(self.workspace, port[0], port[1])
                    else:
                        self.mode = "wire"
                        self.wire_node = port[0]
                        self.wire_port = port[1]
                        self.from_output = port[2] == 1
                else:
                    let at = self.to_graph(event.x, event.y)
                    # Empty canvas: a box picks the nodes it touches.
                    self.mode = "box"
                    for node in self.workspace.network.local_nodes().reversed():
                        if self.inside_node(node, at):
                            # Shift adds or removes a node; a picked node
                            # keeps the others picked, to move them together.
                            if event.shift:
                                node_commands.pick_node(self.workspace, node.id, true)
                                self.mode = ""
                                break
                            let together = self.workspace.network.selection()
                            if node.id in together:
                                self.workspace.network.selected = node.id
                                self.workspace.revision += 1
                            else:
                                node_commands.select_node(self.workspace, node.id)
                            if self.shading():
                                self.start_move(node)
                            elif at.x <= node.x + 15.0:
                                self.actions.enabled.trigger()
                                self.mode = ""
                            elif at.x >= node.x + 81.0:
                                self.actions.output.trigger()
                                self.mode = ""
                            else:
                                let now = time.now()
                                if node_catalog.holds_nodes(node.kind) and self.last_node == node.id and now - self.last_click < 400000000:
                                    self.mode = ""
                                    self.last_node = -1
                                    node_commands.enter_group(self.workspace, node.id)
                                    return
                                self.last_node = node.id
                                self.last_click = now
                                self.start_move(node)
                            break
        elif event.kind == EventKind.pointer_moved:
            var retained = -1
            if let node = self.workspace.network.find(self.hovered):
                let screen = self.to_screen(node.x, node.y)
                if event.inside and event.x >= screen.x - 30.0 and event.x <= screen.x + node_width * self.zoom + 30.0 and event.y >= screen.y - 30.0 and event.y <= screen.y + node_height * self.zoom + 12.0:
                    retained = node.id
            self.hovered = retained
            if event.inside:
                let at = self.to_graph(event.x, event.y)
                for node in self.workspace.network.local_nodes().reversed():
                    if self.inside_node(node, at):
                        self.hovered = node.id
                        break
            if self.mode == "pan":
                self.pan_x += event.x - self.last_x
                self.pan_y += event.y - self.last_y
            elif self.mode == "move" and (event.x != self.start_x or event.y != self.start_y):
                for k in 0..<self.moving_ids.length:
                    let origin = self.moving_from[k]
                    node_commands.move_node(self.workspace, self.moving_ids[k], origin.x + (event.x - self.start_x) / self.zoom, origin.y + (event.y - self.start_y) / self.zoom)
            self.last_x = event.x
            self.last_y = event.y
        elif event.kind == EventKind.pointer_up:
            if self.mode == "move":
                self.workspace.commit()
            elif self.mode == "box":
                self.finish_box(event.shift)
            elif self.mode == "wire":
                let port = self.hit_port(event.x, event.y)
                # A click starts a persistent wire; a drag connects on release.
                if port.length > 0 and port[0] == self.wire_node and (port[2] == 1) == self.from_output:
                    self.box.invalidate()
                    return
                self.finish_wire(port)
            self.mode = ""
        elif event.kind == EventKind.pointer_left:
            self.hovered = -1
        self.box.invalidate()

    ## Begin dragging `node` and the nodes picked with it.
    func start_move(self, node: Node) -> unit!:
        self.mode = "move"
        self.moving = node.id
        self.moving_ids = self.workspace.network.selection()
        if not (node.id in self.moving_ids):
            self.moving_ids = [node.id]
        self.moving_from = []
        for id in self.moving_ids:
            let picked = self.workspace.network.require(id)
            self.moving_from.append(Point(picked.x, picked.y))
        self.workspace.begin("Move node")

    ## Pick the nodes the box touches (added to the picked with Shift); a
    ## click on empty canvas leaves the selected node alone picked.
    func finish_box(self, add: bool) -> unit!:
        let a = self.to_graph(math.min(self.start_x, self.last_x), math.min(self.start_y, self.last_y))
        let b = self.to_graph(math.max(self.start_x, self.last_x), math.max(self.start_y, self.last_y))
        let inside: list[int] = []
        for node in self.workspace.network.local_nodes():
            let size = self.size_of(node)
            if node.x <= b.x and node.x + size.width >= a.x and node.y <= b.y and node.y + size.height >= a.y:
                inside.append(node.id)
        let dragged = math.abs(self.last_x - self.start_x) > 3.0 or math.abs(self.last_y - self.start_y) > 3.0
        if dragged and inside.length > 0:
            node_commands.pick_nodes(self.workspace, inside, add)
        elif not add:
            self.workspace.network.picked = [self.workspace.network.selected]
            self.workspace.revision += 1

    func finish_wire(self, port: list[int]) -> unit!:
        if port.length > 0 and (port[2] == 1) != self.from_output:
            if self.from_output:
                node_commands.connect(self.workspace, self.wire_node, port[0], port[1], self.wire_port)
            else:
                node_commands.connect(self.workspace, port[0], self.wire_node, self.wire_port, port[1])