diff --git a/src/components/graph/GraphCanvas.test.ts b/src/components/graph/GraphCanvas.test.ts index b498fd32f5a..7c872a40998 100644 --- a/src/components/graph/GraphCanvas.test.ts +++ b/src/components/graph/GraphCanvas.test.ts @@ -73,7 +73,10 @@ vi.mock('@/scripts/app', () => { graph: null, onSelectionChange: null, setDirty: mocks.setDirty, - canvas: document.createElement('canvas') + canvas: document.createElement('canvas'), + // useSubgraphDragBridge wires listeners onto this the moment the store's + // canvas ref resolves; without it, mounting GraphCanvas throws. + linkConnector: { events: new EventTarget(), state: {} } } return { app: { diff --git a/src/components/graph/GraphCanvas.vue b/src/components/graph/GraphCanvas.vue index 967b8f00f32..e70cbb9f90a 100644 --- a/src/components/graph/GraphCanvas.vue +++ b/src/components/graph/GraphCanvas.vue @@ -185,6 +185,7 @@ import { useWorkflowAutoSave } from '@/platform/workflow/persistence/composables import { useWorkflowPersistenceV2 as useWorkflowPersistence } from '@/platform/workflow/persistence/composables/useWorkflowPersistenceV2' import { useNodeDataStore } from '@/stores/nodeDataStore' import { useCanvasStore } from '@/renderer/core/canvas/canvasStore' +import { useSubgraphDragBridge } from '@/renderer/core/canvas/links/useSubgraphDragBridge' import { useCanvasInteractions } from '@/renderer/core/canvas/useCanvasInteractions' import { arrangeForLegacyRender } from '@/renderer/core/canvas/litegraph/arrangeForLegacyRender' import { notifyLayoutChanges } from '@/renderer/core/canvas/litegraph/notifyLayoutChanges' @@ -487,6 +488,7 @@ useGroupContextMenu() useCopy() usePaste() useWorkflowAutoSave() +useSubgraphDragBridge() // Start watching for locale change after the initial value is loaded. watch( diff --git a/src/lib/litegraph/src/canvas/LinkConnector.ts b/src/lib/litegraph/src/canvas/LinkConnector.ts index e04e9de202a..976b42e6b90 100644 --- a/src/lib/litegraph/src/canvas/LinkConnector.ts +++ b/src/lib/litegraph/src/canvas/LinkConnector.ts @@ -489,6 +489,7 @@ export class LinkConnector { this.state.connectingTo = 'input' this._setLegacyLinks(false) + this.events.dispatch('connecting', { connectingTo: 'input' }) } dragNewFromSubgraphOutput( @@ -513,6 +514,7 @@ export class LinkConnector { this.state.connectingTo = 'output' this._setLegacyLinks(true) + this.events.dispatch('connecting', { connectingTo: 'output' }) } /** @@ -948,7 +950,10 @@ export class LinkConnector { (link: RenderLink) => !!link.disconnectOnDrop ).forEach((link) => (link as { disconnect(): void }).disconnect()) if (this.renderLinks.length === 0) return - // For external event only. + + const intercepted = this.events.dispatch('before-drop-on-canvas', event) + if (intercepted === false) return + const mayContinue = this.events.dispatch('dropped-on-canvas', event) if (mayContinue === false) return diff --git a/src/lib/litegraph/src/canvas/LinkConnectorDropEvents.test.ts b/src/lib/litegraph/src/canvas/LinkConnectorDropEvents.test.ts new file mode 100644 index 00000000000..4df83b66b77 --- /dev/null +++ b/src/lib/litegraph/src/canvas/LinkConnectorDropEvents.test.ts @@ -0,0 +1,86 @@ +import { beforeEach, describe, expect, test, vi } from 'vitest' + +import { LinkConnector } from '@/lib/litegraph/src/litegraph' +import { + createMockCanvasPointerEvent, + createMockLGraphNode, + createMockLinkNetwork, + createMockNodeOutputSlot +} from '@/utils/__tests__/litegraphTestUtils' + +const mockSetConnectingLinks = vi.fn() + +type RenderLinkItem = LinkConnector['renderLinks'][number] + +function createMockRenderLink(): RenderLinkItem { + const partial: Partial = { + toType: 'input', + fromPos: [0, 0], + fromSlotIndex: 0, + fromDirection: 0, + network: createMockLinkNetwork(), + node: createMockLGraphNode(), + fromSlot: createMockNodeOutputSlot(), + dragDirection: 0, + canConnectToInput: vi.fn().mockReturnValue(false), + canConnectToOutput: vi.fn().mockReturnValue(false), + canConnectToReroute: vi.fn().mockReturnValue(false), + connectToInput: vi.fn(), + connectToOutput: vi.fn(), + connectToSubgraphInput: vi.fn(), + connectToRerouteOutput: vi.fn(), + connectToSubgraphOutput: vi.fn(), + connectToRerouteInput: vi.fn() + } + return partial as RenderLinkItem +} + +describe('LinkConnector.dropOnNothing event dispatch', () => { + let connector: LinkConnector + + beforeEach(() => { + connector = new LinkConnector(mockSetConnectingLinks) + }) + + test('dispatches before-drop-on-canvas before dropped-on-canvas', () => { + connector.renderLinks.push(createMockRenderLink()) + + const callOrder: string[] = [] + connector.events.addEventListener('before-drop-on-canvas', () => { + callOrder.push('before-drop-on-canvas') + }) + connector.events.addEventListener('dropped-on-canvas', () => { + callOrder.push('dropped-on-canvas') + }) + + connector.dropOnNothing(createMockCanvasPointerEvent(100, 100)) + + expect(callOrder).toEqual(['before-drop-on-canvas', 'dropped-on-canvas']) + }) + + test('skips dropped-on-canvas when before-drop-on-canvas is intercepted', () => { + connector.renderLinks.push(createMockRenderLink()) + + const droppedListener = vi.fn() + connector.events.addEventListener('before-drop-on-canvas', (e) => { + e.preventDefault() + }) + connector.events.addEventListener('dropped-on-canvas', droppedListener) + + connector.dropOnNothing(createMockCanvasPointerEvent(100, 100)) + + expect(droppedListener).not.toHaveBeenCalled() + }) + + test('does not dispatch events when renderLinks is empty', () => { + const beforeListener = vi.fn() + const droppedListener = vi.fn() + connector.events.addEventListener('before-drop-on-canvas', beforeListener) + connector.events.addEventListener('dropped-on-canvas', droppedListener) + + connector.dropOnNothing(createMockCanvasPointerEvent(100, 100)) + + expect(beforeListener).not.toHaveBeenCalled() + expect(droppedListener).not.toHaveBeenCalled() + }) +}) diff --git a/src/lib/litegraph/src/infrastructure/LinkConnectorEventMap.ts b/src/lib/litegraph/src/infrastructure/LinkConnectorEventMap.ts index 837c131dedc..cc87bdd20b1 100644 --- a/src/lib/litegraph/src/infrastructure/LinkConnectorEventMap.ts +++ b/src/lib/litegraph/src/infrastructure/LinkConnectorEventMap.ts @@ -15,6 +15,10 @@ import type { IWidget } from '@/lib/litegraph/src/types/widgets' export interface LinkConnectorEventMap { reset: boolean + connecting: { + connectingTo: 'input' | 'output' + } + 'before-drop-links': { renderLinks: RenderLink[] event: CanvasPointerEvent @@ -44,6 +48,7 @@ export interface LinkConnectorEventMap { node: SubgraphInputNode | SubgraphOutputNode event: CanvasPointerEvent } + 'before-drop-on-canvas': CanvasPointerEvent 'dropped-on-canvas': CanvasPointerEvent 'dropped-on-widget': { diff --git a/src/lib/litegraph/src/subgraph/SubgraphIOSlotLinks.test.ts b/src/lib/litegraph/src/subgraph/SubgraphIOSlotLinks.test.ts new file mode 100644 index 00000000000..a52c80b9918 --- /dev/null +++ b/src/lib/litegraph/src/subgraph/SubgraphIOSlotLinks.test.ts @@ -0,0 +1,100 @@ +import { describe, expect, vi } from 'vitest' + +import { LGraphNode } from '@/lib/litegraph/src/litegraph' +import { NodeSlotType } from '@/lib/litegraph/src/types/globalEnums' + +import { subgraphTest } from './__fixtures__/subgraphFixtures' + +describe('SubgraphInput.connect triggers node:slot-links:changed', () => { + subgraphTest( + 'fires connected event when connecting to a widget input', + ({ simpleSubgraph }) => { + const subgraph = simpleSubgraph + const triggerSpy = vi.spyOn(subgraph, 'trigger') + + const node = new LGraphNode('Target') + node.addInput('prompt', 'STRING') + node.inputs[0].widget = { name: 'prompt' } + subgraph.add(node) + + subgraph.inputNode.slots[0].connect(node.inputs[0], node) + + expect(triggerSpy).toHaveBeenCalledWith('node:slot-links:changed', { + nodeId: node.id, + slotType: NodeSlotType.INPUT, + slotIndex: 0, + connected: true, + linkId: expect.any(Number) + }) + } + ) + + subgraphTest( + 'does not fire event when connecting to a non-widget input', + ({ simpleSubgraph }) => { + const subgraph = simpleSubgraph + const triggerSpy = vi.spyOn(subgraph, 'trigger') + + const node = new LGraphNode('Target') + node.addInput('in', 'number') + subgraph.add(node) + + subgraph.inputNode.slots[0].connect(node.inputs[0], node) + + expect(triggerSpy.mock.calls.map((c) => c[0])).not.toContain( + 'node:slot-links:changed' + ) + } + ) +}) + +describe('SubgraphInputNode._disconnectNodeInput triggers node:slot-links:changed', () => { + subgraphTest( + 'fires disconnected event when disconnecting a widget input', + ({ simpleSubgraph }) => { + const subgraph = simpleSubgraph + + const node = new LGraphNode('Target') + node.addInput('prompt', 'STRING') + node.inputs[0].widget = { name: 'prompt' } + subgraph.add(node) + + const link = subgraph.inputNode.slots[0].connect(node.inputs[0], node) + expect(link).toBeDefined() + + const triggerSpy = vi.spyOn(subgraph, 'trigger') + + subgraph.inputNode._disconnectNodeInput(node, node.inputs[0], link!) + + expect(triggerSpy).toHaveBeenCalledWith('node:slot-links:changed', { + nodeId: node.id, + slotType: NodeSlotType.INPUT, + slotIndex: 0, + connected: false, + linkId: link!.id + }) + } + ) + + subgraphTest( + 'does not fire event when disconnecting a non-widget input', + ({ simpleSubgraph }) => { + const subgraph = simpleSubgraph + + const node = new LGraphNode('Target') + node.addInput('in', 'number') + subgraph.add(node) + + const link = subgraph.inputNode.slots[0].connect(node.inputs[0], node) + expect(link).toBeDefined() + + const triggerSpy = vi.spyOn(subgraph, 'trigger') + + subgraph.inputNode._disconnectNodeInput(node, node.inputs[0], link!) + + expect(triggerSpy.mock.calls.map((c) => c[0])).not.toContain( + 'node:slot-links:changed' + ) + } + ) +}) diff --git a/src/lib/litegraph/src/subgraph/SubgraphInput.ts b/src/lib/litegraph/src/subgraph/SubgraphInput.ts index e5c7f97673f..9b80dbc4e08 100644 --- a/src/lib/litegraph/src/subgraph/SubgraphInput.ts +++ b/src/lib/litegraph/src/subgraph/SubgraphInput.ts @@ -133,6 +133,16 @@ export class SubgraphInput extends SubgraphSlot { return } + if (slot.widget) { + subgraph.trigger('node:slot-links:changed', { + nodeId: node.id, + slotType: NodeSlotType.INPUT, + slotIndex: inputIndex, + connected: true, + linkId: link.id + }) + } + node.onConnectionsChange?.(NodeSlotType.INPUT, inputIndex, true, link, slot) if (subgraph.getLink(link.id) !== link) { subgraph.afterChange() diff --git a/src/lib/litegraph/src/subgraph/SubgraphInputNode.ts b/src/lib/litegraph/src/subgraph/SubgraphInputNode.ts index 75d6ff7e5aa..e4112f87300 100644 --- a/src/lib/litegraph/src/subgraph/SubgraphInputNode.ts +++ b/src/lib/litegraph/src/subgraph/SubgraphInputNode.ts @@ -188,6 +188,15 @@ export class SubgraphInputNode subgraph.removeFloatingLink(floatingLink) } + if (input.widget) { + subgraph.trigger('node:slot-links:changed', { + nodeId: node.id, + slotType: NodeSlotType.INPUT, + slotIndex: inputIndex, + connected: false, + linkId: link?.id ?? null + }) + } subgraph.setDirtyCanvas(false, true) if (!link) return diff --git a/src/renderer/core/canvas/links/linkConnectorAdapter.ts b/src/renderer/core/canvas/links/linkConnectorAdapter.ts index a03d07f87b4..7c317d12c9a 100644 --- a/src/renderer/core/canvas/links/linkConnectorAdapter.ts +++ b/src/renderer/core/canvas/links/linkConnectorAdapter.ts @@ -142,7 +142,6 @@ export class LinkConnectorAdapter { /** Drops moving links onto the canvas (no target). */ dropOnCanvas(event: CanvasPointerEvent): void { - //Add extra check for connection to subgraphInput/subgraphOutput if (isSubgraph(this.network)) { const { canvasX, canvasY } = event const ioNode = this.network.getIoNodeOnPos?.(canvasX, canvasY) diff --git a/src/renderer/core/canvas/links/useSubgraphDragBridge.test.ts b/src/renderer/core/canvas/links/useSubgraphDragBridge.test.ts new file mode 100644 index 00000000000..6f469a5f863 --- /dev/null +++ b/src/renderer/core/canvas/links/useSubgraphDragBridge.test.ts @@ -0,0 +1,151 @@ +import { fromPartial } from '@total-typescript/shoehorn' +import { beforeEach, describe, expect, it, vi } from 'vitest' +import { effectScope, nextTick } from 'vue' + +import { LGraph } from '@/lib/litegraph/src/LGraph' +import type { LGraphCanvas } from '@/lib/litegraph/src/LGraphCanvas' +import { LGraphNode } from '@/lib/litegraph/src/LGraphNode' +import type { LinkConnector } from '@/lib/litegraph/src/canvas/LinkConnector' +import type { LinkConnectorEventMap } from '@/lib/litegraph/src/infrastructure/LinkConnectorEventMap' +import { CustomEventTarget } from '@/lib/litegraph/src/infrastructure/CustomEventTarget' +import { LinkDirection } from '@/lib/litegraph/src/types/globalEnums' +import { useCanvasStore } from '@/renderer/core/canvas/canvasStore' +import { useSlotLinkDragUIState } from '@/renderer/core/canvas/links/slotLinkDragUIState' +import { getSlotKey } from '@/renderer/core/layout/slots/slotIdentifier' +import { toNodeId } from '@/types/nodeId' + +import { useSubgraphDragBridge } from './useSubgraphDragBridge' + +/** + * The bridge is the only listener that turns a canvas-drawn subgraph IO drag + * into Vue slot drag state. GraphCanvas mounts it against the live + * `LGraphCanvas`, so its collaborators (`linkConnector.events` and + * `getCanvasWindow()`) are exercised here against a canvas double rather than + * through a component mount. + */ +const appMock = vi.hoisted(() => ({ + app: { canvas: null as LGraphCanvas | null } +})) + +vi.mock('@/scripts/app', () => appMock) + +const SOURCE_NODE_ID = toNodeId(1) +const TARGET_NODE_ID = toNodeId(2) + +function createTargetGraph() { + const graph = new LGraph() + const target = new LGraphNode('Target') + target.id = TARGET_NODE_ID + target.addInput('value', 'INT') + graph.add(target) + return graph +} + +function createCanvasDouble(isInputValidDrop: () => boolean) { + const events = new CustomEventTarget() + + const linkConnector = fromPartial({ + events, + state: {}, + renderLinks: [ + { + node: { id: SOURCE_NODE_ID }, + fromSlotIndex: 3, + fromDirection: LinkDirection.RIGHT, + fromPos: [120, 240] + } + ], + isInputValidDrop: vi.fn(isInputValidDrop) + }) + + const canvas = fromPartial({ + graph: createTargetGraph(), + linkConnector, + setDirty: vi.fn(), + getCanvasWindow: () => window + }) + + return { canvas, linkConnector } +} + +function startBridge(canvas: LGraphCanvas) { + const scope = effectScope() + scope.run(() => useSubgraphDragBridge()) + useCanvasStore().canvas = canvas + return scope +} + +describe('useSubgraphDragBridge', () => { + const { state, endDrag } = useSlotLinkDragUIState() + + beforeEach(() => { + endDrag() + appMock.app.canvas = null + }) + + it('mirrors a canvas-initiated drag into Vue slot drag state', async () => { + const { canvas, linkConnector } = createCanvasDouble(() => true) + appMock.app.canvas = canvas + const scope = startBridge(canvas) + await nextTick() + + linkConnector.events.dispatch('connecting', { connectingTo: 'input' }) + + expect(state.active).toBe(true) + expect(state.source).toMatchObject({ + nodeId: SOURCE_NODE_ID, + slotIndex: 3, + type: 'output', + direction: LinkDirection.RIGHT, + position: { x: 120, y: 240 } + }) + + scope.stop() + }) + + it('records per-slot compatibility for the slots being dragged toward', async () => { + const { canvas, linkConnector } = createCanvasDouble(() => false) + appMock.app.canvas = canvas + const scope = startBridge(canvas) + await nextTick() + + linkConnector.events.dispatch('connecting', { connectingTo: 'input' }) + + expect(state.compatible.get(getSlotKey(TARGET_NODE_ID, 0, true))).toBe( + false + ) + expect(linkConnector.isInputValidDrop).toHaveBeenCalled() + + scope.stop() + }) + + it('ends the drag when the connector resets', async () => { + const { canvas, linkConnector } = createCanvasDouble(() => true) + appMock.app.canvas = canvas + const scope = startBridge(canvas) + await nextTick() + + linkConnector.events.dispatch('connecting', { connectingTo: 'input' }) + linkConnector.events.dispatch('reset', true) + + expect(state.active).toBe(false) + + scope.stop() + }) + + it('ends an in-flight drag and stops listening when its scope is disposed', async () => { + const { canvas, linkConnector } = createCanvasDouble(() => true) + appMock.app.canvas = canvas + const scope = startBridge(canvas) + await nextTick() + + linkConnector.events.dispatch('connecting', { connectingTo: 'input' }) + scope.stop() + + expect(state.active).toBe(false) + + linkConnector.events.dispatch('connecting', { connectingTo: 'input' }) + + expect(state.active).toBe(false) + }) +}) diff --git a/src/renderer/core/canvas/links/useSubgraphDragBridge.ts b/src/renderer/core/canvas/links/useSubgraphDragBridge.ts new file mode 100644 index 00000000000..6a6c88ede60 --- /dev/null +++ b/src/renderer/core/canvas/links/useSubgraphDragBridge.ts @@ -0,0 +1,362 @@ +import { tryOnScopeDispose, whenever } from '@vueuse/core' +import { storeToRefs } from 'pinia' + +import type { LGraphCanvas } from '@/lib/litegraph/src/LGraphCanvas' +import type { LGraphNode } from '@/lib/litegraph/src/LGraphNode' +import type { LinkConnector } from '@/lib/litegraph/src/canvas/LinkConnector' +import type { RenderLink } from '@/lib/litegraph/src/canvas/RenderLink' +import type { SlotDropCandidate } from '@/renderer/core/canvas/links/slotLinkDragUIState' +import { LinkDirection } from '@/lib/litegraph/src/types/globalEnums' +import { useCanvasStore } from '@/renderer/core/canvas/canvasStore' +import { createLinkConnectorAdapter } from '@/renderer/core/canvas/links/linkConnectorAdapter' +import { + resolveNodeSurfaceSlotCandidate, + resolveSlotTargetCandidate +} from '@/renderer/core/canvas/links/linkDropOrchestrator' +import { useSlotLinkDragUIState } from '@/renderer/core/canvas/links/slotLinkDragUIState' +import { getSlotKey } from '@/renderer/core/layout/slots/slotIdentifier' +import { createSlotLinkDragContext } from '@/renderer/extensions/vueNodes/composables/slotLinkDragContext' +import { resolvePointerTarget } from '@/renderer/extensions/vueNodes/composables/useSlotLinkInteraction' +import { app } from '@/scripts/app' +import type { NodeId } from '@/types/nodeId' +import { toNodeId } from '@/types/nodeId' +import { createRafBatch } from '@/utils/rafBatch' + +const SNAP_CLASS = 'lg-slot--snap-target' + +/** + * Bridges canvas-initiated subgraph IO drags to Vue slot drag state. + * + * When a drag starts from a SubgraphInput or SubgraphOutput node + * (canvas-drawn), the Vue slot components need to know about it so they + * can dim incompatible slots, snap links, and highlight compatible targets. + */ +export function useSubgraphDragBridge() { + const canvasStore = useCanvasStore() + const { canvas } = storeToRefs(canvasStore) + const { + state: dragState, + beginDrag, + endDrag, + setCandidate, + setCompatibleForKey + } = useSlotLinkDragUIState() + let cleanup: (() => void) | undefined + + whenever(canvas, (lgCanvas) => { + cleanup?.() + cleanup = setupBridge(lgCanvas) + }) + + tryOnScopeDispose(() => { + cleanup?.() + cleanup = undefined + }) + + /** Wires up LinkConnector event listeners and returns a cleanup function. */ + function setupBridge(lgCanvas: LGraphCanvas): () => void { + const linkConnector: LinkConnector = lgCanvas.linkConnector + let teardownDrag: (() => void) | undefined + let isBridgeDrag = false + + const onConnecting = ( + event: CustomEvent<{ connectingTo: 'input' | 'output' }> + ) => { + teardownDrag?.() + teardownDrag = undefined + + const { connectingTo } = event.detail + + const adapter = createLinkConnectorAdapter() + if (!adapter) return + + const renderLink = adapter.renderLinks[0] + if (!renderLink) return + + const sourceType: 'input' | 'output' = + connectingTo === 'input' ? 'output' : 'input' + + isBridgeDrag = true + beginDrag( + { + nodeId: renderLink.node.id, + slotIndex: renderLink.fromSlotIndex, + type: sourceType, + direction: renderLink.fromDirection ?? LinkDirection.RIGHT, + position: { + x: renderLink.fromPos[0], + y: renderLink.fromPos[1] + } + }, + -1 + ) + + for (const candidateNode of adapter.network.nodes) { + const slots = + connectingTo === 'input' + ? candidateNode.inputs + : candidateNode.outputs + for (const [slotIndex] of slots.entries()) { + const key = getSlotKey( + candidateNode.id, + slotIndex, + connectingTo === 'input' + ) + const ok = + connectingTo === 'input' + ? adapter.isInputValidDrop(candidateNode.id, slotIndex) + : adapter.isOutputValidDrop(candidateNode.id, slotIndex) + + setCompatibleForKey(key, ok) + } + } + + teardownDrag = startPointerTracking(lgCanvas, linkConnector) + } + + const onBeforeDropOnCanvas = (event: CustomEvent) => { + if (!isBridgeDrag) return + + const candidate = dragState.candidate + if (!candidate?.compatible) return + + const adapter = createLinkConnectorAdapter() + if (!adapter) return + + const connected = connectToCandidate( + adapter.renderLinks, + adapter.network, + candidate, + linkConnector + ) + if (connected) event.preventDefault() + } + + const onReset = () => { + if (!isBridgeDrag) return + teardownDrag?.() + teardownDrag = undefined + isBridgeDrag = false + endDrag() + } + + linkConnector.events.addEventListener('connecting', onConnecting) + linkConnector.events.addEventListener( + 'before-drop-on-canvas', + onBeforeDropOnCanvas + ) + linkConnector.events.addEventListener('reset', onReset) + + return () => { + linkConnector.events.removeEventListener('connecting', onConnecting) + linkConnector.events.removeEventListener( + 'before-drop-on-canvas', + onBeforeDropOnCanvas + ) + linkConnector.events.removeEventListener('reset', onReset) + teardownDrag?.() + teardownDrag = undefined + if (isBridgeDrag) { + isBridgeDrag = false + endDrag() + } + } + } + + /** + * Tracks pointer movement during a bridge drag to resolve Vue slot + * candidates, update snap positions, and toggle snap-target highlights. + * Returns a cleanup function that removes the listener and RAF batch. + */ + function startPointerTracking( + lgCanvas: LGraphCanvas, + linkConnector: LinkConnector + ): () => void { + const ownerDoc = lgCanvas.getCanvasWindow().document + const session = createSlotLinkDragContext() + let pendingMove: { clientX: number; clientY: number } | null = null + let highlightedSlotEl: HTMLElement | null = null + + /** Resolves the Vue slot under the pointer and updates snap/highlight state. */ + const processFrame = () => { + const data = pendingMove + if (!data) return + pendingMove = null + + const adapter = createLinkConnectorAdapter() + if (!adapter) return + const graph = adapter.network + + const target = resolvePointerTarget(data.clientX, data.clientY, null) + + let hoveredSlotKey: string | null = null + let hoveredNodeId: NodeId | null = null + if (target === session.lastPointerEventTarget) { + hoveredSlotKey = session.lastPointerTargetSlotKey + hoveredNodeId = session.lastPointerTargetNodeId + } else if (target instanceof HTMLElement) { + const elWithSlot = target + .closest('.lg-slot, .lg-node-widget') + ?.querySelector('[data-slot-key]') + const elWithNode = target.closest('[data-node-id]') + hoveredSlotKey = elWithSlot?.dataset['slotKey'] ?? null + hoveredNodeId = elWithNode?.dataset['nodeId'] + ? toNodeId(elWithNode.dataset['nodeId']) + : null + session.lastPointerEventTarget = target + session.lastPointerTargetSlotKey = hoveredSlotKey + session.lastPointerTargetNodeId = hoveredNodeId + } + + const hoverChanged = + hoveredSlotKey !== session.lastHoverSlotKey || + hoveredNodeId !== session.lastHoverNodeId + + let candidate = dragState.candidate + + if (hoverChanged) { + const context = { adapter, graph, session } + const slotCandidate = resolveSlotTargetCandidate(target, context) + const nodeCandidate = resolveNodeSurfaceSlotCandidate(target, context) + candidate = slotCandidate?.compatible ? slotCandidate : nodeCandidate + session.lastHoverSlotKey = hoveredSlotKey + session.lastHoverNodeId = hoveredNodeId + + if (slotCandidate) { + const key = getSlotKey( + slotCandidate.layout.nodeId, + slotCandidate.layout.index, + slotCandidate.layout.type === 'input' + ) + setCompatibleForKey(key, !!slotCandidate.compatible) + } + if (nodeCandidate && !slotCandidate?.compatible) { + const key = getSlotKey( + nodeCandidate.layout.nodeId, + nodeCandidate.layout.index, + nodeCandidate.layout.type === 'input' + ) + setCompatibleForKey(key, !!nodeCandidate.compatible) + } + } + + const newCandidate = candidate?.compatible ? candidate : null + const newCandidateKey = newCandidate + ? getSlotKey( + newCandidate.layout.nodeId, + newCandidate.layout.index, + newCandidate.layout.type === 'input' + ) + : null + + const candidateChanged = newCandidateKey !== session.lastCandidateKey + if (candidateChanged) { + setCandidate(newCandidate) + session.lastCandidateKey = newCandidateKey + updateSnapTargetHighlight(newCandidate) + } + + const snapPos = newCandidate + ? ([newCandidate.layout.position.x, newCandidate.layout.position.y] as [ + number, + number + ]) + : undefined + const currentSnap = linkConnector.state.snapLinksPos + const snapPosChanged = snapPos + ? !currentSnap || + currentSnap[0] !== snapPos[0] || + currentSnap[1] !== snapPos[1] + : !!currentSnap + if (snapPosChanged) { + linkConnector.state.snapLinksPos = snapPos + } + + if (candidateChanged || snapPosChanged) { + app.canvas?.setDirty(true, true) + } + } + + /** Toggles the `lg-slot--snap-target` CSS class on the candidate's slot element. */ + function updateSnapTargetHighlight(candidate: SlotDropCandidate | null) { + if (highlightedSlotEl) { + highlightedSlotEl.classList.remove(SNAP_CLASS) + highlightedSlotEl = null + } + if (!candidate) return + const key = getSlotKey( + candidate.layout.nodeId, + candidate.layout.index, + candidate.layout.type === 'input' + ) + const dotEl = ownerDoc.querySelector( + `[data-slot-key="${key}"]` + ) + const groupEl = dotEl?.closest('.lg-slot') + if (groupEl) { + groupEl.classList.add(SNAP_CLASS) + highlightedSlotEl = groupEl + } + } + + const raf = createRafBatch(processFrame) + + /** Buffers the latest pointer position and schedules a RAF frame. */ + const onPointerMove = (e: PointerEvent) => { + pendingMove = { clientX: e.clientX, clientY: e.clientY } + raf.schedule() + } + + ownerDoc.addEventListener('pointermove', onPointerMove, { capture: true }) + + return () => { + ownerDoc.removeEventListener('pointermove', onPointerMove, { + capture: true + }) + raf.cancel() + if (highlightedSlotEl) { + highlightedSlotEl.classList.remove(SNAP_CLASS) + highlightedSlotEl = null + } + session.dispose() + } + } +} + +/** + * Connects render links to the snapped Vue slot candidate. + * Returns `true` if at least one link was connected. + */ +function connectToCandidate( + links: ReadonlyArray, + network: { getNodeById(id: NodeId): LGraphNode | null }, + candidate: SlotDropCandidate, + linkConnector: LinkConnector +): boolean { + const node = network.getNodeById(candidate.layout.nodeId) + if (!node) return false + + let connected = false + + if (candidate.layout.type === 'input') { + const input = node.inputs?.[candidate.layout.index] + if (!input) return false + for (const link of links) { + if (link.toType !== 'input') continue + if (!link.canConnectToInput(node, input)) continue + link.connectToInput(node, input, linkConnector.events) + connected = true + } + } else { + const output = node.outputs?.[candidate.layout.index] + if (!output) return false + for (const link of links) { + if (link.toType !== 'output') continue + if (!link.canConnectToOutput(node, output)) continue + link.connectToOutput(node, output, linkConnector.events) + connected = true + } + } + + return connected +} diff --git a/src/renderer/extensions/vueNodes/components/SlotConnectionDot.vue b/src/renderer/extensions/vueNodes/components/SlotConnectionDot.vue index f1df51b7eed..d1917669736 100644 --- a/src/renderer/extensions/vueNodes/components/SlotConnectionDot.vue +++ b/src/renderer/extensions/vueNodes/components/SlotConnectionDot.vue @@ -48,7 +48,7 @@ const slotClass = computed(() => 'border border-solid border-node-component-slot-dot-outline', props.multi ? 'h-5 w-2' - : 'size-2 cursor-crosshair group-hover/slot:scale-125 group-hover/slot:[--node-component-slot-dot-outline-opacity-mult:5]' + : 'size-2 cursor-crosshair group-hover/slot:scale-125 group-hover/slot:[--node-component-slot-dot-outline-opacity-mult:5] group-[.lg-slot--snap-target]/slot:scale-125 group-[.lg-slot--snap-target]/slot:[--node-component-slot-dot-outline-opacity-mult:5]' ) ) diff --git a/src/renderer/extensions/vueNodes/composables/useSlotLinkInteraction.ts b/src/renderer/extensions/vueNodes/composables/useSlotLinkInteraction.ts index ebac19f96f9..b706cb0e6f7 100644 --- a/src/renderer/extensions/vueNodes/composables/useSlotLinkInteraction.ts +++ b/src/renderer/extensions/vueNodes/composables/useSlotLinkInteraction.ts @@ -12,6 +12,7 @@ import type { INodeInputSlot, INodeOutputSlot } from '@/lib/litegraph/src/interfaces' +import type { CanvasPointerEvent } from '@/lib/litegraph/src/types/events' import { LinkDirection } from '@/lib/litegraph/src/types/globalEnums' import { clearCanvasPointerHistory, @@ -40,6 +41,7 @@ import { graphScopeOf } from '@/types/graphScopeId' import { UNASSIGNED_NODE_ID, toNodeId } from '@/types/nodeId' import type { NodeId } from '@/types/nodeId' import { createRafBatch } from '@/utils/rafBatch' +import { isSubgraph } from '@/utils/typeGuardUtil' interface SlotInteractionOptions { nodeId?: NodeId @@ -413,14 +415,44 @@ export function useSlotLinkInteraction({ dragContext.lastCandidateKey = newCandidateKey } + let subgraphIOSnapPos: [number, number] | null = null + let subgraphIOHoverChanged = false + + const graph = app.canvas?.graph + if (isSubgraph(graph)) { + const pointerEvent = { canvasX, canvasY } as CanvasPointerEvent + + for (const node of [graph.inputNode, graph.outputNode]) { + if (!node) continue + + const wasPointerOver = node.isPointerOver + node.onPointerMove(pointerEvent) + + if (wasPointerOver !== node.isPointerOver) { + subgraphIOHoverChanged = true + } + + if (node.isPointerOver) { + const slot = node.getSlotInPosition(canvasX, canvasY) + if (slot && slot.isPointerOver) { + subgraphIOSnapPos = slot.pos + } + } + } + } + let snapPosChanged = false if (activeAdapter) { - const snapX = newCandidate - ? newCandidate.layout.position.x - : state.pointer.canvas.x - const snapY = newCandidate - ? newCandidate.layout.position.y - : state.pointer.canvas.y + const snapX = subgraphIOSnapPos + ? subgraphIOSnapPos[0] + : newCandidate + ? newCandidate.layout.position.x + : state.pointer.canvas.x + const snapY = subgraphIOSnapPos + ? subgraphIOSnapPos[1] + : newCandidate + ? newCandidate.layout.position.y + : state.pointer.canvas.y const currentSnap = activeAdapter.linkConnector.state.snapLinksPos snapPosChanged = !currentSnap || currentSnap[0] !== snapX || currentSnap[1] !== snapY @@ -429,7 +461,8 @@ export function useSlotLinkInteraction({ } } - const shouldRedraw = candidateChanged || snapPosChanged + const shouldRedraw = + candidateChanged || snapPosChanged || subgraphIOHoverChanged if (shouldRedraw) app.canvas?.setDirty(true, true) } const raf = createRafBatch(processPointerMoveFrame)