994 lines
38 KiB
Vue
994 lines
38 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, 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.withDocked(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)
|
|
const wires = routes.value.filter(r => 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.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.withDocked(ed.selection.value)
|
|
if (!ids.size && !ed.wireSel.value.length) return
|
|
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 and buttons 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'))
|
|
if (bound.length) {
|
|
e.preventDefault()
|
|
if (!e.repeat) for (const n of bound) n.kind === 'input' ? ed.toggleInput(n) : ed.press(n, true)
|
|
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()
|
|
ed.startCable()
|
|
} 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)
|
|
}
|
|
|
|
// ── 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,
|
|
}
|
|
})
|
|
|
|
/** 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" class="box-select" />
|
|
</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>
|