logigate/app/components/editor/Canvas.vue

2052 lines
89 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 } 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, crossingPoints, planHops } 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 { cableInUse, LANE, plugLayout, ribbon, RIBBON_MAX } from '~/lib/logic/cables'
import { latchLayout, latchSeam } from '~/lib/logic/latch'
import { probeAt } from '~/lib/logic/probes'
import { keyCode } from '~/lib/logic/devices'
import { moveParts, moveStart, type MoveStart } from '~/lib/logic/move'
import { wirePath, type HopSpan } from '~/lib/draw'
import { downloadSheet, printSheet, sheetSvg } from '~/lib/sheet'
import { inputCount } from '~/lib/logic/wide'
import { pinName } from '~/lib/logic/labels'
import { lineForWire } from '~/lib/logic/ops'
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 }
/** It jumps over other lines somewhere. */
hops?: boolean
/** Each jump once more on its own, drawn on top of everything it crosses: the line, and a cable's lines. */
patches?: { d: string; lanes: { i: number; d: string; color?: string }[] }[]
}
/**
* Short pieces of a route around each of its jumps, from a little before to
* a little after, with the jump in them. Drawn over all other lines, a jump
* always lies on top of what it crosses, whatever order the lines are in.
*/
function jumpPieces(pts: Pt[], hops: Map<number, HopSpan[]> | undefined, style: Parameters<typeof wirePath>[2]): { seg: number; from: number; to: number; hop: HopSpan }[] {
const out: { seg: number; from: number; to: number; hop: HopSpan }[] = []
for (const [seg, list] of hops ?? []) {
const a = pts[seg]
const b = pts[seg + 1]
if (!a || !b || style === 'plain') continue
const axis = a[1] === b[1] ? 0 : 1
const lo = Math.min(a[axis], b[axis])
const hi = Math.max(a[axis], b[axis])
for (const hop of list) out.push({ seg, from: Math.max(lo, hop.lo - 0.3), to: Math.min(hi, hop.hi + 0.3), hop })
}
return out
}
/** One piece of a polyline's segment (or of a lane beside it), drawn with its jump. */
function piecePath(line: Pt[], p: { seg: number; from: number; to: number; hop: HopSpan }, style: Parameters<typeof wirePath>[2]): string {
const a = line[p.seg]!
const b = line[p.seg + 1]!
const axis = a[1] === b[1] ? 0 : 1
const forward = b[axis] > a[axis]
const at = (v: number): Pt => (axis === 0 ? [v, a[1]] : [a[0], v])
const [s, e] = forward ? [p.from, p.to] : [p.to, p.from]
return wirePath([at(s), at(e)], new Map([[0, [p.hop]]]), style)
}
/**
* Where a cable's label goes: the middle of the longest straight stretch
* that no other line crosses (keeping clear of the crossings on each side).
*/
function midOfLongest(draw: Pt[], busy: Pt[] = []): Pt | undefined {
const CLEAR = 1.5
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 axis = ay === by ? 0 : 1
const lo = Math.min(draw[i]![axis], draw[i + 1]![axis])
const hi = Math.max(draw[i]![axis], draw[i + 1]![axis])
const cuts = busy.filter(p => p[1 - axis] === draw[i]![1 - axis] && p[axis] > lo && p[axis] < hi).map(p => p[axis]).sort((p, q) => p - q)
// Stretches between the crossings, each kept clear of them.
const edges = [lo - CLEAR, ...cuts, hi + CLEAR]
for (let k = 0; k < edges.length - 1; k++) {
const from = Math.max(lo, edges[k]! + CLEAR)
const to = Math.min(hi, edges[k + 1]! - CLEAR)
if (to - from > best) {
best = to - from
const m = (from + to) / 2
at = axis === 0 ? [m, ay] : [ax, m]
}
}
}
return at ?? (draw.length > 1 ? [(draw[0]![0] + draw[1]![0]) / 2, (draw[0]![1] + draw[1]![1]) / 2] : undefined)
}
const toPath = (pts: Pt[]) => pts.map(([x, y], i) => `${i ? 'L' : 'M'}${x * G} ${y * G}`).join('')
/** How wide a wire is drawn, in pixels, when it is a cable: its sleeve with the outline. */
function cablePx(w: Wire | undefined): number | undefined {
const from = w && nodeMap.value.get(w.from.node)
if (!from) return
if (from.kind === 'bundle') {
const bits = cableBits(from)
return bits <= RIBBON_MAX ? bits * LANE * G + 6 : 8
}
const conn = shapes.value.get(from.id)?.outputs.find(p => p.key === w.from.pin)?.conn
if (conn) return Math.min(8, Math.max(2, ed.getDef.value.conn?.(conn)?.lines.length ?? 2)) * LANE * G + 6
}
/** Puts the parts of a move `dx`, `dy` squares from where they started, with their wires (cables as wide as drawn). */
function moveTo(start: MoveStart, dx: number, dy: number) {
const byId = new Map(def.value.wires.map(w => [w.id, w]))
moveParts(def.value, start, dx, dy, shapes.value, { widthOf: id => cablePx(byId.get(id)) })
}
const routes = computed<Route[]>(() => {
const byId = new Map(def.value.wires.map(w => [w.id, w]))
const routed = circuitRoutes(def.value, shapes.value, { tidy: !!ed.project.value.settings.tidy, widthOf: id => cablePx(byId.get(id)) })
const hops = planHops(routed)
const crossed = crossingPoints(routed)
const style = ed.project.value.settings.crossing ?? 'bow'
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) : '', hops: !!hops.get(k)?.size }
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.sleeve = Math.min(8, Math.max(2, type?.lines.length ?? 2)) * LANE * G + 3
route.mark = midOfLongest(r.draw, crossed.get(k))
}
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]))
const lanes = ribbon(r.draw, route.bits)
route.lanes = lanes.map((lane, i) => ({ i, d: wirePath(lane, hops.get(k), style), color: feed.get(`b${i}`) }))
route.patches = jumpPieces(r.draw, hops.get(k), style).map(p => ({
d: piecePath(r.draw, p, style),
lanes: lanes.map((lane, i) => ({ i, d: piecePath(lane, p, style), 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, crossed.get(k))
}
route.patches ??= jumpPieces(r.draw, hops.get(k), style).map(p => ({ d: piecePath(r.draw, p, style), lanes: [] }))
return route
})
})
const routeOf = (wire: Wire) => routes.value.find(r => r.wire === wire)
/** Classes of a wire's group: its colour, its signal's value, and how it is being used. */
function wireClass(r: Route) {
return [
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.value.has(r.wire.id),
hover: hoverSrc.value === r.src,
cable: !!r.bits,
'drop-target': dropWire.value === r.wire.id,
moving: movingWire.value === r.wire.id,
},
]
}
/**
* Sleeved cables, grouped by signal: each group is drawn outline first, then
* core, then lines, so cables of one signal that share a trunk merge into
* one cable that splits. Groups that hop over others come later, on top.
*/
const cableGroups = computed(() => {
const groups = new Map<string, Route[]>()
for (const r of routes.value) if (r.lanes || r.port) groups.set(r.src, [...(groups.get(r.src) ?? []), r])
const hopping = (g: Route[]) => (g.some(r => r.hops) ? 1 : 0)
return [...groups.values()].sort((a, b) => hopping(a) - hopping(b))
})
/** 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
}
// ── Buttons beside what is selected ─────────────────────────────────
/** A round button on the canvas next to the selection, for what is done most with it. */
interface ActionButton {
key: string
x: number
y: number
title: string
/** A lucide icon, or else the cable mark (mirrored with `flip`). */
icon?: string
flip?: boolean
run: (e: PointerEvent) => void
}
/** The cable that a cable end belongs to, when it has one (a bundle with a split behind it). */
function cableOfEnd(n: CircuitNode): CircuitNode | undefined {
const w = def.value.wires.find(x => (n.kind === 'bundle' ? x.from.node === n.id : x.to.node === n.id && x.to.pin === 'a'))
const bundle = w && nodeMap.value.get(w.from.node)
if (bundle?.kind !== 'bundle') return undefined
return def.value.wires.some(x => x.from.node === bundle.id && nodeMap.value.get(x.to.node)?.kind === 'split') ? bundle : undefined
}
/**
* Buttons beside a part: a cable onto its outputs and its inputs, and each
* connector port split into its wires or joined again. A cable end: plug in
* or out, take the cable apart.
*/
function nodeButtons(n: CircuitNode): ActionButton[] {
const out: ActionButton[] = []
const s = shapes.value.get(n.id)
if (!s) return out
const key = (k: string) => `${n.id}|${k}`
// Connector ports: beside the socket, out of the box.
for (const p of [...s.inputs, ...s.outputs]) {
if (!p.conn || n.kind !== 'chip') continue
const split = !!n.splitPorts?.includes(p.key)
out.push({
key: key(`port:${p.key}`),
x: n.x + p.dx + (p.dx === 0 ? -1.3 : 1.3),
y: n.y + p.dy,
title: split ? `Join the ${p.label} wires back into its socket` : `Split ${p.label} into wires`,
icon: split ? 'lucide:merge' : 'lucide:split',
run: () => ed.toggleSplit(n, p.key),
})
}
const choices = ed.cableChoices(n)
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 && p.face !== -1)
const ins = s.inputs.filter(p => !p.bus && p.face !== 1)
// Clear of a port's button on the same edge.
const clear = (x: number, y: number) => {
while (out.some(b => b.x === x && Math.abs(b.y - y) < 1.2)) y += 0.5
return y
}
if (choices.out.length && outs.length) {
const x = n.x + Math.max(...outs.map(p => p.dx)) + 1.3
out.push({ key: key('cable:out'), x, y: clear(x, n.y + mid(outs)), title: 'A cable plug on these outputs', run: e => onCableButton(n, 'out', e) })
}
if (choices.in.length && ins.length) {
const x = n.x + Math.min(...ins.map(p => p.dx)) - 1.3
out.push({ key: key('cable:in'), x, y: clear(x, n.y + mid(ins)), title: 'A cable plug on these inputs', flip: true, run: e => onCableButton(n, 'in', e) })
}
if (n.kind === 'bundle' || n.kind === 'split') {
// On the cable's side of the end, clear of its cable pin: pull a cable out, plug in or out, take the cable apart.
const x = n.kind === 'bundle' ? n.x + s.body.x + s.body.w + 1 : n.x + s.body.x - 1
const busY = n.y + (n.kind === 'bundle' ? s.outputs : s.inputs).find(p => p.bus)!.dy
// From its top row down, stepping over the cable pin's row.
let y = n.y + s.body.y + 0.5
for (const b of endActions(n)) {
if (Math.abs(y - busY) < 0.9) y = busY + 1
out.push({ ...b, key: key(b.key), x, y })
y += 1.2
}
}
return out
}
/** What can be done at a cable end: pull a cable out, plug in or out, take the cable apart. */
function endActions(n: CircuitNode): Omit<ActionButton, 'x' | 'y'>[] {
const ends: Omit<ActionButton, 'x' | 'y'>[] = []
const bus = n.kind === 'bundle' ? { pin: 'q', dir: 'out' as const } : { pin: 'a', dir: 'in' as const }
if (pullable({ node: n.id, ...bus }) && !linked.value[bus.dir].has(`${n.id}:${bus.pin}`)) {
ends.push({
key: 'pull',
title: 'Pull the cable out: click where its other end goes (or drag it out of its pin)',
icon: 'lucide:cable',
run: () => (ed.linking.value = { queue: [{ node: n.id, ...bus, label: '' }], at: 0 }),
})
}
if (n.plug) ends.push({ key: 'unplug', title: 'Unplug: it steps aside and its wires show again', icon: 'lucide:unplug', run: () => ed.unplugEnd(n) })
else if (ed.plugTarget(n)) ends.push({ key: 'plug', title: 'Plug straight onto the pins its wires run to', icon: 'lucide:plug', run: () => ed.plugEnd(n) })
const use = cableInUse(def.value, n.id)
if (use && use.after < use.before) {
ends.push({ key: 'trim', title: `Drop the ${use.before - use.after} unused wires (${use.before} → ${use.after})`, icon: 'lucide:scissors', run: () => ed.trimCableEnd(n.id) })
}
const cable = cableOfEnd(n)
if (cable) ends.push({ key: 'apart', title: 'Split the cable into single wires', icon: 'lucide:split', run: () => ed.removeCable(cable.id) })
return ends
}
/** Buttons beside picked pins: a cable plug on exactly them, or wire them one by one. */
function pickedButtons(): ActionButton[] {
const sel = ed.pinSel.value
const n = sel && nodeMap.value.get(sel.node)
const s = n && shapes.value.get(n.id)
if (!sel || !n || !s) return []
const pins = (sel.dir === 'out' ? s.outputs : s.inputs).filter(p => sel.pins.includes(p.key))
if (!pins.length) return []
const side = sel.dir === 'out' ? 1 : -1
const x = n.x + (side > 0 ? Math.max(...pins.map(p => p.dx)) : Math.min(...pins.map(p => p.dx))) + side * 1.3
const mid = n.y + (Math.min(...pins.map(p => p.dy)) + Math.max(...pins.map(p => p.dy))) / 2
const count = `${pins.length} ${sel.dir === 'out' ? 'output' : 'input'}${pins.length === 1 ? '' : 's'}`
const out: ActionButton[] = []
if (pins.length >= 2) out.push({ key: 'picked|cable', x, y: mid - 0.6, title: `A cable plug on these ${count}`, flip: side < 0, run: () => ed.cablePicked() })
out.push({ key: 'picked|link', x, y: out.length ? mid + 0.6 : mid, title: `Wire these ${count} one by one: click where each goes`, icon: 'lucide:cable', run: () => ed.linkPicked() })
return out
}
// ── A part pointed at shows its buttons too, as if it were selected ──
const hoverNode = ref<string | null>(null)
let hoverTimer: ReturnType<typeof setTimeout> | undefined
/** Pointing at a part (after a moment), or at one of its buttons, keeps them; leaving lets them go a moment later. */
let hoverNext: string | null | undefined
function trackHover(target: Element | null) {
// On one of the buttons: they stay.
if (target?.closest('[data-action]')) {
clearTimeout(hoverTimer)
hoverNext = undefined
return
}
const id = target?.closest('[data-node]')?.getAttribute('data-node') ?? null
if (id === hoverNode.value) {
clearTimeout(hoverTimer)
hoverNext = undefined
return
}
// Already on its way to this one: let it come (moving on must not keep putting it off).
if (hoverNext === id) return
clearTimeout(hoverTimer)
hoverNext = id
hoverTimer = setTimeout(
() => {
hoverNode.value = id
hoverNext = undefined
},
id ? 150 : 400,
)
}
/** While the view or a part is dragged, nothing is pointed at. */
function dropHover() {
clearTimeout(hoverTimer)
hoverNext = undefined
hoverNode.value = null
}
/**
* Buttons beside the selection, and beside a part pointed at. Picked pins:
* a cable on them, or wire them one by one. A cable: take it apart. Several
* wires: bundle them into a cable.
*/
const actionButtons = computed<ActionButton[]>(() => {
if (drag.value || ed.linking.value || ed.placing.value || ed.cabling.value) return []
const out: ActionButton[] = [...pickedButtons()]
const sel = ed.selection.value
const picked = sel.length === 1 && !ed.wireSel.value.length ? sel[0] : undefined
for (const id of new Set([picked, hoverNode.value])) {
const n = id ? nodeMap.value.get(id) : undefined
// With pins of it picked, the buttons for those pins stand in for its own.
if (n && n.id !== ed.pinSel.value?.node) out.push(...nodeButtons(n))
}
// Wires: a cable can be taken apart, several single wires bundled.
const wires = sel.length ? [] : routes.value.filter(r => wireSelected.value.has(r.wire.id))
// Above the middle of the topmost one.
const at = (rs: Route[]) => {
const ps = rs.map(r => midOfLongest(r.pts)).filter(p => !!p)
return ps.length ? { x: ps.reduce((a, p) => a + p[0], 0) / ps.length, y: Math.min(...ps.map(p => p[1])) - 1.2 } : null
}
const cable = wires.length === 1 && wires[0]!.bits ? nodeMap.value.get(wires[0]!.wire.from.node) : undefined
const singles = wires.filter(r => !r.bits)
const spot = at(wires)
if (cable && spot) out.push({ key: 'apart', ...spot, title: 'Split the cable into single wires', icon: 'lucide:split', run: () => ed.removeCable(cable.id) })
else if (singles.length >= 2 && singles.length === wires.length && spot) {
out.push({ key: 'bundle', ...spot, title: `Bundle the ${singles.length} wires into a cable (Ctrl+G)`, run: () => ed.bundleSelected(singles.map(r => r.wire.id)) })
}
return out
})
/** A cable button: with one way to do it, it is done; with several, they are offered. */
function onCableButton(n: CircuitNode, side: 'out' | 'in', e: PointerEvent) {
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' ? 'Plug on outputs' : 'Plug on 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
/** Where the moving parts and the corners were: every step moves from there. */
orig: MoveStart
/** Squares moved so far. */
at: 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 (at `at`). */
plug?: { part: string; rings: Pt[]; at: 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)
/** Space pressed and let go quickly, without moving the view: opens the search box at the mouse. */
let spaceTap: { at: number } | null = null
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
}
function onPointerDown(e: PointerEvent) {
const w = toWorld(e)
const v = view.value
if (e.button === 1 || e.button === 2 || (e.button === 0 && spaceDown.value)) {
spaceTap = null
menu.value = null
dropHover()
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)
// A click anywhere but the keyboard being typed into stops the typing.
if (ed.typingInto.value && (e.target as Element).closest?.('[data-node]')?.getAttribute('data-node') !== ed.typingInto.value) ed.typeInto(null)
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 (on a port's socket, to one of its lines).
const socket = socketAt({ ...end, cur: w })
const target = socket ? ed.lineAt(end.dir, socket.node, socket.port) : targetAt(w, end.dir === 'out' ? 'in' : 'out', ed.pinKind(end.node, end.pin, end.dir))
if (target) return ed.linkTo(target, e.shiftKey)
// A cable pulled out of a cable end: its other end goes where the click is.
const pulled = link.queue.length === 1 ? pullEnd({ ...end, cur: w }) : null
if (pulled) {
ed.stopLinking()
return ed.pullCable(end.node, pulled.x, pulled.y, pulled.links)
}
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 actionEl = target.closest('[data-action]')
if (actionEl) return actionButtons.value.find(b => b.key === actionEl.getAttribute('data-action'))?.run(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 && ed.canInvert(n, pinEl.getAttribute('data-pin')!)) return ed.toggleInvert(n, pinEl.getAttribute('data-pin')!)
}
if (pinEl && e.shiftKey) {
// Shift + click on a pin: in or out of the picked pins.
ed.pickPin(pinEl.getAttribute('data-node')!, pinEl.getAttribute('data-dir') as 'in' | 'out', pinEl.getAttribute('data-pin')!)
return
}
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])
drag.value = {
kind: 'move',
start: w,
orig: moveStart(def.value, ids, ed.wireSel.value),
at: [0, 0],
moved: false,
node,
toggle: (node.kind === 'input' || node.kind === 'keyboard' || !!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 trackHover(e.target as Element)
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.nodes.has(n.id))
d.still = dropPins(def.value, def.value.nodes.filter(n => !d.orig.nodes.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: p.y + dy }))
d.snap = e.altKey ? null : dropLinks(at, d.still, d.grabbed === 1 ? 1 : 0)
}
if (dx !== d.at[0] || dy !== d.at[1]) {
d.at = [dx, dy]
moveTo(d.orig, dx, dy)
}
d.plug = d.moved && d.grabbed === 1 && !e.altKey ? plugNear(d.node) : null
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.
// Around pins of one part, all inputs or all outputs, and not over its middle: those pins.
const pinsIn = allPins.value.filter(p => !p.bus && p.x > x0 && p.x < x1 && p.y > y0 && p.y < y1)
const owner = pinsIn[0]?.node
const host = owner ? nodeMap.value.get(owner) : undefined
if (host && pinsIn.every(p => p.node === owner && p.dir === pinsIn[0]!.dir) && nodes.every(id => id === owner)) {
const b = shapes.value.get(owner!)!.body
const cx = host.x + b.x + b.w / 2
const cy = host.y + b.y + b.h / 2
if (!(cx > x0 && cx < x1 && cy > y0 && cy < y1)) {
ed.pickPins(owner!, pinsIn[0]!.dir, pinsIn.map(p => p.pin))
break
}
}
if (ed.pinSel.value) ed.pinSel.value = null
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
// A line of a split port is fed by the cable when one is in its socket.
const cabled = (port: string) => linked.value.in.has(`${n.id}:${port}`) || linked.value.out.has(`${n.id}:${port}`)
const open = shapes.value.get(n.id)!.inputs.filter(p => !p.bus && !(p.port && cabled(p.port)) && !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
}
/** The cable pin of a cable end that a cable can be pulled out of: a bundle's always, a split's while it has no cable. */
function pullable(d: { node: string; pin: string; dir: 'in' | 'out' }): CircuitNode | undefined {
const n = nodeMap.value.get(d.node)
if (!n || ed.pinKind(d.node, d.pin, d.dir) !== 'bus') return undefined
if (n.kind === 'bundle' || (n.kind === 'split' && !linked.value.in.has(`${n.id}:a`))) return n
return undefined
}
/**
* Where the other end of a cable pulled out of a cable end goes when let
* go at `cur`: over a part's pins (or its body), its wires land on them
* from the pin under the mouse on; elsewhere its cable pin is at the mouse.
*/
function pullEnd(d: { node: string; pin: string; dir: 'in' | 'out'; cur: Pt }): { x: number; y: number; links: Link[] } | null {
const from = pullable(d)
if (!from) return null
const end: CircuitNode = { id: 'ghost', kind: from.kind === 'bundle' ? 'split' : 'bundle', bits: cableBits(from), x: 0, y: 0 }
const s = ed.shape(end)
const wires = end.kind === 'split' ? s.outputs : s.inputs
const pin = targetAt(d.cur, end.kind === 'split' ? 'in' : 'out')
const host = pin && nodeMap.value.get(pin.node)
const at = host && pinPos(host, shapes.value.get(host.id)!, pin.pin, end.kind === 'split' ? 'in' : 'out')
if (at) {
end.x = at.x - wires[0]!.dx
end.y = at.y - wires[0]!.dy
const links = (dropLinks(dropPins(def.value, [end], () => s), allPins.value, 0)?.links ?? []).filter(l => [l.from, l.to].some(r => r.node === 'ghost' && r.pin !== 'a' && r.pin !== 'q'))
if (links.length) return { x: end.x, y: end.y, links }
}
const bus = end.kind === 'split' ? s.inputs[0]! : s.outputs[0]!
return { x: Math.round(d.cur[0]) - bus.dx, y: Math.round(d.cur[1]) - bus.dy, links: [] }
}
/**
* 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 }
}
/**
* Port sockets on components' boxes, not split yet, that a single wire can
* go onto (the port then splits into its lines): with a free line going in,
* for a wire from an output, or a line coming out, for a wire to an input.
*/
const openSockets = computed(() => {
const out: Record<'in' | 'out', { node: string; port: string; x: number; y: number; face: 1 | -1 }[]> = { in: [], out: [] }
for (const n of def.value.nodes) {
if (n.kind !== 'chip') continue
const s = shapes.value.get(n.id)!
for (const p of [...s.inputs, ...s.outputs]) {
if (!p.conn || n.splitPorts?.includes(p.key)) continue
const at = { node: n.id, port: p.key, x: n.x + p.dx, y: n.y + p.dy, face: p.dx > 0 ? (1 as const) : (-1 as const) }
if (lineForWire(ed.project.value, def.value, n.id, p.key, true)) out.in.push(at)
if (lineForWire(ed.project.value, def.value, n.id, p.key, false)) out.out.push(at)
}
}
return out
})
/** The socket a single wire being drawn from this pin is dropped on, if any. */
function socketAt(d: { node: string; pin: string; dir: 'in' | 'out'; cur: Pt }) {
if (ed.isBus(d.node, d.pin, d.dir)) return undefined
return openSockets.value[d.dir === 'out' ? 'in' : 'out'].find(s => Math.abs(s.x - d.cur[0]) <= 0.5 && Math.abs(s.y - d.cur[1]) <= 0.5)
}
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) {
// Onto the pins it plugs into, its wires settled there as for any move.
const [ox, oy] = d.orig.nodes.get(d.node.id)!
moveTo(d.orig, d.plug.at[0] - ox, d.plug.at[1] - oy)
ed.unplugMoved(new Set(d.orig.nodes.keys()))
if (d.node.kind === 'bundle' || d.node.kind === 'split') ed.plugEnd(d.node)
else ed.latchPart(d.node)
} else if (d.moved && d.snap?.links.length) {
const [sx, sy] = d.snap.shift
moveTo(d.orig, d.at[0] + sx, d.at[1] + sy)
ed.unplugMoved(new Set(d.orig.nodes.keys()))
ed.connectMany(d.snap.links)
ed.commit(false)
} else if (d.moved) {
ed.unplugMoved(new Set(d.orig.nodes.keys()))
ed.commit(false)
} else if (d.toggle && d.row) ed.toggleRow(d.node, d.row)
else if (d.toggle && d.node.kind === 'keyboard') ed.typeInto(d.node.id)
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
}
// A single wire dropped on a port's socket: the port splits and the wire takes one of its lines.
const socket = d.replace ? undefined : socketAt(d)
if (socket) {
const line = ed.lineAt(d.dir, socket.node, socket.port)
if (line) ed.connect(d.dir === 'out' ? here : line, d.dir === 'out' ? line : here)
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 && !d.replace && !d.branch) {
// A cable pulled out of a cable end: its other end goes where it is let go.
const end = pullEnd(d)
if (end) ed.pullCable(d.node, end.x, end.y, end.links)
break
}
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)
// Let go with Shift: go on from the output it now comes from.
if (e.shiftKey) ed.linking.value = { queue: [{ ...target, dir: 'out', label: '' }], at: 0 }
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)
// Let go with Shift: the wire goes on from the same output, for another connection.
if (e.shiftKey) ed.linking.value = { queue: [{ ...here, dir: 'out', label: '' }], at: 0 }
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) {
// Zooming moves everything under the pointer: what it points at is found again when it moves.
dropHover()
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
// A wire moved on its own keeps the shape it has.
for (const r of routes.value) {
if (wireSelected.value.has(r.wire.id) && !r.wire.pts && !ids.has(r.wire.from.node) && !ids.has(r.wire.to.node)) r.wire.pts = r.pts.slice(1, -1)
}
moveTo(moveStart(def.value, ids, ed.wireSel.value), dx, dy)
ed.unplugMoved(ids)
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
// Typing into a keyboard: the keys go there (Esc stops).
if (ed.typingInto.value) {
if (e.key === 'Escape') return ed.typeInto(null)
const code = keyCode(e)
if (code !== null) {
e.preventDefault()
return ed.typeKey(code)
}
}
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 && !ed.pinSel.value) 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()
if (!e.repeat) spaceTap = { at: performance.now() }
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
// A tap, not a hold for moving the view: the search box with recent parts and actions.
if (spaceTap && performance.now() - spaceTap.at < 350 && !quick.value) openQuickAdd()
spaceTap = null
}
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'
// Over a port's socket the wire ends there, as it does when let go (the port splits into its lines).
const socket = drag.value?.kind === 'wire' && drag.value.replace ? undefined : socketAt(d)
const target = socket ? null : 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 (socket) {
end = [socket.x, socket.y]
endFace = socket.face
} else 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: !!(socket || 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}`) })
}
}
// A single wire can go onto a port's socket too: the port splits into its lines.
if (!bus) for (const s of openSockets.value[want]) out.push({ x: s.x, y: s.y, free: true })
// A cable pulled out of a cable end can also be let go on free single pins: its other end lands on them.
if (pullable(d)) {
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) && (want === 'out' || !taken.has(`${n.id}:${p.key}`))) out.push({ x: n.x + p.dx, y: n.y + p.dy, free: true })
}
}
}
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')
// On a picked pin the picked pins stay picked (selecting the part would put them down).
const onPicked = !!ed.pinSel.value && ed.pinSel.value.node === nodeId && ed.pinSel.value.pins.includes(target.closest('[data-pin]')?.getAttribute('data-pin') ?? '')
if (nodeId && nodeMap.value.has(nodeId)) {
if (!selected.value.has(nodeId) && !onPicked) {
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 pinEl = target.closest('[data-pin]')
const pin = pinEl?.getAttribute('data-pin')
const dir = pinEl?.getAttribute('data-dir') as 'in' | 'out' | undefined
const n = nodeId ? nodeMap.value.get(nodeId) : undefined
const here: MenuEntry[] = []
if (pin && dir && n) {
const shape = shapes.value.get(n.id)!
const p = (dir === 'in' ? shape.inputs : shape.outputs).find(x => x.key === pin)
// A cable socket on a component: split it into its wires right here, or join them.
if (p?.conn && n.kind === 'chip') {
const split = !!n.splitPorts?.includes(pin)
here.push({ label: split ? `Join the ${p.label} wires` : `Split ${p.label} into wires here`, icon: split ? 'lucide:merge' : 'lucide:split', run: () => ed.toggleSplit(n, pin) })
}
// A cable end's cable pin: pull the cable out right here (plugging and taking apart are in the end's own menu below).
if (p?.bus && (n.kind === 'bundle' || n.kind === 'split')) {
const pull = endActions(n).find(x => x.key === 'pull')
if (pull) here.push({ label: 'Pull the cable out', icon: pull.icon, run: () => pull.run(new PointerEvent('pointerdown')) })
}
const probe = p && !p.port ? probeAt(def.value, n, pin, dir, ed.getDef.value) : null
if (probe) here.push({ label: 'Watch in analyzer', icon: 'lucide:activity', run: () => ed.watchSignal(probe) })
if (dir === 'in' && ed.canInvert(n, pin)) {
const on = n.invert?.includes(pin)
here.push({ label: on ? 'Take the bubble off this input' : 'Invert this input', icon: 'lucide:circle-dot', keys: 'Alt+click', run: () => ed.toggleInvert(n, pin) })
}
}
// Picked pins (right-clicked on one of them): what can be done with all of them.
const sel = ed.pinSel.value
if (sel && n && sel.node === n.id && (!pin || sel.pins.includes(pin))) {
const count = `${sel.pins.length} ${sel.dir === 'out' ? 'output' : 'input'}${sel.pins.length === 1 ? '' : 's'}`
here.unshift(
{ head: `${count} picked` },
...(sel.pins.length >= 2 ? [{ label: 'A cable plug on them', icon: sel.dir === 'out' ? 'lucide:merge' : 'lucide:split', run: () => ed.cablePicked() }] : []),
{ label: 'Wire them one by one', icon: 'lucide:cable', run: () => ed.linkPicked() },
...(sel.dir === 'in' ? [{ label: 'Invert them', icon: 'lucide:circle-dot', run: () => ed.invertPicked() }] : []),
{ label: 'Remove their wires', icon: 'lucide:unlink', danger: true, run: () => ed.unwirePicked() },
)
}
if (here.length) entries.unshift(...here, '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. Any other part brought as
* close to where it would latch onto the part it is wired to: the pins it
* would latch onto.
*/
function plugNear(n: CircuitNode): { part: string; rings: Pt[]; at: Pt } | null {
if (n.kind !== 'bundle' && n.kind !== 'split') {
const host = ed.latchTargetOf({ ...n, latch: undefined })
const lay = host && latchLayout(def.value, n, host, ed.getDef.value)
// Not onto a part that is latched onto this one (it moves along anyway).
if (!host || !lay || ed.withFollowers([n.id]).has(host.id) || Math.hypot(n.x - lay.x, n.y - lay.y) > 1.6) return null
const s = shapes.value.get(n.id)!
const shared = def.value.wires.filter(w => (w.from.node === host.id && w.to.node === n.id) || (w.from.node === n.id && w.to.node === host.id))
const rings = shared
.map(w => (w.to.node === n.id ? s.inputs.find(p => p.key === w.to.pin) : s.outputs.find(p => p.key === w.from.pin)))
.filter(p => !!p)
.map(p => [lay.x + p.dx, lay.y + p.dy] as Pt)
return { part: host.id, rings, at: [lay.x, lay.y] }
}
if (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), at: [lay.x, lay.y] }
}
/** Where latched parts touch their part: a contact strip along the joint, held by a clamp at each end. */
const latchMarks = computed(() =>
def.value.nodes.flatMap(n => {
const seam = n.latch ? latchSeam(def.value, n, ed.getDef.value) : null
return seam ? [{ id: n.id, x: n.x + seam.x, y0: n.y + seam.y0, y1: n.y + seam.y1 }] : []
}),
)
/** The picked pins, where they are. */
const pickedPins = computed(() => {
const sel = ed.pinSel.value
if (!sel) return []
const keep = new Set(sel.pins)
return allPins.value.filter(p => p.node === sel.node && p.dir === sel.dir && keep.has(p.pin))
})
/** 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.nodes.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), trackHover(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">
<!-- Cables (ribbons, and cables between connector ports): a sleeve, a core, a line per wire -->
<template v-for="grp in cableGroups" :key="grp[0]!.src">
<g v-for="r in grp" :key="`h${r.wire.id}`" class="wire" :class="wireClass(r)">
<path v-if="wireSelected.has(r.wire.id)" :d="r.d" class="wire-halo" :style="{ strokeWidth: `${r.sleeve! + 9}px` }" />
<path :d="r.d" class="cable-sleeve" :style="{ strokeWidth: `${r.sleeve! + 3}px` }" />
</g>
<g v-for="r in grp" :key="`c${r.wire.id}`" class="wire" :class="wireClass(r)">
<path :d="r.d" class="cable-core" :style="{ strokeWidth: `${r.sleeve}px` }" />
</g>
<g v-for="r in grp" :key="`l${r.wire.id}`" class="wire" :class="wireClass(r)">
<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 }]"
/>
</g>
</template>
<g v-for="r in routes" :key="r.wire.id" class="wire" :class="wireClass(r)">
<template v-if="!r.port && !r.lanes">
<path v-if="wireSelected.has(r.wire.id)" :d="r.d" class="wire-halo" :style="r.sleeve ? { strokeWidth: `${r.sleeve + 9}px` } : undefined" />
<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>
<!-- Jumps once more on top: a line always lies over what it jumps -->
<template v-for="r in routes" :key="`p${r.wire.id}`">
<g v-if="r.patches?.length" class="wire jump" :class="wireClass(r)">
<template v-for="(p, n) in r.patches" :key="n">
<template v-if="r.lanes || r.port">
<path :d="p.d" class="cable-sleeve" :style="{ strokeWidth: `${r.sleeve! + 3}px` }" />
<path :d="p.d" class="cable-core" :style="{ strokeWidth: `${r.sleeve}px` }" />
<path
v-for="l in p.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>
<path v-else :d="p.d" class="wire-line" />
</template>
</g>
</template>
<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)"
/>
<g v-for="m in latchMarks" :key="`latch-${m.id}`" class="part-latch">
<path :d="`M${m.x * G} ${(m.y0 - 0.35) * G}V${(m.y1 + 0.35) * G}`" class="contact" />
<rect :x="m.x * G - 0.3 * G" :y="(m.y0 - 0.5) * G - 3" :width="0.6 * G" :height="5" rx="1.5" />
<rect :x="m.x * G - 0.3 * G" :y="(m.y1 + 0.5) * G - 2" :width="0.6 * G" :height="5" rx="1.5" />
</g>
<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" />
<circle v-for="p in pickedPins" :key="`pk${p.pin}`" :cx="p.x * G" :cy="p.y * G" r="6.5" class="picked-pin" />
<g
v-for="b in actionButtons"
:key="b.key"
class="cable-btn"
:data-action="b.key"
:transform="`translate(${b.x * G} ${b.y * G})${b.flip ? ' scale(-1 1)' : ''}`"
>
<title>{{ b.title }}</title>
<circle r="9" />
<foreignObject v-if="b.icon" x="-6" y="-6" width="12" height="12"><Icon :name="b.icon" class="cable-btn-icon" /></foreignObject>
<path v-else 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" @fit="fit" @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>