logigate/app/components/editor/Canvas.vue

1600 lines
65 KiB
Vue
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

<script setup lang="ts">
import { cableKeys, INVERTIBLE } from '~/lib/logic/compile'
import { CHECKED_INPUTS } from '~/lib/logic/check'
import { cableBits, GRID as G, pinKindOf, pinPos, routeWire, type Pt, type Shape } from '~/lib/logic/geometry'
import type { CircuitNode, PanelRow, PinRef, Wire } from '~/lib/logic/types'
import { branchCorners, branchTo, endGrip, moveCorner, moveSegment, nearEnd, routeTouchesBox, segmentAt, segmentDrag, splitDrag } from '~/lib/logic/wires'
import { circuitRoutes, findCrossings } from '~/lib/logic/routing'
import { seriesLinks, type Link } from '~/lib/logic/bulk'
import { dropLinks, dropPins, fitStart, type DropPin } from '~/lib/logic/fit'
import type { CanvasOps, MenuEntry } from '~/composables/useMenu'
import { LANE, plugLayout, ribbon, RIBBON_MAX } from '~/lib/logic/cables'
import { wirePath } from '~/lib/draw'
import { downloadSheet, printSheet, sheetSvg } from '~/lib/sheet'
import { inputCount } from '~/lib/logic/wide'
import { pinName } from '~/lib/logic/labels'
const ed = useEditor()
const root = ref<HTMLDivElement>()
const size = reactive({ w: 800, h: 600 })
const def = ed.def
const view = computed(() => ed.views[def.value.id] ?? { x: 40, y: 40, zoom: 1 })
const nodeMap = computed(() => new Map(def.value.nodes.map(n => [n.id, n])))
const shapes = computed(() => new Map<string, Shape>(def.value.nodes.map(n => [n.id, ed.shape(n)])))
const selected = computed(() => new Set(ed.selection.value))
const wireSelected = computed(() => new Set(ed.wireSel.value))
// ── Wires ───────────────────────────────────────────────────────────
interface Route {
wire: Wire
/** Whole-grid route, used for dragging, handles and hit areas. */
pts: Pt[]
/** Route as drawn: on its own lane where it would share a line with another signal. */
draw: Pt[]
d: string
src: string
/** Wires in it when this is a cable (it leaves a bundle). */
bits?: number
/** Where the cable's width mark goes. */
mark?: Pt
/** A cable drawn as a ribbon: one line per wire, coloured like that wire. */
lanes?: { i: number; d: string; color?: string }[]
/** Width of the cable's sleeve in pixels. */
sleeve?: number
/** What its pins plug into: '' a wire, 'bus' a cable, 'c:<id>' a connector port. */
kind: string
/** A cable between connector ports: its type's name and colour. */
port?: { name: string; color?: string }
}
/** The middle of a route's longest straight run, where a cable's label goes. */
function midOfLongest(draw: Pt[]): Pt | undefined {
let best = 0
let at: Pt | undefined
for (let i = 0; i < draw.length - 1; i++) {
const [ax, ay] = draw[i]!
const [bx, by] = draw[i + 1]!
const len = Math.abs(bx - ax) + Math.abs(by - ay)
if (len > best) {
best = len
at = [(ax + bx) / 2, (ay + by) / 2]
}
}
return at
}
const toPath = (pts: Pt[]) => pts.map(([x, y], i) => `${i ? 'L' : 'M'}${x * G} ${y * G}`).join('')
const routes = computed<Route[]>(() => {
const routed = circuitRoutes(def.value, shapes.value, { tidy: !!ed.project.value.settings.tidy })
const hops = new Map<number, Map<number, number[]>>()
for (const c of findCrossings(routed)) {
const segs = hops.get(c.wire) ?? hops.set(c.wire, new Map()).get(c.wire)!
segs.set(c.seg, [...(segs.get(c.seg) ?? []), c.x])
}
const style = ed.project.value.settings.crossing ?? 'bow'
const byId = new Map(def.value.wires.map(w => [w.id, w]))
return routed.map((r, k) => {
const wire = byId.get(r.id)!
const from = nodeMap.value.get(wire.from.node)
const pin = from && shapes.value.get(from.id)?.outputs.find(p => p.key === wire.from.pin)
const route: Route = { wire, pts: r.grid, draw: r.draw, d: wirePath(r.draw, hops.get(k), style), src: r.net, kind: pin ? pinKindOf(pin) : '' }
if (pin?.conn) {
// A cable between connector ports: a sleeve in its type's colour, named.
const type = ed.getDef.value.conn?.(pin.conn)
route.port = { name: type?.name ?? '?', color: type?.color }
route.d = toPath(r.draw)
route.sleeve = Math.min(8, Math.max(2, type?.lines.length ?? 2)) * LANE * G + 3
route.mark = midOfLongest(r.draw)
}
if (from?.kind === 'bundle') {
route.bits = cableBits(from)
if (route.bits <= RIBBON_MAX) {
// Each wire keeps the colour of the wire that runs into the bundle.
const feed = new Map(def.value.wires.filter(w => w.to.node === from.id).map(w => [w.to.pin, w.color]))
route.d = toPath(r.draw)
route.lanes = ribbon(r.draw, route.bits).map((lane, i) => ({ i, d: toPath(lane), color: feed.get(`b${i}`) }))
route.sleeve = route.bits * LANE * G + 3
}
// The width mark sits on the middle of the longest straight run.
route.mark = midOfLongest(r.draw)
}
return route
})
})
const routeOf = (wire: Wire) => routes.value.find(r => r.wire === wire)
/** The number a cable carries right now: wire 0 is the lowest bit. */
function cableValue(r: Route): { dec: string; tip: string } | null {
if (!r.bits) return null
const from = r.wire.from.node
const bits = Array.from({ length: r.bits }, (_, i) => ed.val(from, `b${i}`) === 1)
const n = bits.reduce((v, on, i) => v + (on ? 2 ** i : 0), 0)
const hex = `0x${n.toString(16).toUpperCase().padStart(Math.ceil(r.bits / 4), '0')}`
const bin = bits.map(b => (b ? '1' : '0')).reverse().join('')
return { dec: r.bits > 4 ? `${n} · ${hex}` : String(n), tip: `${r.bits} wires: ${bin} = ${n} = ${hex} (wire 0 is the lowest bit)` }
}
/** What a wire carries, for its tooltip: where it comes from, where it goes, and its value. */
function wireTip(r: Route): string {
const v = cableValue(r)
if (v) return v.tip
const name = (ref: PinRef) => {
const n = nodeMap.value.get(ref.node)
if (!n) return '?'
const pin = pinName(n, ref.pin, ed.getDef.value)
const part = n.label?.trim() || (n.kind === 'chip' ? (n.chip && ed.getDef.value(n.chip)?.name) || 'Component' : n.kind.toUpperCase())
return pin ? `${part} ${pin}` : part
}
if (r.port) {
const type = r.kind.startsWith('c:') ? ed.getDef.value.conn?.(r.kind.slice(2)) : undefined
const lines = (type?.lines ?? []).map(l => (l.back ? `${l.name} (back)` : l.name)).join(', ')
return `${name(r.wire.from)} → ${name(r.wire.to)}: ${r.port.name} cable${lines ? ` with ${lines}` : ''}`
}
return `${name(r.wire.from)} → ${name(r.wire.to)}: ${srcVal(r.src)}`
}
/** Dots where a net branches, so crossings without a dot read as "not connected". */
const junctions = computed(() => {
const groups = new Map<string, Pt[][]>()
const colors = new Map<string, string>()
for (const r of routes.value) {
const g = groups.get(r.src)
if (g) g.push(r.draw)
else groups.set(r.src, [r.draw])
if (r.wire.color && !colors.has(r.src)) colors.set(r.src, r.wire.color)
}
const dots: { x: number; y: number; src: string; color: string }[] = []
for (const [src, list] of groups) {
if (list.length < 2) continue
const candidates = new Map<string, Pt>()
for (const r of list) for (let i = 0; i < r.length - 1; i++) candidates.set(`${r[i]![0]},${r[i]![1]}`, r[i]!)
for (const [x, y] of candidates.values()) {
const dirs = new Set<string>()
for (const r of list) {
for (let i = 0; i < r.length - 1; i++) {
const [ax, ay] = r[i]!
const [bx, by] = r[i + 1]!
const onV = ax === bx && x === ax && y >= Math.min(ay, by) && y <= Math.max(ay, by)
const onH = ay === by && y === ay && x >= Math.min(ax, bx) && x <= Math.max(ax, bx)
if (!onV && !onH) continue
for (const [px, py] of [[ax, ay], [bx, by]] as Pt[]) {
if (px === x && py === y) continue
dirs.add(px < x ? 'L' : px > x ? 'R' : py < y ? 'U' : 'D')
}
}
}
if (dirs.size >= 3) dots.push({ x, y, src, color: colors.get(src) ?? '' })
}
}
return dots
})
const srcVal = (src: string) => {
const [node, pin] = src.split(':')
const n = nodeMap.value.get(node!)
// A cable is lit while any of its wires carries a 1.
if (n?.kind === 'bundle') return cableKeys(n).some(k => ed.val(n.id, k) === 1) ? 1 : 0
return ed.val(node!, pin!)
}
const hoverSrc = ref<string | null>(null)
// ── View ────────────────────────────────────────────────────────────
function bounds(nodes: CircuitNode[]) {
let x0 = Infinity
let y0 = Infinity
let x1 = -Infinity
let y1 = -Infinity
for (const n of nodes) {
const b = (shapes.value.get(n.id) ?? ed.shape(n)).body
x0 = Math.min(x0, n.x + b.x - (n.kind === 'input' || n.kind === 'button' ? 2 : 0))
y0 = Math.min(y0, n.y + b.y)
x1 = Math.max(x1, n.x + b.x + b.w + (n.kind === 'output' || n.kind === 'lamp' ? 2 : 0))
y1 = Math.max(y1, n.y + b.y + b.h)
}
return { x0, y0, x1, y1 }
}
function fit() {
const nodes = def.value.nodes
if (!nodes.length) {
ed.views[def.value.id] = { x: size.w / 2, y: size.h / 2, zoom: 1.25 }
return
}
const { x0, y0, x1, y1 } = bounds(nodes)
const zoom = Math.min(2.2, fitZoom())
ed.views[def.value.id] = {
zoom,
x: size.w / 2 - ((x0 + x1) / 2) * G * zoom,
y: size.h / 2 - ((y0 + y1) / 2) * G * zoom,
}
}
/** Zoom at which the whole circuit just fits on screen. */
function fitZoom(): number {
const nodes = def.value.nodes
if (!nodes.length) return 1
const { x0, y0, x1, y1 } = bounds(nodes)
const pad = 2
return Math.min(size.w / ((x1 - x0 + 2 * pad) * G), size.h / ((y1 - y0 + 2 * pad) * G))
}
/** Zooming out goes at least far enough to see the whole circuit with room around it. */
const minZoom = () => Math.max(0.005, Math.min(0.15, fitZoom() * 0.5))
function zoomAt(factor: number, sx = size.w / 2, sy = size.h / 2) {
const v = view.value
const zoom = Math.min(4, Math.max(minZoom(), v.zoom * factor))
const k = zoom / v.zoom
ed.views[def.value.id] = { zoom, x: sx - (sx - v.x) * k, y: sy - (sy - v.y) * k }
}
function toWorld(e: { clientX: number; clientY: number }): Pt {
const r = root.value!.getBoundingClientRect()
const v = view.value
return [(e.clientX - r.left - v.x) / (G * v.zoom), (e.clientY - r.top - v.y) / (G * v.zoom)]
}
watch(
() => def.value.id,
id => {
if (!ed.views[id]) nextTick(fit)
},
)
// Centre on a part picked elsewhere (the Pins list), keeping the zoom.
watch(
() => ed.focusRequest.value,
r => {
const n = r && nodeMap.value.get(r.id)
const s = n && shapes.value.get(n.id)
if (!n || !s) return
const v = view.value
ed.views[def.value.id] = {
...v,
x: size.w / 2 - (n.x + s.body.x + s.body.w / 2) * G * v.zoom,
y: size.h / 2 - (n.y + s.body.y + s.body.h / 2) * G * v.zoom,
}
},
)
let resize: ResizeObserver | undefined
onMounted(() => {
resize = new ResizeObserver(([entry]) => {
size.w = entry!.contentRect.width
size.h = entry!.contentRect.height
if (!ed.views[def.value.id]) fit()
})
resize.observe(root.value!)
window.addEventListener('keydown', onKey)
window.addEventListener('keyup', onKeyUp)
})
onBeforeUnmount(() => {
resize?.disconnect()
window.removeEventListener('keydown', onKey)
window.removeEventListener('keyup', onKeyUp)
})
// ── Placing ─────────────────────────────────────────────────────────
const cursor = ref<Pt | null>(null)
function originFor(p: { kind: CircuitNode['kind']; chip?: string; conn?: string }, at: Pt): Pt {
const b = ed.shape({ id: 'ghost', kind: p.kind, chip: p.chip, conn: p.conn, x: 0, y: 0 }).body
return [Math.round(at[0] - (b.x + b.w / 2)), Math.round(at[1] - (b.y + b.h / 2))]
}
/** Pins of everything on the canvas, for a new part to land on. */
const allPins = computed(() => dropPins(def.value, def.value.nodes, n => shapes.value.get(n.id)!))
/** Alt held while placing: just place, connect nothing. */
const altDown = ref(false)
/**
* Where a new part goes (being placed or dragged in from the parts list):
* at the mouse, or a square over so its free pins land on pins they can
* join, with the wires that makes.
*/
function landing(p: { kind: CircuitNode['kind']; chip?: string; conn?: string }, at: Pt, alt: boolean) {
const [x, y] = originFor(p, at)
const node: CircuitNode = { id: 'ghost', kind: p.kind, chip: p.chip, conn: p.conn, x, y, label: p.kind === 'note' ? 'Note' : p.kind === 'input' ? '?' : undefined }
const snap = alt ? null : dropLinks(dropPins(def.value, [node], n => ed.shape(n)), allPins.value, 1)
if (snap) {
node.x += snap.shift[0]
node.y += snap.shift[1]
}
return { node, links: snap?.links ?? [] }
}
const ghostLanding = computed(() => {
const p = ed.placing.value ?? ed.dragPart.value
return p && cursor.value ? landing(p, cursor.value, altDown.value) : null
})
const ghost = computed<CircuitNode | null>(() => ghostLanding.value?.node ?? null)
function onDragOver(e: DragEvent) {
if (!ed.dragPart.value) return
cursor.value = toWorld(e)
altDown.value = e.altKey
}
function onDragLeave(e: DragEvent) {
// Leaving the canvas, not just moving from one part of it to another.
if (!root.value?.contains(e.relatedTarget as Node | null)) cursor.value = null
}
// ── Cable buttons on a selected part ────────────────────────────────
/**
* One selected component (or panel, or hex display) gets a cable button
* beside its outputs and its inputs: a cable straight onto those pins.
*/
const cableButtons = computed(() => {
if (drag.value || ed.selection.value.length !== 1 || ed.linking.value || ed.placing.value) return []
const n = nodeMap.value.get(ed.selection.value[0]!)
if (!n) return []
const choices = ed.cableChoices(n)
const s = shapes.value.get(n.id)!
const out: { side: 'out' | 'in'; x: number; y: number }[] = []
const mid = (ps: { dy: number }[]) => (Math.min(...ps.map(p => p.dy)) + Math.max(...ps.map(p => p.dy))) / 2
const outs = s.outputs.filter(p => !p.bus)
const ins = s.inputs.filter(p => !p.bus)
if (choices.out.length && outs.length) out.push({ side: 'out', x: n.x + Math.max(...outs.map(p => p.dx)) + 1.3, y: n.y + mid(outs) })
if (choices.in.length && ins.length) out.push({ side: 'in', x: n.x + Math.min(...ins.map(p => p.dx)) - 1.3, y: n.y + mid(ins) })
return out
})
/** A cable button: with one way to do it, it is done; with several, they are offered. */
function onCableButton(side: 'out' | 'in', e: PointerEvent) {
const n = nodeMap.value.get(ed.selection.value[0]!)
if (!n) return
const groups = ed.cableChoices(n)[side]
const run = (pins: string[]) => (side === 'out' ? ed.cableOut(n.id, pins) : ed.cableIn(n.id, pins))
if (groups.length === 1) return run(groups[0]!.pins)
menu.value = {
x: e.clientX + 6,
y: e.clientY + 6,
entries: [
{ head: side === 'out' ? 'Cable from outputs' : 'Cable into inputs' },
...groups.map(g => ({ label: g.label, note: `${g.pins.length} wires`, icon: side === 'out' ? 'lucide:merge' : 'lucide:split', run: () => run(g.pins) })),
],
}
}
function onDrop(e: DragEvent) {
const raw = e.dataTransfer?.getData('application/x-logigate')
ed.dragPart.value = null
if (!raw) return
const p = JSON.parse(raw) as { kind: CircuitNode['kind']; chip?: string; conn?: string }
if (p.chip && !ed.canPlace(p.chip)) return ed.notify('A component cannot contain itself', 'error')
if (!ed.canPlaceKind(p.kind)) return
const { node, links } = landing(p, toWorld(e), e.altKey)
ed.addNode(p, node.x, node.y, links)
}
// ── Pointer interaction ─────────────────────────────────────────────
type Drag =
| {
kind: 'pan'
sx: number
sy: number
vx: number
vy: number
/** A right click that doesn't move opens the menu for what is under it. */
menu?: { target: Element; at: Pt }
}
| {
kind: 'move'
start: Pt
orig: Map<string, Pt>
/** Docked panels moved without their component: they only slide sideways. */
lockY: Set<string>
wires: Map<Wire, Pt[]>
moved: boolean
node: CircuitNode
toggle: boolean
row?: PanelRow
/** How many parts were picked up (followers not counted): one part may snap to a pin a square away. */
grabbed: number
/** Pins of the parts staying put, and of the moving parts where they started; filled once the drag moves. */
still?: DropPin[]
from?: DropPin[]
/** Pins the moving parts land on: the step that lines them up and the wires dropping makes. */
snap?: { shift: Pt; links: Link[] } | null
/** A cable end brought close to the part its wires run to: dropped, it plugs in. */
plug?: { part: string; rings: Pt[] } | null
}
| {
kind: 'wire'
node: string
pin: string
dir: 'in' | 'out'
start: Pt
cur: Pt
moved: boolean
branch?: Pt[]
/** Moving one end of this wire: the other end stays, the wire goes where it is dropped. */
replace?: string
}
| { kind: 'box'; start: Pt; cur: Pt; nodes: string[]; wires: string[] }
| { kind: 'segment'; wire: Wire; base: Pt[]; k: number; axis: 0 | 1; start: number; moved: boolean }
| { kind: 'corner'; wire: Wire; route: Pt[]; i: number; moved: boolean }
const drag = ref<Drag | null>(null)
const spaceDown = ref(false)
let lastClick = { id: '', t: 0 }
function isDoubleClick(id: string) {
const now = performance.now()
const dbl = lastClick.id === id && now - lastClick.t < 350
lastClick = dbl ? { id: '', t: 0 } : { id, t: now }
return dbl
}
/** Wires whose corner points travel with the nodes being moved. */
function wiresToShift(moving: Set<string>): Map<Wire, Pt[]> {
const out = new Map<Wire, Pt[]>()
for (const wire of def.value.wires) {
const both = moving.has(wire.from.node) && moving.has(wire.to.node)
if (wire.pts && (both || wireSelected.value.has(wire.id))) out.set(wire, wire.pts.map(p => [...p] as Pt))
}
return out
}
function onPointerDown(e: PointerEvent) {
const w = toWorld(e)
const v = view.value
if (e.button === 1 || e.button === 2 || (e.button === 0 && spaceDown.value)) {
menu.value = null
drag.value = { kind: 'pan', sx: e.clientX, sy: e.clientY, vx: v.x, vy: v.y, menu: e.button === 2 ? { target: e.target as Element, at: w } : undefined }
root.value!.setPointerCapture(e.pointerId)
return
}
if (e.button !== 0) return
root.value!.setPointerCapture(e.pointerId)
const link = ed.linking.value
const end = link?.queue[link.at]
if (end) {
// Connecting: a click on a pin or a part wires the current pin there.
const target = targetAt(w, end.dir === 'out' ? 'in' : 'out', ed.pinKind(end.node, end.pin, end.dir))
if (target) return ed.linkTo(target)
const pinEl = (e.target as Element).closest('[data-pin]')
if (pinEl && link.queue.length === 1) {
// Another pin of the same kind: start from that one instead.
const node = pinEl.getAttribute('data-node')!
const pin = pinEl.getAttribute('data-pin')!
ed.linking.value = { queue: [{ node, pin, dir: pinEl.getAttribute('data-dir') as 'in' | 'out', label: '' }], at: 0 }
return
}
return ed.stopLinking()
}
if (ed.cabling.value) {
ed.placeCable([Math.round(w[0]), Math.round(w[1])])
return
}
const placing = ed.placing.value
if (placing) {
if (placing.chip && !ed.canPlace(placing.chip)) {
ed.placing.value = null
return ed.notify('A component cannot contain itself', 'error')
}
const { node, links } = landing(placing, w, e.altKey)
ed.addNode(placing, node.x, node.y, links)
if (!e.shiftKey && !placing.keep) ed.placing.value = null
return
}
const target = e.target as Element
const cableEl = target.closest('[data-cable]')
if (cableEl) return onCableButton(cableEl.getAttribute('data-cable') as 'out' | 'in', e)
const widenEl = target.closest('[data-inputs]')
if (widenEl) {
// + or − under a selected gate: one input more or less.
const n = nodeMap.value.get(widenEl.closest('[data-node]')?.getAttribute('data-node') ?? '')
if (n) ed.setInputs(n, inputCount(n, ed.getDef.value) + Number(widenEl.getAttribute('data-inputs')))
return
}
const fitEl = target.closest('[data-fit]')
if (fitEl) {
// A green box: wire the selection to the pins pointed at.
const i = Number(fitEl.getAttribute('data-fit'))
const spot = ed.fits.value[i]
const h = ed.fitHover.value
if (spot) ed.connectFit(i, h?.spot === i ? h.start : fitStart(spot, w[1]))
return
}
const pinEl = target.closest('[data-pin]')
if (pinEl && e.altKey && pinEl.getAttribute('data-dir') === 'in') {
// Alt + click on an input: invert it (a bubble), or take the bubble off.
const n = nodeMap.value.get(pinEl.getAttribute('data-node')!)
if (n && INVERTIBLE.has(n.kind)) return ed.toggleInvert(n, pinEl.getAttribute('data-pin')!)
}
if (pinEl) {
drag.value = {
kind: 'wire',
node: pinEl.getAttribute('data-node')!,
pin: pinEl.getAttribute('data-pin')!,
dir: pinEl.getAttribute('data-dir') as 'in' | 'out',
start: w,
cur: w,
moved: false,
}
return
}
const junctionEl = target.closest('[data-junction]')
if (junctionEl) {
// A junction dot stands for its whole signal.
const src = junctionEl.getAttribute('data-junction')
ed.wireSel.value = def.value.wires.filter(x => `${x.from.node}:${x.from.pin}` === src).map(x => x.id)
ed.selection.value = []
return
}
const wireEl = target.closest('[data-wire]')
if (wireEl) return onWireDown(e, wireEl, w)
const nodeEl = target.closest('[data-node]')
if (nodeEl) {
const id = nodeEl.getAttribute('data-node')!
const node = nodeMap.value.get(id)
if (!node) return
const multi = e.shiftKey || e.ctrlKey || e.metaKey
if (multi) {
ed.selection.value = selected.value.has(id) ? ed.selection.value.filter(s => s !== id) : [...ed.selection.value, id]
} else if (!selected.value.has(id)) {
ed.selection.value = [id]
ed.wireSel.value = []
}
const rowId = target.closest('[data-row]')?.getAttribute('data-row')
const row = rowId ? node.rows?.find(r => r.id === rowId) : undefined
if (!row && isDoubleClick(`n:${id}`)) return onDoubleClick(node)
if (node.kind === 'button') ed.press(node, true)
if (row && !multi) ed.pressRow(node, row, true)
const ids = ed.withFollowers(selected.value.has(id) ? ed.selection.value : [id])
const orig = new Map<string, Pt>()
const lockY = new Set<string>()
for (const sid of ids) {
const n = nodeMap.value.get(sid)
if (!n) continue
orig.set(sid, [n.x, n.y])
if (n.attach && !ids.has(n.attach)) lockY.add(sid)
}
drag.value = {
kind: 'move',
start: w,
orig,
lockY,
wires: wiresToShift(ids),
moved: false,
node,
toggle: (node.kind === 'input' || !!row) && !multi,
row,
grabbed: selected.value.has(id) ? ed.selection.value.length : 1,
}
return
}
if (!e.shiftKey) ed.clearSelection()
drag.value = { kind: 'box', start: w, cur: w, nodes: [...ed.selection.value], wires: [...ed.wireSel.value] }
}
function onWireDown(e: PointerEvent, el: Element, w: Pt) {
const wire = def.value.wires.find(x => x.id === el.getAttribute('data-wire'))
const route = wire && routeOf(wire)
if (!wire || !route) return
const corner = el.getAttribute('data-corner')
if (corner !== null) {
drag.value = { kind: 'corner', wire, route: route.pts.map(p => [...p] as Pt), i: Number(corner), moved: false }
return
}
const index = el.hasAttribute('data-seg') ? Number(el.getAttribute('data-seg')) : Math.max(0, segmentAt(route.pts, w, 1))
if (e.ctrlKey || e.metaKey) {
// Branch: a new wire from the same signal, starting at this point.
drag.value = { kind: 'wire', node: wire.from.node, pin: wire.from.pin, dir: 'out', start: w, cur: w, moved: true, branch: branchCorners(route.pts, index, w) }
return
}
if (e.shiftKey) {
ed.wireSel.value = wireSelected.value.has(wire.id) ? ed.wireSel.value.filter(id => id !== wire.id) : [...ed.wireSel.value, wire.id]
return
}
if (isDoubleClick(`w:${wire.id}`)) {
ed.selectNet(wire.id)
ed.selection.value = []
return
}
// Grabbing a wire by its end (the grip, or close to the pin) moves that end to another pin.
const end = (el.getAttribute('data-end') as 'from' | 'to' | null) ?? (e.altKey ? null : nearEnd(route.pts, w))
if (end && !isCable(wire)) {
const stay = end === 'to' ? wire.from : wire.to
drag.value = { kind: 'wire', node: stay.node, pin: stay.pin, dir: end === 'to' ? 'out' : 'in', start: w, cur: w, moved: false, replace: wire.id }
ed.wireSel.value = [wire.id]
ed.selection.value = []
return
}
if (!wireSelected.value.has(wire.id)) {
ed.wireSel.value = [wire.id]
ed.selection.value = []
}
const prep = e.altKey ? splitDrag(route.pts, index, w) : segmentDrag(route.pts, index)
if (prep) drag.value = { kind: 'segment', wire, ...prep, start: w[prep.axis], moved: false }
}
function onPointerMove(e: PointerEvent) {
lastClient = { x: e.clientX, y: e.clientY }
const w = toWorld(e)
cursor.value = w
altDown.value = e.altKey
const d = drag.value
if (!d) return
switch (d.kind) {
case 'pan':
ed.views[def.value.id] = { ...view.value, x: d.vx + e.clientX - d.sx, y: d.vy + e.clientY - d.sy }
break
case 'move': {
const dx = Math.round(w[0] - d.start[0])
const dy = Math.round(w[1] - d.start[1])
if (!d.moved && (dx || dy)) {
d.moved = true
if (d.node.kind === 'button') ed.press(d.node, false)
if (d.row) ed.pressRow(d.node, d.row, false)
const moving = def.value.nodes.filter(n => d.orig.has(n.id))
d.still = dropPins(def.value, def.value.nodes.filter(n => !d.orig.has(n.id)), n => shapes.value.get(n.id)!)
d.from = dropPins(def.value, moving, n => shapes.value.get(n.id)!)
}
if (d.still && d.from) {
// Dropped onto pins it can join, it connects there (Alt: just place it).
const at = d.from.map(p => ({ ...p, x: p.x + dx, y: d.lockY.has(p.node) ? p.y : p.y + dy }))
d.snap = e.altKey ? null : dropLinks(at, d.still, d.grabbed === 1 ? 1 : 0)
}
d.plug = d.moved && d.grabbed === 1 && !e.altKey ? plugNear(d.node) : null
for (const [id, [x, y]] of d.orig) {
const n = nodeMap.value.get(id)
if (n) {
n.x = x + dx
n.y = d.lockY.has(id) ? y : y + dy
}
}
for (const [wire, pts] of d.wires) wire.pts = pts.map(([x, y]) => [x + dx, y + dy])
break
}
case 'wire':
d.cur = w
if (Math.hypot(w[0] - d.start[0], w[1] - d.start[1]) > 0.4) d.moved = true
break
case 'box': {
d.cur = w
const x0 = Math.min(d.start[0], w[0])
const x1 = Math.max(d.start[0], w[0])
const y0 = Math.min(d.start[1], w[1])
const y1 = Math.max(d.start[1], w[1])
const nodes = def.value.nodes
.filter(n => {
const b = shapes.value.get(n.id)!.body
return n.x + b.x < x1 && n.x + b.x + b.w > x0 && n.y + b.y < y1 && n.y + b.y + b.h > y0
})
.map(n => n.id)
// Dragged right to left, or across wires without touching any part: every wire the box
// crosses. Otherwise only wires lying fully inside, so a box over some parts doesn't
// catch (and on Delete remove) unrelated wires passing through.
const box = { x0, y0, x1, y1 }
const crossing = w[0] < d.start[0] || !nodes.length
const wires = routes.value
.filter(r => (crossing ? routeTouchesBox(r.pts, box) : r.pts.every(([x, y]) => x >= x0 && x <= x1 && y >= y0 && y <= y1)))
.map(r => r.wire.id)
ed.selection.value = [...new Set([...d.nodes, ...nodes])]
ed.wireSel.value = [...new Set([...d.wires, ...wires])]
break
}
case 'segment': {
const delta = Math.round(w[d.axis] - d.start)
if (!delta && !d.moved) break
d.moved = true
d.wire.pts = moveSegment(d.base, d.k, d.axis, delta)
break
}
case 'corner': {
const to: Pt = [Math.round(w[0]), Math.round(w[1])]
const at = d.route[d.i]!
if (!d.moved && to[0] === at[0] && to[1] === at[1]) break
d.moved = true
d.wire.pts = moveCorner(d.route, d.i, to)
break
}
}
}
/** Pin keys that already have a wire, as "node:pin": inputs by their wire, outputs by any wire. */
const linked = computed(() => {
const ins = new Set<string>()
const outs = new Set<string>()
for (const w of def.value.wires) {
ins.add(`${w.to.node}:${w.to.pin}`)
outs.add(`${w.from.node}:${w.from.pin}`)
}
return { in: ins, out: outs }
})
/**
* Names to show, dimmed, on switches, buttons, clocks, lamps and output pins
* that have none of their own: the component pin they are wired to.
*/
const hints = computed(() => {
const out = new Map<string, string>()
const nodes = nodeMap.value
for (const w of def.value.wires) {
const from = nodes.get(w.from.node)
const to = nodes.get(w.to.node)
if (!from || !to) continue
if (SOURCES.has(from.kind) && (from.autoLabel || !from.label?.trim()) && !out.has(from.id)) {
const name = pinName(to, w.to.pin, ed.getDef.value)
if (name) out.set(from.id, name)
}
if (SINKS.has(to.kind) && (to.autoLabel || !to.label?.trim()) && !out.has(to.id)) {
const name = pinName(from, w.from.pin, ed.getDef.value)
if (name) out.set(to.id, name)
}
}
return out
})
/** Inputs with no wire, marked like Loxone does: they read 0. */
const openPins = computed(() => {
const out = new Map<string, Set<string>>()
for (const n of def.value.nodes) {
if (!CHECKED_INPUTS.has(n.kind)) continue
const open = shapes.value.get(n.id)!.inputs.filter(p => !p.bus && !linked.value.in.has(`${n.id}:${p.key}`)).map(p => p.key)
if (open.length) out.set(n.id, new Set(open))
}
return out
})
/** The signal of the one selected tag or reference: all of its tags and references light up. */
const signalSel = computed(() => {
if (ed.selection.value.length !== 1) return ''
const n = nodeMap.value.get(ed.selection.value[0]!)
return n && (n.kind === 'tag' || n.kind === 'ref') ? (n.label?.trim() ?? '') : ''
})
const SOURCES = new Set(['input', 'button', 'clock'])
const SINKS = new Set(['output', 'lamp'])
/** The part whose body is under the point; the one drawn on top wins. */
function nodeAt(at: Pt): CircuitNode | undefined {
const list = def.value.nodes
for (let i = list.length - 1; i >= 0; i--) {
const n = list[i]!
if (n.kind === 'note') continue
const b = shapes.value.get(n.id)!.body
if (at[0] >= n.x + b.x - 0.3 && at[0] <= n.x + b.x + b.w + 0.3 && at[1] >= n.y + b.y - 0.3 && at[1] <= n.y + b.y + b.h + 0.3) return n
}
return undefined
}
/**
* Where a wire would go: a pin of the wanted direction close to the point,
* else, over a part, that part's first free pin (or its nearest one when
* all are taken). So dropping a wire anywhere on a component works.
*/
function targetAt(at: Pt, dir: 'in' | 'out', bus = ''): PinRef | null {
let best: PinRef | null = null
let bestD = 1.1 * 1.1
for (const n of def.value.nodes) {
const s = shapes.value.get(n.id)!
for (const p of dir === 'in' ? s.inputs : s.outputs) {
if (pinKindOf(p) !== bus) continue
const dx = n.x + p.dx - at[0]
const dy = n.y + p.dy - at[1]
const dd = dx * dx + dy * dy
if (dd < bestD) {
bestD = dd
best = { node: n.id, pin: p.key }
}
}
}
if (best) return best
const n = nodeAt(at)
if (!n) return null
const pins = (dir === 'in' ? shapes.value.get(n.id)!.inputs : shapes.value.get(n.id)!.outputs).filter(p => pinKindOf(p) === bus)
if (!pins.length) return null
const taken = linked.value[dir]
const free = pins.find(p => !taken.has(`${n.id}:${p.key}`))
if (free) return { node: n.id, pin: free.key }
const near = pins.reduce((a, p) => (Math.abs(n.y + p.dy - at[1]) < Math.abs(n.y + a.dy - at[1]) ? p : a))
return { node: n.id, pin: near.key }
}
function onPointerUp(e: PointerEvent) {
const d = drag.value
drag.value = null
if (!d) return
switch (d.kind) {
case 'pan':
if (d.menu && Math.abs(e.clientX - d.sx) + Math.abs(e.clientY - d.sy) < 5) openMenuAt(d.menu.target, d.menu.at, e.clientX, e.clientY)
break
case 'move':
if (d.node.kind === 'button') ed.press(d.node, false)
if (d.row && !d.moved) ed.pressRow(d.node, d.row, false)
if (d.moved && d.plug) {
ed.unplugMoved(new Set(d.orig.keys()))
ed.plugEnd(d.node)
} else if (d.moved && d.snap?.links.length) {
const [sx, sy] = d.snap.shift
for (const id of d.orig.keys()) {
const n = nodeMap.value.get(id)
if (!n) continue
n.x += sx
if (!d.lockY.has(id)) n.y += sy
}
for (const wire of d.wires.keys()) wire.pts = wire.pts?.map(([x, y]) => [x + sx, y + sy])
ed.unplugMoved(new Set(d.orig.keys()))
ed.connectMany(d.snap.links)
ed.commit(false)
} else if (d.moved) {
ed.unplugMoved(new Set(d.orig.keys()))
ed.commit(false)
} else if (d.toggle && d.row) ed.toggleRow(d.node, d.row)
else if (d.toggle) ed.toggleInput(d.node)
break
case 'wire': {
const here = { node: d.node, pin: d.pin }
if (!d.moved) {
if (d.replace) break
// A click on a pin: the wire follows the mouse until the next click.
ed.linking.value = { queue: [{ ...here, dir: d.dir, label: '' }], at: 0 }
break
}
const onWire = wireDrop(d)
const target = targetAt(d.cur, d.dir === 'out' ? 'in' : 'out', ed.pinKind(d.node, d.pin, d.dir)) ?? onWire?.pin
if (!target) break
if (d.replace) {
ed.rewire(d.replace, d.dir === 'out' ? here : target, d.dir === 'out' ? target : here)
break
}
if (onWire && d.dir === 'in' && !d.branch) {
// Dropped on a wire from a pin that needs a signal: it taps that wire's signal where it was dropped.
const r = onWire.route
const fn = nodeMap.value.get(target.node)!
const tn = nodeMap.value.get(here.node)!
const a = pinPos(fn, shapes.value.get(fn.id)!, target.pin, 'out')!
const b = pinPos(tn, shapes.value.get(tn.id)!, here.pin, 'in')!
ed.connect(target, here, branchTo(branchCorners(r.pts, onWire.seg, d.cur), [a.x, a.y], [b.x, b.y]))
break
}
// Dragged from one of several selected parts to another part: wire them all, in order.
if (!d.branch && ed.selection.value.length > 1 && ed.selection.value.includes(d.node) && !ed.selection.value.includes(target.node)) {
ed.connectMany(seriesLinks(def.value, ed.getDef.value, ed.selection.value, { node: d.node, pin: d.pin, dir: d.dir }, target))
break
}
if (d.dir === 'in') {
ed.connect(target, here)
break
}
let corners = d.branch
if (corners) {
const fn = nodeMap.value.get(d.node)!
const tn = nodeMap.value.get(target.node)!
const a = pinPos(fn, shapes.value.get(fn.id)!, d.pin, 'out')!
const b = pinPos(tn, shapes.value.get(tn.id)!, target.pin, 'in')!
corners = branchTo(corners, [a.x, a.y], [b.x, b.y])
}
ed.connect(here, target, corners)
break
}
case 'segment':
case 'corner':
if (d.moved) ed.commit(false)
break
}
}
function onDoubleClick(node: CircuitNode) {
if (node.kind === 'chip' && node.chip) ed.open(node.chip)
else if (['input', 'output', 'lamp', 'button', 'note', 'hex', 'panel', 'outpanel', 'tag', 'ref'].includes(node.kind)) {
ed.selection.value = [node.id]
ed.labelFocus.value++
}
}
function onWheel(e: WheelEvent) {
const r = root.value!.getBoundingClientRect()
const k = e.ctrlKey ? 0.01 : 0.0015
zoomAt(Math.exp(-e.deltaY * k), e.clientX - r.left, e.clientY - r.top)
}
// ── Keyboard ────────────────────────────────────────────────────────
const QUICK: Record<string, CircuitNode['kind']> = { n: 'nand', i: 'input', o: 'output', l: 'lamp', c: 'clock', b: 'button', h: 'hex', t: 'note', p: 'panel', x: 'pixel' }
const ARROWS: Record<string, Pt> = { ArrowLeft: [-1, 0], ArrowRight: [1, 0], ArrowUp: [0, -1], ArrowDown: [0, 1] }
/** Arrow keys: move the selected parts and wires one grid step (four with Shift). */
function nudge(dx: number, dy: number) {
const ids = ed.withFollowers(ed.selection.value)
if (!ids.size && !ed.wireSel.value.length) return
ed.unplugMoved(ids)
for (const n of def.value.nodes) {
if (!ids.has(n.id)) continue
n.x += dx
if (!n.attach || ids.has(n.attach)) n.y += dy
}
for (const r of routes.value) {
const both = ids.has(r.wire.from.node) && ids.has(r.wire.to.node)
if (wireSelected.value.has(r.wire.id)) {
const pts = r.wire.pts ?? r.pts.slice(1, -1)
r.wire.pts = pts.map(([x, y]) => [x + dx, y + dy])
} else if (both && r.wire.pts) {
r.wire.pts = r.wire.pts.map(([x, y]) => [x + dx, y + dy])
}
}
ed.commit(false)
}
function onKey(e: KeyboardEvent) {
const el = e.target as HTMLElement
if (el.closest?.('input, textarea, select, [contenteditable]')) return
if (ed.dialog.value || ed.showHelp.value) {
if (e.key === 'Escape') {
ed.dialog.value = null
ed.showHelp.value = false
}
return
}
// Paused: the pause menu has the keys.
if (ed.paused.value) return
const mod = e.ctrlKey || e.metaKey
const key = e.key.toLowerCase()
if (e.key === 'ContextMenu' || (e.shiftKey && e.key === 'F10')) {
e.preventDefault()
return openMenuForSelection()
}
// Finding parts from the keyboard: /, Shift+A or Ctrl+K add one at the mouse.
if (e.key === '/' && !mod) {
e.preventDefault()
return openQuickAdd()
}
if ((e.shiftKey && key === 'a' && !mod) || (mod && key === 'k')) {
e.preventDefault()
return openQuickAdd()
}
// Keys bound to switches, buttons and panel rows win over the shortcuts below.
if (!mod && !e.altKey && e.key.length === 1) {
const bound = def.value.nodes.filter(n => n.key === key && (n.kind === 'input' || n.kind === 'button'))
const rows = boundRows(key)
if (bound.length || rows.length) {
e.preventDefault()
if (e.repeat) return
for (const n of bound) n.kind === 'input' ? ed.toggleInput(n) : ed.press(n, true)
for (const [n, r] of rows) r.type === 'button' ? ed.pressRow(n, r, true) : ed.toggleRow(n, r)
return
}
}
if (mod && key === 'p') {
e.preventDefault()
ed.exportSheet('print')
return
}
if (mod && key === 'f') {
e.preventDefault()
ed.dialog.value = 'search'
return
}
if (mod && key === 'z') {
e.preventDefault()
if (e.shiftKey) ed.redo()
else ed.undo()
} else if (mod && key === 'y') {
e.preventDefault()
ed.redo()
} else if (mod && key === 'c') ed.copy()
else if (mod && key === 'v') ed.paste()
else if (mod && key === 'd') {
e.preventDefault()
ed.duplicate()
} else if (mod && key === 'g') {
e.preventDefault()
if (e.shiftKey) ed.startCable()
else ed.bundleSelected()
} else if (mod && key === 'a') {
e.preventDefault()
ed.selectAll()
} else if (e.key === 'Delete' || e.key === 'Backspace') {
e.preventDefault()
ed.deleteSelected()
} else if (e.key === 'Escape') {
if (ed.cabling.value) {
ed.cabling.value = null
return
}
if (ed.linking.value) return ed.stopLinking()
// Nothing to cancel: Esc pauses, like in a game.
if (!ed.placing.value && !ed.selection.value.length && !ed.wireSel.value.length) return ed.pause()
ed.placing.value = null
ed.clearSelection()
} else if (ARROWS[e.key]) {
e.preventDefault()
const [dx, dy] = ARROWS[e.key]!
const step = e.shiftKey ? 4 : 1
nudge(dx * step, dy * step)
} else if (e.key === ' ') {
e.preventDefault()
spaceDown.value = true
} else if (e.key === 'Enter' && ed.selection.value.length === 1) {
const n = nodeMap.value.get(ed.selection.value[0]!)
if (n?.kind === 'chip' && n.chip) ed.open(n.chip)
} else if (!mod && !e.altKey && key === 'w' && ed.selection.value.length) ed.startLinking(ed.selection.value, e.shiftKey ? 'in' : undefined)
else if (!mod && !e.altKey && key === 'f') fit()
else if (!mod && !e.altKey && e.key === '[') ed.togglePanel()
else if (!mod && !e.altKey && e.key === '?') ed.showHelp.value = !ed.showHelp.value
else if (!mod && !e.altKey && QUICK[key] && ed.canPlaceKind(QUICK[key]!)) ed.placing.value = { kind: QUICK[key]! }
}
function onKeyUp(e: KeyboardEvent) {
if (e.key === ' ') spaceDown.value = false
const key = e.key.toLowerCase()
for (const n of def.value.nodes) if (n.kind === 'button' && n.key === key) ed.press(n, false)
for (const [n, r] of boundRows(key)) if (r.type === 'button') ed.pressRow(n, r, false)
}
/** Panel rows bound to a key. */
function boundRows(key: string): [CircuitNode, PanelRow][] {
const out: [CircuitNode, PanelRow][] = []
for (const n of def.value.nodes) if (n.kind === 'panel') for (const r of n.rows ?? []) if (r.key === key) out.push([n, r])
return out
}
// ── Overlays ────────────────────────────────────────────────────────
/** The wire being drawn: dragged from a pin, or following the mouse after a click on a pin. */
const pending = computed(() => {
const d = drag.value
if (d?.kind === 'wire') return d.moved ? { node: d.node, pin: d.pin, dir: d.dir, cur: d.cur, branch: d.branch } : null
const l = ed.linking.value
const end = l?.queue[l.at]
return end && cursor.value ? { node: end.node, pin: end.pin, dir: end.dir, cur: cursor.value, branch: undefined } : null
})
const tempWire = computed(() => {
const d = pending.value
if (!d) return null
const n = nodeMap.value.get(d.node)
if (!n) return null
const p = pinPos(n, shapes.value.get(n.id)!, d.pin, d.dir)
if (!p) return null
const want = d.dir === 'out' ? 'in' : 'out'
const target = targetAt(d.cur, want, ed.pinKind(d.node, d.pin, d.dir))
let end: Pt = [Math.round(d.cur[0]), Math.round(d.cur[1])]
// The side the far end faces: a snapped pin's own, else the usual one.
let endFace: 1 | -1 = want === 'in' ? -1 : 1
if (target) {
const tn = nodeMap.value.get(target.node)!
const tp = pinPos(tn, shapes.value.get(tn.id)!, target.pin, want)!
end = [tp.x, tp.y]
endFace = tp.face
}
const pts =
d.dir === 'out'
? routeWire([p.x, p.y], end, d.branch && branchTo(d.branch, [p.x, p.y], end), p.face, endFace)
: routeWire(end, [p.x, p.y], undefined, endFace, p.face)
return { d: toPath(pts), snapped: !!target, end }
})
const isCable = (w: Wire) => nodeMap.value.get(w.from.node)?.kind === 'bundle'
/**
* A wire being drawn and dropped on another wire (not on a pin): one that
* needs a signal takes that wire's signal; one that carries a signal feeds
* what that wire fed, in its place.
*/
function wireDrop(d: { node: string; pin: string; dir: 'in' | 'out'; cur: Pt; replace?: string }) {
if (targetAt(d.cur, d.dir === 'out' ? 'in' : 'out', ed.pinKind(d.node, d.pin, d.dir))) return null
const bus = ed.pinKind(d.node, d.pin, d.dir)
for (let i = routes.value.length - 1; i >= 0; i--) {
const r = routes.value[i]!
if (r.wire.id === d.replace || r.kind !== bus) continue
if (d.dir === 'in' ? r.wire.to.node === d.node && r.wire.to.pin === d.pin : r.wire.from.node === d.node && r.wire.from.pin === d.pin) continue
const seg = segmentAt(r.pts, d.cur, 0.35)
if (seg < 0) continue
return { route: r, seg, pin: d.dir === 'in' ? r.wire.from : r.wire.to }
}
return null
}
/** The wire a wire being drawn would drop onto, shown highlighted. */
const dropWire = computed(() => {
const d = pending.value
return d ? (wireDrop({ ...d, replace: drag.value?.kind === 'wire' ? drag.value.replace : undefined })?.route.wire.id ?? null) : null
})
/** The wire whose end is being moved: drawn faint while it follows the mouse. */
const movingWire = computed(() => (drag.value?.kind === 'wire' && drag.value.moved ? (drag.value.replace ?? null) : null))
const hoverWire = ref<string | null>(null)
/** Grips on the ends of the wire under the mouse (or selected): drag one to move that end to another pin. */
const grips = computed(() => {
if (drag.value) return []
const ids = new Set([...ed.wireSel.value.slice(0, 8), ...(hoverWire.value ? [hoverWire.value] : [])])
return routes.value
.filter(r => ids.has(r.wire.id) && !r.bits)
.flatMap(r =>
(['from', 'to'] as const).flatMap(end => {
const p = endGrip(r.pts, end)
return p ? [{ wire: r.wire.id, end, x: p[0], y: p[1] }] : []
}),
)
})
/** Pins a wire being drawn can go to: free ones stand out, taken ones would be replaced. */
const targets = computed(() => {
const d = pending.value
if (!d) return []
const want = d.dir === 'out' ? 'in' : 'out'
const bus = ed.pinKind(d.node, d.pin, d.dir)
const taken = linked.value[want]
const out: { x: number; y: number; free: boolean }[] = []
for (const n of def.value.nodes) {
const s = shapes.value.get(n.id)!
for (const p of want === 'in' ? s.inputs : s.outputs) {
if (pinKindOf(p) !== bus) continue
// An output can always take one more wire; an input only has room for one.
out.push({ x: n.x + p.dx, y: n.y + p.dy, free: want === 'out' || !taken.has(`${n.id}:${p.key}`) })
}
}
return out
})
/** Numbers on the pins still waiting in "connect one by one". */
const queueBadges = computed(() => {
const l = ed.linking.value
if (!l || l.queue.length < 2) return []
return l.queue.flatMap((e, i) => {
if (i < l.at) return []
const n = nodeMap.value.get(e.node)
const p = n && pinPos(n, shapes.value.get(n.id)!, e.pin, e.dir)
return p ? [{ x: p.x + (e.dir === 'out' ? 0.75 : -0.75), y: p.y - 0.55, n: i + 1, current: i === l.at }] : []
})
})
const boxRect = computed(() => {
const d = drag.value
if (d?.kind !== 'box') return null
return {
x: Math.min(d.start[0], d.cur[0]) * G,
y: Math.min(d.start[1], d.cur[1]) * G,
width: Math.abs(d.cur[0] - d.start[0]) * G,
height: Math.abs(d.cur[1] - d.start[1]) * G,
// Right to left: everything the box touches (drawn green, as in CAD programs).
class: d.cur[0] < d.start[0] ? 'box-select crossing' : 'box-select',
}
})
/** Corner handles of the selected wires. */
const handles = computed(() =>
routes.value
.filter(r => wireSelected.value.has(r.wire.id))
.flatMap(r => r.pts.slice(1, -1).map((p, i) => ({ wire: r.wire.id, i: i + 1, x: p[0], y: p[1] }))),
)
const gridSize = computed(() => G * view.value.zoom)
const flow = computed(() => ed.project.value.settings.flow)
/** Preview while placing a cable: its start (where you clicked or the mouse) and its end. */
const cableGhost = computed(() => {
const c = ed.cabling.value
if (!c || !cursor.value) return null
const at: Pt = [Math.round(cursor.value[0]), Math.round(cursor.value[1])]
const bits = c.wires.length
const mid = Math.floor((bits - 1) / 2)
const end = (kind: 'bundle' | 'split', p: Pt): CircuitNode => ({ id: `ghost-${kind}`, kind, bits, x: p[0], y: p[1] - mid })
if (!c.start) return { nodes: [end('bundle', at)], line: '' }
return { nodes: [end('bundle', c.start), end('split', at)], line: toPath(routeWire(c.start, at)) }
})
// ── Sheets ──────────────────────────────────────────────────────────
const content = ref<SVGGElement>()
/** The open circuit as a sheet with a title block: printed on white paper, or saved as SVG like on screen. */
watch(
() => ed.sheetRequest.value?.n,
() => {
const req = ed.sheetRequest.value
if (!req || !content.value) return
if (!def.value.nodes.length) return ed.notify('Nothing to print: the circuit is empty', 'error')
const b = bounds(def.value.nodes)
for (const r of routes.value) {
for (const [x, y] of r.pts) {
b.x0 = Math.min(b.x0, x)
b.x1 = Math.max(b.x1, x)
b.y0 = Math.min(b.y0, y)
b.y1 = Math.max(b.y1, y)
}
}
const m = 2
const box = { x: (b.x0 - m) * G, y: (b.y0 - m) * G, w: (b.x1 - b.x0 + 2 * m) * G, h: (b.y1 - b.y0 + 2 * m) * G }
// Without the selection, so the sheet shows the circuit as it is.
const keep = { nodes: ed.selection.value, wires: ed.wireSel.value }
ed.selection.value = []
ed.wireSel.value = []
nextTick(() => {
const info = { project: ed.meta.value?.name ?? ed.project.value.name ?? 'Project', circuit: def.value.name, date: new Date(), box }
if (req.mode === 'print') printSheet(sheetSvg(content.value!, { ...info, paper: true }), `${info.project} - ${info.circuit}`)
else downloadSheet(sheetSvg(content.value!, info), info.circuit)
ed.selection.value = keep.nodes
ed.wireSel.value = keep.wires
})
},
)
// ── Quick add ───────────────────────────────────────────────────────
/** The quick-add box: where it opened on screen and on the canvas. */
const quick = ref<{ x: number; y: number; at: Pt } | null>(null)
let lastClient = { x: 0, y: 0 }
function openQuickAdd(centre = false) {
const r = root.value!.getBoundingClientRect()
const inside = !centre && lastClient.x >= r.left && lastClient.x <= r.right && lastClient.y >= r.top && lastClient.y <= r.bottom
const x = inside ? lastClient.x : r.left + r.width / 2
const y = inside ? lastClient.y : r.top + r.height / 3
quick.value = { x, y, at: toWorld({ clientX: x, clientY: y }) }
}
// The search button in the parts bar opens it in the middle of the canvas.
watch(ed.partSearch, () => openQuickAdd(true))
function onQuickPick(p: { kind: CircuitNode['kind']; chip?: string }) {
const q = quick.value
quick.value = null
if (!q) return
const { node, links } = landing(p, q.at, false)
ed.addNode(p, node.x, node.y, links)
}
// ── Context menu ────────────────────────────────────────────────────
const menu = ref<{ x: number; y: number; entries: MenuEntry[]; keyboard?: boolean } | null>(null)
const { build } = useMenu()
const canvasOps: CanvasOps = {
fit,
place: (kind, at) => {
const [x, y] = originFor({ kind }, at)
ed.addNode({ kind }, x, y)
},
}
/**
* Right click: on a part or wire it selects that (unless it is in the
* selection already) and shows what can be done with the selection; on
* empty canvas, what can go there.
*/
function openMenuAt(target: Element, at: Pt, x: number, y: number) {
const nodeId = target.closest('[data-node]')?.getAttribute('data-node')
const wireId = target.closest('[data-wire]')?.getAttribute('data-wire')
const junction = target.closest('[data-junction]')?.getAttribute('data-junction')
if (nodeId && nodeMap.value.has(nodeId)) {
if (!selected.value.has(nodeId)) {
ed.selection.value = [nodeId]
ed.wireSel.value = []
}
} else if (wireId) {
if (!wireSelected.value.has(wireId)) {
ed.wireSel.value = [wireId]
ed.selection.value = []
}
} else if (junction) {
ed.wireSel.value = def.value.wires.filter(w => `${w.from.node}:${w.from.pin}` === junction).map(w => w.id)
ed.selection.value = []
}
const onThing = !!(nodeId || wireId || junction)
const entries = build(onThing ? { kind: 'selection' } : { kind: 'canvas', at }, canvasOps)
// On an input pin: its bubble first (the same as Alt + click, which some desktops take for themselves).
const pin = target.closest('[data-pin][data-dir="in"]')?.getAttribute('data-pin')
const n = nodeId ? nodeMap.value.get(nodeId) : undefined
if (pin && n && INVERTIBLE.has(n.kind)) {
const on = n.invert?.includes(pin)
entries.unshift({ label: on ? 'Take the bubble off this input' : 'Invert this input', icon: 'lucide:circle-dot', keys: 'Alt+click', run: () => ed.toggleInvert(n, pin) }, 'sep')
}
menu.value = entries.length ? { x: x + 2, y: y + 2, entries } : null
}
/** The menu key (or Shift+F10): the menu for the selection, by its middle. */
function openMenuForSelection() {
const r = root.value!.getBoundingClientRect()
const ids = new Set(ed.selection.value)
const nodes = def.value.nodes.filter(n => ids.has(n.id))
const v = view.value
let at: Pt = [(size.w / 2 - v.x) / (G * v.zoom), (size.h / 2 - v.y) / (G * v.zoom)]
if (nodes.length) {
const b = bounds(nodes)
at = [(b.x0 + b.x1) / 2, (b.y0 + b.y1) / 2]
}
const x = r.left + v.x + at[0] * G * v.zoom
const y = r.top + v.y + at[1] * G * v.zoom
const entries = build(nodes.length || ed.wireSel.value.length ? { kind: 'selection' } : { kind: 'canvas', at }, canvasOps)
menu.value = entries.length ? { x, y, entries, keyboard: true } : null
}
/**
* A free cable end dragged to within a square or so of where it would sit
* on its part's pins: the pins it would plug into.
*/
function plugNear(n: CircuitNode): { part: string; rings: Pt[] } | null {
if ((n.kind !== 'bundle' && n.kind !== 'split') || n.plug) return null
const part = ed.plugTarget(n)
const lay = part && plugLayout(def.value, n, part, ed.getDef.value)
if (!part || !lay || Math.hypot(n.x - lay.x, n.y - lay.y) > 1.6) return null
const x = n.kind === 'split' ? lay.x + 1 : lay.x
return { part: part.id, rings: lay.offsets.map(o => [x, lay.y + o] as Pt) }
}
/** Pins a dragged part will connect to when dropped, shown as green rings. */
const dropRings = computed(() => {
const g = ghostLanding.value
if (g?.links.length) {
return g.links.map(l => {
const end = l.from.node === 'ghost' ? { ...l.to, dir: 'in' } : { ...l.from, dir: 'out' }
return allPins.value.find(p => p.node === end.node && p.pin === end.pin && p.dir === end.dir)!
}).filter(Boolean)
}
const d = drag.value
if (d?.kind === 'move' && d.plug) return d.plug.rings.map(([x, y]) => ({ x, y }))
if (d?.kind !== 'move' || !d.snap || !d.still) return []
const moving = new Set(d.orig.keys())
return d.snap.links.map(l => {
const end = moving.has(l.from.node) ? { ...l.to, dir: 'in' } : { ...l.from, dir: 'out' }
return d.still!.find(p => p.node === end.node && p.pin === end.pin && p.dir === end.dir)!
}).filter(Boolean)
})
/** Green boxes over the runs of pins the selection fits onto; hidden while dragging, wiring or placing. */
const fitShown = computed(() => (drag.value || ed.linking.value || ed.placing.value || ed.cabling.value ? [] : ed.fits.value))
function pinAt(ref: PinRef, dir: 'in' | 'out'): Pt | null {
const n = nodeMap.value.get(ref.node)
const p = n && pinPos(n, shapes.value.get(n.id)!, ref.pin, dir)
return p ? [p.x, p.y] : null
}
/** The fit pointed at: its box and a line from each selected part to the pin it would get. */
const fitPreview = computed(() => {
const h = ed.fitHover.value
const spot = h && fitShown.value[h.spot]
if (!h || !spot) return null
const k = spot.mine.length
const pins = spot.pins.slice(h.start, h.start + k)
const lines = spot.mine.map((m, i) => {
const a = pinAt(m, spot.side === 'out' ? 'in' : 'out')
const b = pins[i]!
return a ? `M${a[0] * G} ${a[1] * G}L${b.x * G} ${b.y * G}` : ''
})
return { x: pins[0]!.x, y0: pins[0]!.y, y1: pins[k - 1]!.y, lines, pins }
})
function onFitMove(i: number, e: PointerEvent) {
const spot = fitShown.value[i]
if (spot) ed.fitHover.value = { spot: i, start: fitStart(spot, toWorld(e)[1]) }
}
const cursorStyle = computed(() => {
if (drag.value?.kind === 'pan') return 'grabbing'
if (spaceDown.value) return 'grab'
if (ed.placing.value) return 'copy'
if (ed.linking.value || ed.cabling.value) return 'crosshair'
return 'default'
})
defineExpose({ fit, zoomAt })
</script>
<template>
<div
ref="root"
class="canvas"
:style="{ cursor: cursorStyle }"
@pointerdown="onPointerDown"
@pointermove="onPointerMove"
@pointerup="onPointerUp"
@pointercancel="onPointerUp"
@pointerleave="cursor = null"
@wheel.prevent="onWheel"
@contextmenu.prevent
@dragover.prevent="onDragOver"
@dragleave="onDragLeave"
@drop.prevent="onDrop"
>
<svg width="100%" height="100%">
<defs>
<pattern id="grid-dots" :width="gridSize" :height="gridSize" patternUnits="userSpaceOnUse" :x="view.x" :y="view.y">
<circle :cx="0.75" :cy="0.75" :r="view.zoom > 0.5 ? 0.9 : 0.6" class="grid-dot" />
</pattern>
<pattern id="grid-major" :width="gridSize * 8" :height="gridSize * 8" patternUnits="userSpaceOnUse" :x="view.x" :y="view.y">
<circle :cx="0.75" :cy="0.75" r="1.4" class="grid-major" />
</pattern>
</defs>
<rect v-if="gridSize >= 5" width="100%" height="100%" fill="url(#grid-dots)" />
<rect v-if="gridSize * 8 >= 6" width="100%" height="100%" fill="url(#grid-major)" />
<g ref="content" :transform="`translate(${view.x} ${view.y}) scale(${view.zoom})`">
<g class="wires">
<g
v-for="r in routes"
:key="r.wire.id"
class="wire"
:class="[
r.wire.color ? `c-${r.wire.color}` : r.port?.color ? `c-${r.port.color}` : '',
{
on: srcVal(r.src) === 1,
'port-cable': !!r.port,
selected: wireSelected.has(r.wire.id),
hover: hoverSrc === r.src,
cable: !!r.bits,
'drop-target': dropWire === r.wire.id,
moving: movingWire === r.wire.id,
},
]"
>
<path v-if="wireSelected.has(r.wire.id)" :d="r.d" class="wire-halo" :style="r.sleeve ? { strokeWidth: `${r.sleeve + 9}px` } : undefined" />
<template v-if="r.port">
<!-- A cable between connector ports: one sleeve, named after its type -->
<path :d="r.d" class="cable-sleeve" :style="{ strokeWidth: `${r.sleeve! + 3}px` }" />
<path :d="r.d" class="cable-core" :style="{ strokeWidth: `${r.sleeve}px` }" />
</template>
<template v-else-if="r.lanes">
<!-- Ribbon cable: a sleeve in the cable's colour, one line per wire inside -->
<path :d="r.d" class="cable-sleeve" :style="{ strokeWidth: `${r.sleeve! + 3}px` }" />
<path :d="r.d" class="cable-core" :style="{ strokeWidth: `${r.sleeve}px` }" />
<path
v-for="l in r.lanes"
:key="l.i"
:d="l.d"
class="lane"
:class="[l.color ? `c-${l.color}` : '', { on: ed.val(r.wire.from.node, `b${l.i}`) === 1 }]"
/>
</template>
<template v-else>
<path :d="r.d" class="wire-line" />
<path v-if="flow && srcVal(r.src) === 1" :d="r.d" class="wire-flow" />
</template>
<path
v-for="(p, i) in r.pts.slice(0, -1)"
:key="i"
:d="`M${p[0] * G} ${p[1] * G}L${r.pts[i + 1]![0] * G} ${r.pts[i + 1]![1] * G}`"
class="wire-hit"
:class="{ vertical: p[0] === r.pts[i + 1]![0] }"
:style="r.sleeve ? { strokeWidth: `${Math.max(10, r.sleeve + 4)}px` } : undefined"
:data-wire="r.wire.id"
:data-seg="i"
@pointerenter="(hoverSrc = r.src), (hoverWire = r.wire.id)"
@pointerleave="(hoverSrc = null), (hoverWire = null)"
/>
<g v-if="r.bits && r.mark" class="cable-mark" :transform="`translate(${r.mark[0] * G} ${r.mark[1] * G})`">
<path :d="r.sleeve ? `M-4 ${r.sleeve / 2 + 3}L4 ${-r.sleeve / 2 - 3}` : 'M-4 6L4 -6'" />
<text x="6" :y="r.sleeve ? -r.sleeve / 2 - 4 : -6">{{ r.bits }}</text>
<text x="6" :y="r.sleeve ? r.sleeve / 2 + 11 : 14" class="cable-value">= {{ cableValue(r)?.dec }}</text>
</g>
<g v-if="r.port && r.mark" class="cable-mark port-mark" :transform="`translate(${r.mark[0] * G} ${r.mark[1] * G})`">
<text text-anchor="middle" :y="-r.sleeve! / 2 - 5">{{ r.port.name }}</text>
</g>
<title v-if="hoverWire === r.wire.id">{{ wireTip(r) }}</title>
</g>
<g v-for="(j, i) in junctions" :key="`j${i}`" class="wire" :class="[j.color ? `c-${j.color}` : '', { on: srcVal(j.src) === 1 }]">
<circle :cx="j.x * G" :cy="j.y * G" r="3.2" class="junction" :data-junction="j.src" />
</g>
</g>
<EditorNodeView
v-for="n in def.nodes"
:key="n.id"
:node="n"
:shape="shapes.get(n.id)!"
:selected="selected.has(n.id)"
:through="linked.out.has(`${n.id}:q`) && (n.kind === 'lamp' || n.kind === 'output')"
:hint="hints.get(n.id)"
:linked="!!signalSel && (n.kind === 'tag' || n.kind === 'ref') && n.label?.trim() === signalSel"
:open="openPins.get(n.id)"
/>
<circle
v-for="g in grips"
:key="`${g.wire}-${g.end}`"
:cx="g.x * G"
:cy="g.y * G"
r="4"
class="wire-grip"
:data-wire="g.wire"
:data-end="g.end"
@pointerenter="hoverWire = g.wire"
@pointerleave="hoverWire = null"
>
<title>Drag to move this end to another pin</title>
</circle>
<rect
v-for="h in handles"
:key="`${h.wire}-${h.i}`"
:x="h.x * G - 3.5"
:y="h.y * G - 3.5"
width="7"
height="7"
rx="1.5"
class="corner-handle"
:data-wire="h.wire"
:data-corner="h.i"
/>
<g v-if="fitShown.length" class="fits">
<rect
v-for="(f, i) in fitShown"
:key="`f${i}`"
:x="(f.pins[0]!.x - 0.45) * G"
:y="(f.pins[0]!.y - 0.5) * G"
:width="0.9 * G"
:height="(f.pins[f.pins.length - 1]!.y - f.pins[0]!.y + 1) * G"
rx="4"
class="fit-strip"
:class="{ active: ed.fitHover.value?.spot === i }"
:data-fit="i"
@pointermove="onFitMove(i, $event)"
@pointerleave="ed.fitHover.value = null"
/>
<template v-if="fitPreview">
<path v-for="(l, i) in fitPreview.lines" :key="`fl${i}`" :d="l" class="fit-line" />
<rect
:x="(fitPreview.x - 0.55) * G"
:y="(fitPreview.y0 - 0.55) * G"
:width="1.1 * G"
:height="(fitPreview.y1 - fitPreview.y0 + 1.1) * G"
rx="5"
class="fit-window"
/>
<circle v-for="(p, i) in fitPreview.pins" :key="`fp${i}`" :cx="p.x * G" :cy="p.y * G" r="4.5" class="fit-pin" />
</template>
</g>
<circle v-for="(p, i) in dropRings" :key="`d${i}`" :cx="p.x * G" :cy="p.y * G" r="7" class="drop-ring" />
<g
v-for="c in cableButtons"
:key="c.side"
class="cable-btn"
:data-cable="c.side"
:transform="`translate(${c.x * G} ${c.y * G})${c.side === 'in' ? ' scale(-1 1)' : ''}`"
>
<title>{{ c.side === 'out' ? 'Cable from these outputs' : 'Cable into these inputs' }}</title>
<circle r="9" />
<path d="M-4.5 -4.5L1.5 0M-4.5 0H1.5M-4.5 4.5L1.5 0M1.5 0H5" />
</g>
<g class="targets">
<circle v-for="(t, i) in targets" :key="`t${i}`" :cx="t.x * G" :cy="t.y * G" r="5.5" class="pin-target" :class="{ taken: !t.free }" />
</g>
<path v-if="tempWire" :d="tempWire.d" class="temp-wire" :class="{ snapped: tempWire.snapped }" />
<circle v-if="tempWire?.snapped" :cx="tempWire.end[0] * G" :cy="tempWire.end[1] * G" r="6.5" class="pin-snap" />
<g v-for="b in queueBadges" :key="`q${b.n}`" class="queue-badge" :class="{ current: b.current }">
<rect :x="b.x * G - 7" :y="b.y * G - 6" width="14" height="12" rx="3" />
<text :x="b.x * G" :y="b.y * G + 3.5" text-anchor="middle">{{ b.n }}</text>
</g>
<EditorNodeView v-if="ghost" :node="ghost" :shape="ed.shape(ghost)" :selected="false" ghost />
<template v-if="cableGhost">
<path v-if="cableGhost.line" :d="cableGhost.line" class="temp-wire" />
<EditorNodeView v-for="g in cableGhost.nodes" :key="g.id" :node="g" :shape="ed.shape(g)" :selected="false" ghost />
</template>
<rect v-if="boxRect" v-bind="boxRect" />
</g>
</svg>
<EditorQuickAdd v-if="quick" :x="quick.x" :y="quick.y" @pick="onQuickPick" @close="quick = null" />
<EditorContextMenu v-if="menu" :x="menu.x" :y="menu.y" :entries="menu.entries" :keyboard="menu.keyboard" @close="menu = null" />
<div v-if="!def.nodes.length" class="empty-hint">
<p class="font-semibold">Empty circuit</p>
<p>Drag parts in from the left, or press <kbd>N</kbd> for a NAND gate.</p>
</div>
<div class="zoom-controls" @pointerdown.stop>
<button title="Zoom out" @click="zoomAt(1 / 1.25)"><Icon name="lucide:minus" /></button>
<span class="tabular-nums">{{ Math.round(view.zoom * 100) }}%</span>
<button title="Zoom in" @click="zoomAt(1.25)"><Icon name="lucide:plus" /></button>
<button title="Fit to screen (F)" @click="fit"><Icon name="lucide:scan" /></button>
</div>
</div>
</template>