diff --git a/browser_tests/tests/links/linkVisibility.spec.ts b/browser_tests/tests/links/linkVisibility.spec.ts index f22f374d2ed..de095defbb7 100644 --- a/browser_tests/tests/links/linkVisibility.spec.ts +++ b/browser_tests/tests/links/linkVisibility.spec.ts @@ -293,6 +293,56 @@ test.describe( ) }) }) + + test('double-clicking a stack renames every link in it', async ({ + comfyPage, + linkVisibility + }) => { + const undoSizeBeforeRename = + (await comfyPage.workflow.getUndoQueueSize()) ?? 0 + const exportedLinkPresentations = async () => + Object.values( + (await comfyPage.workflow.getExportedWorkflow()).extra + ?.linkPresentation ?? {} + ) + + await test.step('Name the unlabelled stack', async () => { + await linkVisibility.openRenamePromptAtOutputBadgeRow( + checkpointLoaderId, + clipSlot, + 0 + ) + await expect(linkVisibility.promptInput).toHaveValue('') + await comfyPage.nodeOps.fillLegacyWidgetDialog('enc') + await expect(linkVisibility.promptInput).toBeHidden() + await expect.poll(exportedLinkPresentations).toEqual([ + { hidden: true, label: 'enc' }, + { hidden: true, label: 'enc' } + ]) + }) + + await test.step('The links stay one collapsed stack with the new name', async () => { + await linkVisibility.parkPointer() + await expectRegionScreenshot( + comfyPage.page, + [ + await comfyPage.nodeOps.getNodeRefById(checkpointLoaderId), + ...(await comfyPage.nodeOps.getNodeRefsByType('CLIPTextEncode')) + ], + 'link-stack-same-name-collapsed.png' + ) + }) + + await test.step('One undo removes the name from every link', async () => { + await expect + .poll(() => comfyPage.workflow.getUndoQueueSize()) + .toBe(undoSizeBeforeRename + 1) + await comfyPage.keyboard.undo() + await expect + .poll(exportedLinkPresentations) + .toEqual([{ hidden: true }, { hidden: true }]) + }) + }) } ) diff --git a/src/composables/graph/useGroupContextMenu.test.ts b/src/composables/graph/useGroupContextMenu.test.ts index a9bc7bdb6f0..6b19a94b1f1 100644 --- a/src/composables/graph/useGroupContextMenu.test.ts +++ b/src/composables/graph/useGroupContextMenu.test.ts @@ -3,7 +3,8 @@ import { beforeEach, describe, expect, it, onTestFinished, vi } from 'vitest' import { useSelectedLiteGraphItems } from '@/composables/canvas/useSelectedLiteGraphItems' import { useGroupContextMenu } from '@/composables/graph/useGroupContextMenu' -import type { CanvasPointerEvent } from '@/lib/litegraph/src/litegraph' +import type { getCanvasContextMenuTarget } from '@/lib/litegraph/src/canvas/getCanvasContextMenuTarget' +import type { CanvasPointerEvent, Reroute } from '@/lib/litegraph/src/litegraph' import { LGraph, LGraphCanvas, @@ -18,13 +19,16 @@ import { createMockCanvasRenderingContext2D, createTestCanvas } from '@/utils/__tests__/canvasTestUtils' +import { createMockLLink } from '@/utils/__tests__/litegraphTestUtils' +import { toLinkId } from '@comfyorg/graph-model/linkId' +import { toRerouteId } from '@comfyorg/graph-model/rerouteId' const { mockShowNodeOptions, mockGetCanvasContextMenuTarget } = vi.hoisted( () => ({ mockShowNodeOptions: vi.fn(), - mockGetCanvasContextMenuTarget: vi.fn< - () => { reroute?: unknown; link?: unknown; group?: unknown } - >(() => ({})) + mockGetCanvasContextMenuTarget: vi.fn( + () => ({}) + ) }) ) @@ -32,7 +36,7 @@ vi.mock(import('@/composables/graph/useMoreOptionsMenu'), () => ({ showNodeOptions: mockShowNodeOptions })) -vi.mock( +vi.mock( import('@/lib/litegraph/src/canvas/getCanvasContextMenuTarget'), () => ({ getCanvasContextMenuTarget: mockGetCanvasContextMenuTarget @@ -241,7 +245,26 @@ describe('useGroupContextMenu', () => { it('falls through to the legacy menu when the cursor is on a reroute', () => { mockGetCanvasContextMenuTarget.mockReturnValue({ - reroute: { id: 5 }, + reroute: fromPartial({ id: toRerouteId(5) }), + group + }) + + invoke(undefined) + + expect(legacyMenuMock).toHaveBeenCalledOnce() + expect(mockShowNodeOptions).not.toHaveBeenCalled() + expect(stubCanvas.selectedItems.size).toBe(0) + }) + + it('falls through to the legacy menu when the cursor is on a stack of hidden links', () => { + mockGetCanvasContextMenuTarget.mockReturnValue({ + stack: { + stackKey: 'output:1:0', + links: [ + createMockLLink({ id: toLinkId(5) }), + createMockLLink({ id: toLinkId(6) }) + ] + }, group }) @@ -254,7 +277,7 @@ describe('useGroupContextMenu', () => { it('falls through to the legacy menu when the cursor is on a link', () => { mockGetCanvasContextMenuTarget.mockReturnValue({ - link: { id: 5 }, + link: createMockLLink({ id: toLinkId(5) }), group }) diff --git a/src/composables/graph/useGroupContextMenu.ts b/src/composables/graph/useGroupContextMenu.ts index 57161431d1a..2dfa7c17168 100644 --- a/src/composables/graph/useGroupContextMenu.ts +++ b/src/composables/graph/useGroupContextMenu.ts @@ -13,6 +13,15 @@ function shouldUseLegacyContextMenu( return Boolean(node) || !LiteGraph.vueNodesMode || !canvas.graph } +function groupUnderBareCursor(canvas: LGraphCanvas, x: number, y: number) { + const { reroute, link, stack, group } = getCanvasContextMenuTarget( + canvas, + x, + y + ) + return reroute || link || stack ? undefined : group +} + /** * Routes Nodes 2.0 group right-clicks to Vue while nodes, reroutes, * background, and legacy mode stay on litegraph. @@ -31,12 +40,8 @@ export function useGroupContextMenu() { return } - const { reroute, link, group } = getCanvasContextMenuTarget( - this, - event.canvasX, - event.canvasY - ) - if (reroute || link || !group) { + const group = groupUnderBareCursor(this, event.canvasX, event.canvasY) + if (!group) { original.apply(this, args) return } diff --git a/src/lib/litegraph/src/CanvasPointer.ts b/src/lib/litegraph/src/CanvasPointer.ts index e7e5337115d..84f6f60e8b9 100644 --- a/src/lib/litegraph/src/CanvasPointer.ts +++ b/src/lib/litegraph/src/CanvasPointer.ts @@ -6,7 +6,11 @@ import type { GesturePolicy, GestureState } from './canvas/reduceGesture' -import { idleGesture, reduceGesture } from './canvas/reduceGesture' +import { + doubleClickedClick, + idleGesture, + reduceGesture +} from './canvas/reduceGesture' import type { CompassCorners } from '@comfyorg/shared-frontend-utils/geometry' import type { CanvasPointerEvent } from '@comfyorg/graph-model/events' @@ -67,6 +71,11 @@ export class CanvasPointer { return this.state.phase === 'dragging' } + /** The `timeStamp` of the press that the current press double-clicks, if any. */ + get doubleClickedTimeStamp(): number | undefined { + return doubleClickedClick(this.state)?.timeStamp + } + private state: GestureState = idleGesture private releaseCapture?: () => void diff --git a/src/lib/litegraph/src/LGraphCanvas.linkVisibility.test.ts b/src/lib/litegraph/src/LGraphCanvas.linkVisibility.test.ts index f7373a54e61..bf087326738 100644 --- a/src/lib/litegraph/src/LGraphCanvas.linkVisibility.test.ts +++ b/src/lib/litegraph/src/LGraphCanvas.linkVisibility.test.ts @@ -10,7 +10,8 @@ import { LGraph, LGraphNode, LiteGraph } from '@/lib/litegraph/src/litegraph' import { drawHiddenLinkBadges, layoutHiddenLinkBadges, - queryLinkBadgeAtPoint + queryLinkBadgeAtPoint, + queryLinkBadgeHitAtPoint } from '@/lib/litegraph/src/canvas/linkBadges' import { LLink } from '@/lib/litegraph/src/LLink' import { LinkMarkerShape } from '@comfyorg/graph-model/globalEnums' @@ -502,25 +503,33 @@ describe('LGraphCanvas link visibility interactions', () => { }) describe('stacked hidden link badges', () => { - function createStackFixture() { + function createStackFixture( + labels: readonly (string | undefined)[] = [undefined, undefined] + ) { const { graph, canvas, link } = createFixture() const source = graph.getNodeById(link.origin_id) assert.exists(source) - const target = new LGraphNode('Second target') - target.addInput('in', 'MODEL') - graph.add(target) - const links = [link, createTestLink(graph, source, 0, target, 0)] + const links = labels.map((_, index) => { + if (index === 0) return link + const target = new LGraphNode(`Target ${index}`) + target.addInput('in', 'MODEL') + graph.add(target) + return createTestLink(graph, source, 0, target, 0) + }) const scope = graphScopeOf(graph) - for (const hidden of links) { - useLinkPresentationStore().patch(scope, hidden.id, { hidden: true }) - } + const store = useLinkPresentationStore() + links.forEach((hidden, index) => + store.patch(scope, hidden.id, { hidden: true, label: labels[index] }) + ) + const labelOf = (hidden: LLink) => + store.getPresentation(scope, hidden.id)?.label const relayout = () => layoutHiddenLinkBadges( canvas, canvas.ctx, links.map((hidden, index) => ({ link: hidden, - presentation: { hidden: true }, + presentation: { hidden: true, label: labelOf(hidden) }, startPos: [400, 300], endPos: [700, 300 + index * 100], color: '#89A' @@ -529,7 +538,14 @@ describe('LGraphCanvas link visibility interactions', () => { relayout() drawHiddenLinkBadges(canvas.ctx, canvas, [0, 0, 800, 600]) onTestFinished(() => canvas.pointer.reset()) - return { graph, canvas, links, relayout } + const prompt = vi + .spyOn(canvas, 'prompt') + .mockReturnValue(document.createElement('div')) + const submitPrompt = (value: string) => { + prompt.mock.calls[0][2](value) + relayout() + } + return { graph, canvas, links, relayout, prompt, submitPrompt, labelOf } } function clickAt(canvas: LGraphCanvas, clientX: number, clientY: number) { @@ -636,16 +652,390 @@ describe('LGraphCanvas link visibility interactions', () => { canvas.processMouseUp(up) } - it('expands a stack exactly once on a double click', () => { - const { canvas, links, relayout } = createStackFixture() + function doubleClickAt( + canvas: LGraphCanvas, + clientX: number, + clientY: number + ) { + pressAt(canvas, clientX, clientY, 100) + pressAt(canvas, clientX, clientY, 200) + } + + const stackedLinkIdsAt = (canvas: LGraphCanvas, x: number, y: number) => { + const hit = queryLinkBadgeHitAtPoint(canvas, x, y) + return hit?.stackKey ? hit.linkIds : undefined + } + + it('renames every link in a collapsed stack on a double click and keeps it collapsed', () => { + const { canvas, links, prompt, submitPrompt, labelOf } = + createStackFixture([undefined, undefined, 'untouched']) + + doubleClickAt(canvas, 420, 300) + + expect(prompt).toHaveBeenCalledWith( + 'Rename', + '', + expect.any(Function), + expect.anything() + ) + submitPrompt('render_size') + + expect(links.map(labelOf)).toEqual([ + 'render_size', + 'render_size', + 'untouched' + ]) + expect(stackedLinkIdsAt(canvas, 420, 300)).toEqual( + links.slice(0, 2).map(({ id }) => id) + ) + expect(queryLinkBadgeAtPoint(canvas, 420, 322)).toBe(links[2].id) + }) + + it('renames the whole stack when the double click lands on its layer edge', () => { + const { canvas, links, relayout, submitPrompt, labelOf } = + createStackFixture([undefined, undefined, undefined]) + + pressAt(canvas, 420, 313, 100) + relayout() + pressAt(canvas, 420, 313, 200) + submitPrompt('edge') + + expect(links.map(labelOf)).toEqual(['edge', 'edge', 'edge']) + expect(queryLinkBadgeAtPoint(canvas, 420, 322)).toBeUndefined() + }) + + it('keeps an expanded stack expanded when the second click of its rename lands beside the pill', () => { + const { canvas, links, relayout, prompt } = createStackFixture([ + undefined, + undefined, + undefined + ]) + pressAt(canvas, 420, 300, 100) + relayout() + + pressAt(canvas, 420, 300, 500) + relayout() + pressAt(canvas, 420, 284, 600) + relayout() + + expect(prompt).toHaveBeenCalledOnce() + expect(queryLinkBadgeAtPoint(canvas, 420, 322)).toBe(links[0].id) + }) + + it('opens no rename prompt when the canvas turns read-only between the two clicks', () => { + const { canvas, relayout, prompt } = createStackFixture() pressAt(canvas, 420, 300, 100) + relayout() + canvas.read_only = true pressAt(canvas, 420, 300, 200) + + expect(prompt).not.toHaveBeenCalled() + }) + + function holdPressAt( + canvas: LGraphCanvas, + clientX: number, + clientY: number, + timeStamp: number + ) { + const init = { isPrimary: true, pointerId: 1, clientX, clientY } + const down = new PointerEvent('pointerdown', { + ...init, + button: 0, + buttons: 1 + }) + const up = new PointerEvent('pointerup', { + ...init, + button: 0, + buttons: 0 + }) + vi.spyOn(down, 'timeStamp', 'get').mockReturnValue(timeStamp) + vi.spyOn(up, 'timeStamp', 'get').mockReturnValue(timeStamp + 20) + canvas.processMouseDown(down) + return () => canvas.processMouseUp(up) + } + + it('opens no rename prompt when the canvas turns read-only during the second press', () => { + const { canvas, relayout, prompt } = createStackFixture() + + pressAt(canvas, 420, 300, 100) + relayout() + const release = holdPressAt(canvas, 420, 300, 200) + canvas.read_only = true + release() + + expect(prompt).not.toHaveBeenCalled() + }) + + it('opens no rename prompt when the canvas turns read-only during a double click whose first click missed', () => { + const { canvas, prompt } = createStackFixture() + + pressAt(canvas, 420, 280, 100) + const release = holdPressAt(canvas, 420, 295, 200) + canvas.read_only = true + release() + + expect(prompt).not.toHaveBeenCalled() + }) + + it('cancels the rename and keeps the collapse when Escape is pressed during the second press', () => { + const { canvas, relayout, prompt } = createStackFixture() + + pressAt(canvas, 420, 300, 100) + relayout() + const release = holdPressAt(canvas, 420, 300, 200) + canvas.processKey(new KeyboardEvent('keydown', { key: 'Escape' })) + release() + relayout() + + expect(prompt).not.toHaveBeenCalled() + expect(queryLinkBadgeAtPoint(canvas, 420, 322)).toBeUndefined() + }) + + it('renames no single link when Escape is pressed during a second press on the layer edge', () => { + const { canvas, relayout, prompt } = createStackFixture([ + undefined, + undefined, + undefined + ]) + + pressAt(canvas, 420, 313, 100) + relayout() + const release = holdPressAt(canvas, 420, 313, 200) + canvas.processKey(new KeyboardEvent('keydown', { key: 'Escape' })) + release() + + expect(prompt).not.toHaveBeenCalled() + }) + + function dragFromBesideStackAfterClickingIt(gap: number) { + const previousBehavior = LiteGraph.leftMouseClickBehavior + LiteGraph.leftMouseClickBehavior = 'select' + onTestFinished(() => { + LiteGraph.leftMouseClickBehavior = previousBehavior + }) + const { canvas, relayout } = createStackFixture() + pressAt(canvas, 420, 300, 100) + relayout() + + const init = { isPrimary: true, pointerId: 1, button: 0 } + const down = new PointerEvent('pointerdown', { + ...init, + buttons: 1, + clientX: 420, + clientY: 284 + }) + vi.spyOn(down, 'timeStamp', 'get').mockReturnValue(100 + gap) + canvas.processMouseDown(down) + canvas.processMouseMove( + new PointerEvent('pointermove', { + ...init, + buttons: 1, + clientX: 460, + clientY: 244 + }) + ) + expect(canvas.dragging_rectangle).not.toBeNull() + const draggingCanvas = canvas.dragging_canvas + canvas.processMouseUp( + new PointerEvent('pointerup', { + ...init, + buttons: 0, + clientX: 460, + clientY: 244 + }) + ) + return { draggingCanvas, offset: [...canvas.ds.offset] } + } + + it('selects, not pans, when dragging from beside a just-clicked stack', () => { + const outsideDoubleClickWindow = dragFromBesideStackAfterClickingIt(1000) + + expect(outsideDoubleClickWindow.draggingCanvas).toBe(false) + expect(dragFromBesideStackAfterClickingIt(100)).toEqual( + outsideDoubleClickWindow + ) + }) + + it('keeps a stack expanded when a member click sits between two head clicks', () => { + const { canvas, links, relayout, prompt } = createStackFixture() + + pressAt(canvas, 420, 300, 100) + relayout() + pressAt(canvas, 420, 322, 220) + pressAt(canvas, 420, 309, 340) relayout() + expect(prompt).toHaveBeenCalledOnce() expect(queryLinkBadgeAtPoint(canvas, 420, 322)).toBe(links[0].id) }) + it('keeps an expanded stack expanded through a double click and its rename', () => { + const { canvas, links, relayout, prompt, submitPrompt } = + createStackFixture() + clickAt(canvas, 420, 300) + relayout() + + doubleClickAt(canvas, 420, 300) + relayout() + + expect(prompt).toHaveBeenCalledOnce() + expect(queryLinkBadgeAtPoint(canvas, 420, 322)).toBe(links[0].id) + + submitPrompt('render_size') + + expect(stackedLinkIdsAt(canvas, 420, 300)).toEqual( + links.map(({ id }) => id) + ) + expect(queryLinkBadgeAtPoint(canvas, 420, 322)).toBe(links[0].id) + }) + + it('keeps an expanded stack expanded when its menu Rename clears the name', () => { + const { canvas, links, relayout, submitPrompt } = createStackFixture([ + 'batch', + 'batch' + ]) + const menu = vi + .spyOn(LiteGraph, 'ContextMenu') + .mockImplementation(fromPartial(class {})) + clickAt(canvas, 420, 300) + relayout() + + canvas.processContextMenu( + undefined, + fromPartial({ canvasX: 420, canvasY: 300 }) + ) + void menu.mock.calls[0][1]?.callback?.({ + content: 'Rename', + value: 'Rename' + }) + submitPrompt('') + + expect(queryLinkBadgeAtPoint(canvas, 420, 322)).toBe(links[0].id) + }) + + it('leaves a stack collapsed when the first click of a double click missed it', () => { + const { canvas, relayout, prompt } = createStackFixture() + + pressAt(canvas, 420, 280, 100) + pressAt(canvas, 420, 295, 200) + relayout() + + expect(prompt).toHaveBeenCalledOnce() + expect(queryLinkBadgeAtPoint(canvas, 420, 322)).toBeUndefined() + }) + + it('leaves a stack collapsed when Escape collapsed it between two fast clicks', () => { + const { canvas, relayout, prompt } = createStackFixture() + + pressAt(canvas, 420, 300, 100) + canvas.processKey(new KeyboardEvent('keydown', { key: 'Escape' })) + pressAt(canvas, 420, 300, 200) + relayout() + + expect(prompt).toHaveBeenCalledOnce() + expect(queryLinkBadgeAtPoint(canvas, 420, 322)).toBeUndefined() + }) + + it('merges a renamed stack into the stack that already has that name', () => { + const { canvas, links, prompt, submitPrompt } = createStackFixture([ + undefined, + undefined, + 'batch', + 'batch' + ]) + + doubleClickAt(canvas, 420, 300) + expect(prompt.mock.calls[0][1]).toBe('') + submitPrompt('batch') + + expect(stackedLinkIdsAt(canvas, 420, 300)).toEqual( + links.map(({ id }) => id) + ) + }) + + it('returns every link to the unlabelled stack when a stack name is cleared', () => { + const { canvas, links, prompt, submitPrompt, labelOf } = + createStackFixture(['batch', 'batch', undefined]) + + doubleClickAt(canvas, 420, 322) + expect(prompt.mock.calls[0][1]).toBe('batch') + submitPrompt('') + + expect(links.map(labelOf)).toEqual([undefined, undefined, undefined]) + expect(stackedLinkIdsAt(canvas, 420, 300)).toEqual( + links.map(({ id }) => id) + ) + }) + + it('renames only one link when its expanded label is double clicked', () => { + const { canvas, links, relayout, submitPrompt, labelOf } = + createStackFixture() + clickAt(canvas, 420, 300) + relayout() + + doubleClickAt(canvas, 420, 322) + submitPrompt('solo') + + expect(links.map(labelOf)).toEqual(['solo', undefined]) + }) + + it('renames the whole stack from the Rename item of its context menu', () => { + const { canvas, links, prompt, submitPrompt, labelOf } = + createStackFixture() + const menu = vi + .spyOn(LiteGraph, 'ContextMenu') + .mockImplementation(fromPartial(class {})) + const rightClick = fromPartial({ + canvasX: 420, + canvasY: 300 + }) + + canvas.processContextMenu(undefined, rightClick) + + const [items, options] = menu.mock.calls[0] + expect(items).toEqual([ + { content: 'Rename', value: 'Rename' }, + { content: 'Show Links', value: 'Show Links' } + ]) + void options?.callback?.({ content: 'Rename', value: 'Rename' }) + expect(prompt).toHaveBeenCalledWith( + 'Rename', + '', + expect.any(Function), + rightClick + ) + submitPrompt('render_size') + + expect(links.map(labelOf)).toEqual(['render_size', 'render_size']) + }) + + it('shows every link in a stack from the Show Links item of its context menu', () => { + const { graph, canvas, links } = createStackFixture() + const menu = vi + .spyOn(LiteGraph, 'ContextMenu') + .mockImplementation(fromPartial(class {})) + const hiddenLinks = () => + links.filter( + ({ id }) => + useLinkPresentationStore().getPresentation(graphScopeOf(graph), id) + ?.hidden + ) + + canvas.processContextMenu( + undefined, + fromPartial({ canvasX: 420, canvasY: 300 }) + ) + const callback = menu.mock.calls[0][1]?.callback + + void callback?.(undefined) + expect(hiddenLinks()).toEqual(links) + + void callback?.({ content: 'Show Links', value: 'Show Links' }) + expect(hiddenLinks()).toEqual([]) + }) + it('collapses an expanded stack when empty canvas is clicked', () => { const { canvas, relayout } = createStackFixture() diff --git a/src/lib/litegraph/src/LGraphCanvas.ts b/src/lib/litegraph/src/LGraphCanvas.ts index ec323edb590..c281dc36b00 100644 --- a/src/lib/litegraph/src/LGraphCanvas.ts +++ b/src/lib/litegraph/src/LGraphCanvas.ts @@ -110,9 +110,14 @@ import { collapseLinkBadgeStacks, drawHiddenLinkBadges, queryLinkBadgeHitAtPoint, + queryLinkBadgeStackToggledAt, + relabelExpandedLinkBadgeStack, toggleLinkBadgeStack } from './canvas/linkBadges' -import { layoutGraphLinkBadges } from './canvas/linkBadgeRenderer' +import { + layoutGraphLinkBadges, + queryHiddenLinkStackToggledAt +} from './canvas/linkBadgeRenderer' import { getLinkMenuOptions, getLinkStackMenuOptions, @@ -538,7 +543,46 @@ function marqueeSelectsLinks( ) } -function toggleStackOnceOnDoubleClick(): void {} +interface HiddenLinkStack { + stackKey: string + links: LLink[] +} + +function promptRenameLinkStack( + canvas: LGraphCanvas, + graph: LGraph, + { stackKey, links }: HiddenLinkStack, + event: CanvasPointerEvent +): void { + promptRenameLinkBadge( + canvas, + graphScopeOf(graph), + links.map(({ id }) => id), + event, + (name) => relabelExpandedLinkBadgeStack(canvas, stackKey, name) + ) +} + +function renameToggledLinkStackOnDoubleClick( + canvas: LGraphCanvas, + graph: LGraph, + event: CanvasPointerEvent +): void { + const { pointer } = canvas + const toggledAt = pointer.doubleClickedTimeStamp + const isLocked = () => canvas.read_only || canvas.selectOnly + const toggledStack = () => + queryHiddenLinkStackToggledAt(canvas, graph, toggledAt) + if (isLocked() || !toggledStack()) return + + pointer.onDoubleClick = () => { + const stack = toggledStack() + if (isLocked() || !stack) return + toggleLinkBadgeStack(canvas, stack.stackKey) + canvas.dirty_bgcanvas = true + promptRenameLinkStack(canvas, graph, stack, event) + } +} interface SnappingLink { link: LLink @@ -2744,6 +2788,7 @@ export class LGraphCanvas implements CustomEventDispatcher // left button mouse / single finger if (e.button === 0 && !pointer.isDouble) { this._processPrimaryButton(e, node) + if (!node) renameToggledLinkStackOnDoubleClick(this, graph, e) } else if (isMiddleButtonEvent(e)) { this._processMiddleButton(e, node) } else if ( @@ -2893,19 +2938,21 @@ export class LGraphCanvas implements CustomEventDispatcher case 'linkBadge': { const { link } = target pointer.onDoubleClick = () => - promptRenameLinkBadge(this, graphScopeOf(graph), link.id, e) + promptRenameLinkBadge(this, graphScopeOf(graph), [link.id], e) pointer.onDragStart = () => (this.dragging_canvas = true) pointer.finally = () => (this.dragging_canvas = false) return } case 'linkBadgeStack': { - const { stackKey } = target pointer.onClick = () => { - toggleLinkBadgeStack(this, stackKey) + toggleLinkBadgeStack(this, target.stackKey, e.timeStamp) this.dirty_bgcanvas = true } - pointer.onDoubleClick = toggleStackOnceOnDoubleClick + pointer.onDoubleClick = () => { + if (this.read_only || this.selectOnly) return + promptRenameLinkStack(this, graph, target, e) + } pointer.onDragStart = () => (this.dragging_canvas = true) pointer.finally = () => (this.dragging_canvas = false) return @@ -4203,7 +4250,9 @@ export class LGraphCanvas implements CustomEventDispatcher const { eDown } = pointer const pressedBadge = - eDown && queryLinkBadgeHitAtPoint(this, eDown.canvasX, eDown.canvasY) + eDown && + (queryLinkBadgeHitAtPoint(this, eDown.canvasX, eDown.canvasY) ?? + queryLinkBadgeStackToggledAt(this, pointer.doubleClickedTimeStamp)) const wasConnecting = this.linkConnector.isConnecting const isClick = pointer.up(e) if (e.button === 0 && !wasConnecting) { @@ -7019,7 +7068,7 @@ export class LGraphCanvas implements CustomEventDispatcher if (link) showLink(this, graphScope, link.id) break case 'Rename': - if (link) promptRenameLinkBadge(this, graphScope, link.id, e) + if (link) promptRenameLinkBadge(this, graphScope, [link.id], e) break default: } @@ -8901,18 +8950,21 @@ export class LGraphCanvas implements CustomEventDispatcher menu_info = this.getCanvasMenuOptions() if (!this.graph) throw new NullGraphError() - const { reroute, linkSegment, link, stackedLinks, group } = + const { reroute, linkSegment, link, stack, group } = getCanvasContextMenuTarget(this, event.canvasX, event.canvasY) - if (stackedLinks) { - const graphScope = graphScopeOf(this.graph) + if (stack) { + const { graph } = this + const graphScope = graphScopeOf(graph) + const stackedLinkIds = stack.links.map(({ id }) => id) new LiteGraph.ContextMenu(getLinkStackMenuOptions(), { event, - callback: () => - showLinks( - this, - graphScope, - stackedLinks.map(({ id }) => id) - ) + callback: (item) => { + const action = typeof item === 'string' ? item : item?.value + if (action === 'Rename') + promptRenameLinkStack(this, graph, stack, event) + if (action === 'Show Links') + showLinks(this, graphScope, stackedLinkIds) + } }) return } diff --git a/src/lib/litegraph/src/canvas/getCanvasContextMenuTarget.test.ts b/src/lib/litegraph/src/canvas/getCanvasContextMenuTarget.test.ts index f42ca309b7e..81e21a29a8b 100644 --- a/src/lib/litegraph/src/canvas/getCanvasContextMenuTarget.test.ts +++ b/src/lib/litegraph/src/canvas/getCanvasContextMenuTarget.test.ts @@ -198,7 +198,7 @@ describe('getCanvasContextMenuTarget', () => { const target = resolve() - expect(target.stackedLinks).toEqual([links[0], links[1]]) + expect(target.stack?.links).toEqual([links[0], links[1]]) expect(target.link).toBeUndefined() }) diff --git a/src/lib/litegraph/src/canvas/getCanvasContextMenuTarget.ts b/src/lib/litegraph/src/canvas/getCanvasContextMenuTarget.ts index 4eff269fcaa..7b8e6306d85 100644 --- a/src/lib/litegraph/src/canvas/getCanvasContextMenuTarget.ts +++ b/src/lib/litegraph/src/canvas/getCanvasContextMenuTarget.ts @@ -25,7 +25,7 @@ interface CanvasContextMenuTarget { reroute?: Reroute linkSegment?: LinkSegment link?: LLink - stackedLinks?: LLink[] + stack?: ReturnType group?: LGraphGroup } @@ -76,7 +76,7 @@ export function getCanvasContextMenuTarget( if (reroute) return { reroute, group } const stack = queryHiddenLinkStackAtPoint(canvas, graph, x, y) - if (stack) return { stackedLinks: stack.links, group } + if (stack) return { stack, group } const badgeLink = queryHiddenLinkBadgeAtPoint(canvas, graph, x, y) if (badgeLink) return { link: badgeLink, group } diff --git a/src/lib/litegraph/src/canvas/linkBadgeRenderer.ts b/src/lib/litegraph/src/canvas/linkBadgeRenderer.ts index 8ce801ca267..78fbb4c774a 100644 --- a/src/lib/litegraph/src/canvas/linkBadgeRenderer.ts +++ b/src/lib/litegraph/src/canvas/linkBadgeRenderer.ts @@ -6,7 +6,8 @@ import { useLinkPresentationStore } from '@/stores/linkPresentationStore' import { layoutHiddenLinkBadges, queryLinkBadgeAtPoint, - queryLinkBadgeHitAtPoint + queryLinkBadgeHitAtPoint, + queryLinkBadgeStackToggledAt } from './linkBadges' import { getLinkEndpointPositions } from './linkGeometry' import { slotTypeKey } from '@/lib/litegraph/src/utils/type' @@ -29,14 +30,12 @@ export function queryHiddenLinkBadgeAtPoint( } } -/** The stack of hidden links whose pill is under a canvas point. */ -export function queryHiddenLinkStackAtPoint( - host: object, +type LinkBadgeHit = ReturnType + +function hiddenLinkStackOf( graph: LGraph, - x: number, - y: number + hit: LinkBadgeHit ): { stackKey: string; links: LLink[] } | undefined { - const hit = queryLinkBadgeHitAtPoint(host, x, y) if (!hit?.stackKey) return const scope = graphScopeOf(graph) const presentationStore = useLinkPresentationStore() @@ -49,6 +48,25 @@ export function queryHiddenLinkStackAtPoint( if (links.length) return { stackKey: hit.stackKey, links } } +/** The stack of hidden links whose pill is under a canvas point. */ +export function queryHiddenLinkStackAtPoint( + host: object, + graph: LGraph, + x: number, + y: number +): { stackKey: string; links: LLink[] } | undefined { + return hiddenLinkStackOf(graph, queryLinkBadgeHitAtPoint(host, x, y)) +} + +/** The stack of hidden links that the press at `timeStamp` expanded or collapsed. */ +export function queryHiddenLinkStackToggledAt( + host: object, + graph: LGraph, + timeStamp: number | undefined +): { stackKey: string; links: LLink[] } | undefined { + return hiddenLinkStackOf(graph, queryLinkBadgeStackToggledAt(host, timeStamp)) +} + export function layoutGraphLinkBadges( host: object, ctx: CanvasRenderingContext2D, diff --git a/src/lib/litegraph/src/canvas/linkBadges.ts b/src/lib/litegraph/src/canvas/linkBadges.ts index d19266b0061..1fbf406729d 100644 --- a/src/lib/litegraph/src/canvas/linkBadges.ts +++ b/src/lib/litegraph/src/canvas/linkBadges.ts @@ -62,6 +62,7 @@ interface BadgeEndpoint { color: string width: number layers: number + socketKey: string memberOfStack?: string hitArea: BadgeHitArea tip: Point @@ -70,6 +71,10 @@ interface BadgeEndpoint { const endpointsByHost = new WeakMap() const expandedStacksByHost = new WeakMap>() const drawnStackKeysByHost = new WeakMap>() +const lastStackToggleByHost = new WeakMap< + object, + { stackKey: string; timeStamp: number } +>() export function clearLinkBadgeHitAreas(host: object): void { endpointsByHost.delete(host) @@ -100,16 +105,49 @@ export function queryLinkBadgeAtPoint( return hit && !hit.stackKey ? hit.linkIds[0] : undefined } -export function toggleLinkBadgeStack(host: object, stackKey: string): void { +/** Expands or collapses a stack, remembering the press at `timeStamp` that did it. */ +export function toggleLinkBadgeStack( + host: object, + stackKey: string, + timeStamp = -Infinity +): void { const expanded = expandedStacksByHost.get(host) ?? new Set() if (!expanded.delete(stackKey)) expanded.add(stackKey) expandedStacksByHost.set(host, expanded) + lastStackToggleByHost.set(host, { stackKey, timeStamp }) +} + +/** The hit area of the stack that the press at `timeStamp` expanded or collapsed. */ +export function queryLinkBadgeStackToggledAt( + host: object, + timeStamp: number | undefined +): Readonly | undefined { + const last = lastStackToggleByHost.get(host) + if (timeStamp === undefined || last?.timeStamp !== timeStamp) return + return endpointsByHost + .get(host) + ?.find(({ hitArea }) => hitArea.stackKey === last.stackKey)?.hitArea +} + +/** Keeps a stack expanded under the key its links get when they all take `label`. */ +export function relabelExpandedLinkBadgeStack( + host: object, + stackKey: string, + label: string +): void { + const expanded = expandedStacksByHost.get(host) + const head = endpointsByHost + .get(host) + ?.find(({ hitArea }) => hitArea.stackKey === stackKey) + if (!head || !expanded?.delete(stackKey)) return + expanded.add(labelledStackKey(head.socketKey, label.trim())) } /** Collapses every expanded stack on the host; returns whether one was on screen. */ export function collapseLinkBadgeStacks(host: object): boolean { const expanded = expandedStacksByHost.get(host) expandedStacksByHost.delete(host) + lastStackToggleByHost.delete(host) const drawn = drawnStackKeysByHost.get(host) return [...(expanded ?? [])].some((stackKey) => drawn?.has(stackKey)) } @@ -189,16 +227,29 @@ function socketOf(link: LLink, side: BadgeSide) { : { nodeId: link.target_id, slot: link.target_slot } } -function stackKeyOf( - { link, presentation }: HiddenLinkBadge, +function socketKeyOf( + { link }: HiddenLinkBadge, side: BadgeSide, graphId: string | undefined ): string { const { nodeId, slot } = socketOf(link, side) - const label = presentation.label?.trim() const socketKey = `${side}:${nodeId}:${slot}` - const groupKey = label ? `${socketKey}=${JSON.stringify(label)}` : socketKey - return graphId ? `${graphId}/${groupKey}` : groupKey + return graphId ? `${graphId}/${socketKey}` : socketKey +} + +function labelledStackKey(socketKey: string, label: string | undefined) { + return label ? `${socketKey}=${JSON.stringify(label)}` : socketKey +} + +function stackKeyOf( + hidden: HiddenLinkBadge, + side: BadgeSide, + graphId: string | undefined +): string { + return labelledStackKey( + socketKeyOf(hidden, side, graphId), + hidden.presentation.label?.trim() + ) } function isUnlabelled({ presentation }: HiddenLinkBadge): boolean { @@ -234,6 +285,7 @@ interface EndpointSpec { text: string color: string linkIds: readonly LinkId[] + socketKey: string stackKey?: string memberOfStack?: string layers?: number @@ -244,7 +296,7 @@ function createBadgeEndpoint( spec: EndpointSpec ): BadgeEndpoint { const { link, side, rank, socket, text, color, linkIds, stackKey } = spec - const { groupOrder, memberOfStack } = spec + const { groupOrder, memberOfStack, socketKey } = spec const layers = spec.layers ?? 0 const badge = makeBadge(text, color) const width = badge.getWidth(ctx) @@ -263,6 +315,7 @@ function createBadgeEndpoint( color, width, layers, + socketKey, memberOfStack, hitArea: { linkIds, @@ -353,7 +406,8 @@ export function layoutHiddenLinkBadges( rank: isUnlabelled(hidden) ? BADGE_RANK.unlabelled : BADGE_RANK.labelled, groupOrder: stacks.get(stackKey)?.[0] ?? link.id, text: linkBadgeText(link.type, presentation), - linkIds: [link.id] + linkIds: [link.id], + socketKey: socketKeyOf(hidden, side, graphId) } if (!stacks.has(stackKey)) return addEndpoint(spec) const head = stackHead(spec, stackKey) diff --git a/src/lib/litegraph/src/canvas/linkVisibility.test.ts b/src/lib/litegraph/src/canvas/linkVisibility.test.ts index da9cf379219..46fe00f23a0 100644 --- a/src/lib/litegraph/src/canvas/linkVisibility.test.ts +++ b/src/lib/litegraph/src/canvas/linkVisibility.test.ts @@ -15,7 +15,7 @@ import { hideLink, hideLinks, promptRenameLinkBadge, - renameLink, + renameLinks, showLink } from './linkVisibility' @@ -60,17 +60,61 @@ describe('link visibility mutations', () => { const scope = graphScopeOf(new LGraph()) const host = createHost() - renameLink(host, scope, link.id, ' Backbone ') + renameLinks(host, scope, [link.id], ' Backbone ') expect( useLinkPresentationStore().getPresentation(scope, link.id)?.label ).toBe('Backbone') - renameLink(host, scope, link.id, ' ') + renameLinks(host, scope, [link.id], ' ') expect( useLinkPresentationStore().getPresentation(scope, link.id)?.label ).toBeUndefined() }) + it('renames every listed link in one undoable change', () => { + const scope = graphScopeOf(new LGraph()) + const events: string[] = [] + const host = createHost(events) + const linkIds = [toLinkId(21), toLinkId(22), toLinkId(23)] + const labels = () => + linkIds.map( + (linkId) => + useLinkPresentationStore().getPresentation(scope, linkId)?.label + ) + + renameLinks(host, scope, linkIds, ' render_size ') + + expect(labels()).toEqual(['render_size', 'render_size', 'render_size']) + expect(events).toEqual(['before', 'dirty:false:true', 'after']) + + renameLinks(host, scope, linkIds, '') + + expect(labels()).toEqual([undefined, undefined, undefined]) + }) + + it('seeds the prompt with the shared name and renames every listed link', () => { + const scope = graphScopeOf(new LGraph()) + const host = createHost() + const event = fromPartial({}) + const linkIds = [toLinkId(31), toLinkId(32)] + const store = useLinkPresentationStore() + store.patch(scope, linkIds[0], { label: 'old' }) + store.patch(scope, linkIds[1], { label: 'old' }) + + promptRenameLinkBadge(host, scope, linkIds, event) + + expect(host.prompt).toHaveBeenCalledWith( + 'Rename', + 'old', + expect.any(Function), + event + ) + host.prompt.mock.calls[0][2]('new') + expect( + linkIds.map((linkId) => store.getPresentation(scope, linkId)?.label) + ).toEqual(['new', 'new']) + }) + it('localizes and seeds the rename prompt', async () => { const link = createMockLLink({ type: 'MODEL' }) const scope = graphScopeOf(new LGraph()) @@ -84,7 +128,7 @@ describe('link visibility mutations', () => { useLinkPresentationStore().patch(scope, link.id, { label: 'Existing name' }) - promptRenameLinkBadge(host, scope, link.id, event) + promptRenameLinkBadge(host, scope, [link.id], event) expect(host.prompt).toHaveBeenCalledWith( 'Renommer', @@ -102,7 +146,7 @@ describe('link visibility mutations', () => { useLinkPresentationStore().patch(scope, link.id, { label: undefined }) host.prompt.mockClear() - promptRenameLinkBadge(host, scope, link.id, event) + promptRenameLinkBadge(host, scope, [link.id], event) expect(host.prompt).toHaveBeenCalledWith( 'Renommer', diff --git a/src/lib/litegraph/src/canvas/linkVisibility.ts b/src/lib/litegraph/src/canvas/linkVisibility.ts index 02afb0fc5fe..53a5176d39c 100644 --- a/src/lib/litegraph/src/canvas/linkVisibility.ts +++ b/src/lib/litegraph/src/canvas/linkVisibility.ts @@ -100,9 +100,10 @@ export function deleteLinks( } export function getLinkStackMenuOptions(): IContextMenuValue[] { - return [ - { content: st('contextMenu.Show Links', 'Show Links'), value: 'Show Links' } - ] + return ['Rename', 'Show Links'].map((value) => ({ + content: st(`contextMenu.${value}`, value), + value + })) } export function getVisibleRerouteLink( @@ -129,29 +130,34 @@ export function showLink( }) } -export function renameLink( +export function renameLinks( host: LinkMutationHost, scope: GraphScope, - linkId: LinkId, + linkIds: Iterable, value: string ): void { - mutateLink(host, () => - useLinkPresentationStore().patch(scope, linkId, { - label: value.trim() || undefined - }) - ) + const label = value.trim() || undefined + mutateLink(host, () => { + const store = useLinkPresentationStore() + for (const linkId of linkIds) store.patch(scope, linkId, { label }) + }) } +/** Prompts for one name and gives it to every listed link, seeded with the first link's name. */ export function promptRenameLinkBadge( host: LinkRenameHost, scope: GraphScope, - linkId: LinkId, - event: CanvasPointerEvent + linkIds: readonly LinkId[], + event: CanvasPointerEvent, + onRename?: (value: string) => void ): void { host.prompt( t('contextMenu.Rename'), - useLinkPresentationStore().getPresentation(scope, linkId)?.label ?? '', - (value) => renameLink(host, scope, linkId, value), + useLinkPresentationStore().getPresentation(scope, linkIds[0])?.label ?? '', + (value) => { + renameLinks(host, scope, linkIds, value) + onRename?.(value) + }, event ) } diff --git a/src/lib/litegraph/src/canvas/reduceGesture.ts b/src/lib/litegraph/src/canvas/reduceGesture.ts index f3161539e2f..3f1cbbc9f3e 100644 --- a/src/lib/litegraph/src/canvas/reduceGesture.ts +++ b/src/lib/litegraph/src/canvas/reduceGesture.ts @@ -70,6 +70,15 @@ function isDoubleClick( ) } +/** The earlier click that the current press double-clicks if it ends as a click. */ +export function doubleClickedClick( + state: GestureState +): ClickRecord | undefined { + return state.phase === 'pressed' && isDoubleClick(state) + ? state.lastClick + : undefined +} + function unchanged(state: GestureState): GestureResult { return { state, effects: [] } } diff --git a/src/lib/litegraph/src/canvas/resolvePointerTarget.ts b/src/lib/litegraph/src/canvas/resolvePointerTarget.ts index 2f9c8e8057e..e4e24f0ad5c 100644 --- a/src/lib/litegraph/src/canvas/resolvePointerTarget.ts +++ b/src/lib/litegraph/src/canvas/resolvePointerTarget.ts @@ -33,7 +33,7 @@ import { export type PointerTarget = | { kind: 'node'; node: LGraphNode } | { kind: 'linkBadge'; link: LLink } - | { kind: 'linkBadgeStack'; stackKey: string } + | { kind: 'linkBadgeStack'; stackKey: string; links: LLink[] } | { kind: 'subgraphIO'; ioNode: SubgraphInputNode | SubgraphOutputNode } | { kind: 'reroute'; reroute: Reroute; part: 'body' | 'input' | 'output' } | { kind: 'link'; segment: LinkSegment } @@ -55,7 +55,7 @@ export function resolvePointerTarget( const point: Point = [e.canvasX, e.canvasY] const stack = queryHiddenLinkStackAtPoint(canvas, graph, ...point) - if (stack) return { kind: 'linkBadgeStack', stackKey: stack.stackKey } + if (stack) return { kind: 'linkBadgeStack', ...stack } const badgeLink = queryHiddenLinkBadgeAtPoint( canvas,