logigate/app/components/editor/Canvas.vue

1018 lines
39 KiB
Vue

<script setup lang="ts">
import { cableKeys } from '~/lib/logic/compile'
import { cableBits, GRID as G, pinPos, routeWire, type Pt, type Shape } from '~/lib/logic/geometry'
import type { CircuitNode, PanelRow, PinRef, Wire } from '~/lib/logic/types'
import { branchCorners, branchTo, moveCorner, moveSegment, routeTouchesBox, segmentDrag, splitDrag } from '~/lib/logic/wires'
import { circuitRoutes, findCrossings } from '~/lib/logic/routing'
import { seriesLinks } from '~/lib/logic/bulk'
import { LANE, ribbon } from '~/lib/logic/cables'
import { wirePath } from '~/lib/draw'
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
}
/** Cables with up to this many wires show each wire as its own line. */
const RIBBON_MAX = 16
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 route: Route = { wire, pts: r.grid, draw: r.draw, d: wirePath(r.draw, hops.get(k), style), src: r.net }
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.
let best = 0
for (let i = 0; i < r.draw.length - 1; i++) {
const [ax, ay] = r.draw[i]!
const [bx, by] = r.draw[i + 1]!
const len = Math.abs(bx - ax) + Math.abs(by - ay)
if (len > best) {
best = len
route.mark = [(ax + bx) / 2, (ay + by) / 2]
}
}
}
return route
})
})
const routeOf = (wire: Wire) => routes.value.find(r => r.wire === wire)
/** 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 }, at: Pt): Pt {
const b = ed.shape({ id: 'ghost', kind: p.kind, chip: p.chip, x: 0, y: 0 }).body
return [Math.round(at[0] - (b.x + b.w / 2)), Math.round(at[1] - (b.y + b.h / 2))]
}
const ghost = computed<CircuitNode | null>(() => {
const p = ed.placing.value
if (!p || !cursor.value) return null
const [x, y] = originFor(p, cursor.value)
return { id: 'ghost', kind: p.kind, chip: p.chip, x, y, label: p.kind === 'note' ? 'Note' : p.kind === 'input' ? '?' : undefined }
})
function onDrop(e: DragEvent) {
const raw = e.dataTransfer?.getData('application/x-logigate')
if (!raw) return
const p = JSON.parse(raw) as { kind: CircuitNode['kind']; chip?: string }
if (p.chip && !ed.canPlace(p.chip)) return ed.notify('A component cannot contain itself', 'error')
if (!ed.canPlaceKind(p.kind)) return
const [x, y] = originFor(p, toWorld(e))
ed.addNode(p, x, y)
}
// ── Pointer interaction ─────────────────────────────────────────────
type Drag =
| { kind: 'pan'; sx: number; sy: number; vx: number; vy: number }
| {
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
}
| { kind: 'wire'; node: string; pin: string; dir: 'in' | 'out'; start: Pt; cur: Pt; moved: boolean; branch?: Pt[] }
| { 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)) {
drag.value = { kind: 'pan', sx: e.clientX, sy: e.clientY, vx: v.x, vy: v.y }
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.isBus(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 [x, y] = originFor(placing, w)
ed.addNode(placing, x, y)
if (!e.shiftKey && !placing.keep) ed.placing.value = null
return
}
const target = e.target as Element
const pinEl = target.closest('[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,
}
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 = Number(el.getAttribute('data-seg'))
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
}
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) {
const w = toWorld(e)
cursor.value = w
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)
}
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
})
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 = false): 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 (!!p.bus !== 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 => !!p.bus === 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() {
const d = drag.value
drag.value = null
if (!d) return
switch (d.kind) {
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) {
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) {
// 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 target = targetAt(d.cur, d.dir === 'out' ? 'in' : 'out', ed.isBus(d.node, d.pin, d.dir))
if (!target) 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'].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
}
const mod = e.ctrlKey || e.metaKey
const key = e.key.toLowerCase()
// 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 === '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()
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.toggleSidebar('left')
else if (!mod && !e.altKey && e.key === ']') ed.toggleSidebar('right')
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.isBus(d.node, d.pin, d.dir))
let end: Pt = [Math.round(d.cur[0]), Math.round(d.cur[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]
}
const pts =
d.dir === 'out'
? routeWire([p.x, p.y], end, d.branch && branchTo(d.branch, [p.x, p.y], end))
: routeWire(end, [p.x, p.y])
return { d: toPath(pts), snapped: !!target, end }
})
/** 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.isBus(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 (!!p.bus !== 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)) }
})
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
@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 :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}` : '',
{ on: srcVal(r.src) === 1, selected: wireSelected.has(r.wire.id), hover: hoverSrc === r.src, cable: !!r.bits },
]"
>
<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.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"
@pointerleave="hoverSrc = 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>
</g>
</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)"
/>
<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 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>
<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>