diff --git a/browser_tests/tests/vueNodes/interactions/node/alignment.spec.ts b/browser_tests/tests/vueNodes/interactions/node/alignment.spec.ts
new file mode 100644
index 00000000000..247d6d38cdc
--- /dev/null
+++ b/browser_tests/tests/vueNodes/interactions/node/alignment.spec.ts
@@ -0,0 +1,110 @@
+import { expect } from '@playwright/test'
+
+import { comfyPageFixture as test } from '../../../../fixtures/ComfyPage'
+import type { ComfyPage } from '../../../../fixtures/ComfyPage'
+
+async function getNodeHeader(comfyPage: ComfyPage, title: string) {
+ const node = comfyPage.vueNodes.getNodeByTitle(title).first()
+ await expect(node).toBeVisible()
+ return node.locator('.lg-node-header')
+}
+
+async function selectTwoNodes(comfyPage: ComfyPage) {
+ const checkpointHeader = await getNodeHeader(comfyPage, 'Load Checkpoint')
+ const ksamplerHeader = await getNodeHeader(comfyPage, 'KSampler')
+
+ await checkpointHeader.click()
+ await ksamplerHeader.click({ modifiers: ['Control'] })
+ await comfyPage.nextFrame()
+}
+
+test.describe('Vue Node Alignment', { tag: '@ui' }, () => {
+ test.beforeEach(async ({ comfyPage }) => {
+ await comfyPage.settings.setSetting('Comfy.UseNewMenu', 'Disabled')
+ await comfyPage.settings.setSetting('Comfy.VueNodes.Enabled', true)
+ await comfyPage.settings.setSetting('Comfy.Canvas.SelectionToolbox', true)
+ await comfyPage.workflow.loadWorkflow('default')
+ await comfyPage.canvasOps.resetView()
+ await comfyPage.vueNodes.waitForNodes(6)
+ })
+
+ test('snaps a dragged node to another node in Vue nodes mode', async ({
+ comfyPage
+ }) => {
+ await comfyPage.settings.setSetting(
+ 'Comfy.Canvas.AlignNodesWhileDragging',
+ true
+ )
+
+ const ksamplerNode = comfyPage.vueNodes.getNodeByTitle('KSampler').first()
+ const checkpointNode = comfyPage.vueNodes
+ .getNodeByTitle('Load Checkpoint')
+ .first()
+ const ksamplerHeader = ksamplerNode.locator('.lg-node-header')
+
+ const ksamplerBox = await ksamplerNode.boundingBox()
+ const checkpointBox = await checkpointNode.boundingBox()
+ const headerBox = await ksamplerHeader.boundingBox()
+
+ if (!ksamplerBox || !checkpointBox || !headerBox) {
+ throw new Error('Expected Vue node bounding boxes to be available')
+ }
+
+ const dragStart = {
+ x: headerBox.x + headerBox.width / 2,
+ y: headerBox.y + headerBox.height / 2
+ }
+ const targetLeft = checkpointBox.x + 5
+ const dragTarget = {
+ x: dragStart.x + (targetLeft - ksamplerBox.x),
+ y: dragStart.y
+ }
+
+ await comfyPage.canvasOps.dragAndDrop(dragStart, dragTarget)
+
+ await expect
+ .poll(async () => {
+ const draggedBox = await ksamplerNode.boundingBox()
+ return draggedBox ? Math.round(draggedBox.x) : null
+ })
+ .toBe(Math.round(checkpointBox.x))
+ })
+
+ test('shows center alignment actions from the multi-node right-click menu', async ({
+ comfyPage
+ }) => {
+ await selectTwoNodes(comfyPage)
+
+ const ksamplerHeader = await getNodeHeader(comfyPage, 'KSampler')
+ await ksamplerHeader.click({ button: 'right' })
+
+ const alignMenuItem = comfyPage.page.getByText('Align Selected To', {
+ exact: true
+ })
+ await expect(alignMenuItem).toBeVisible()
+ await alignMenuItem.hover()
+
+ await expect(
+ comfyPage.page.getByText('Horizontal Center', { exact: true })
+ ).toBeVisible()
+ await expect(
+ comfyPage.page.getByText('Vertical Center', { exact: true })
+ ).toBeVisible()
+ })
+
+ test('does not show alignment actions from the selection toolbox More Options menu', async ({
+ comfyPage
+ }) => {
+ await selectTwoNodes(comfyPage)
+ await expect(comfyPage.selectionToolbox).toBeVisible()
+
+ await comfyPage.page.click('[data-testid="more-options-button"]')
+
+ await expect(
+ comfyPage.page.getByText('Rename', { exact: true })
+ ).toBeVisible()
+ await expect(
+ comfyPage.page.getByText('Align Selected To', { exact: true })
+ ).not.toBeVisible()
+ })
+})
diff --git a/src/components/graph/selectionToolbox/NodeOptionsButton.vue b/src/components/graph/selectionToolbox/NodeOptionsButton.vue
index df70ad4906d..7f16d87626c 100644
--- a/src/components/graph/selectionToolbox/NodeOptionsButton.vue
+++ b/src/components/graph/selectionToolbox/NodeOptionsButton.vue
@@ -18,6 +18,6 @@ import Button from '@/components/ui/button/Button.vue'
import { toggleNodeOptions } from '@/composables/graph/useMoreOptionsMenu'
const handleClick = (event: Event) => {
- toggleNodeOptions(event)
+ toggleNodeOptions(event, 'toolbar')
}
diff --git a/src/components/rightSidePanel/settings/TabGlobalSettings.vue b/src/components/rightSidePanel/settings/TabGlobalSettings.vue
index 8cd5873dbab..9d47dbfe703 100644
--- a/src/components/rightSidePanel/settings/TabGlobalSettings.vue
+++ b/src/components/rightSidePanel/settings/TabGlobalSettings.vue
@@ -50,6 +50,12 @@ const snapToGrid = computed({
set: (value) => settingStore.set('pysssss.SnapToGrid', value)
})
+const alignNodesWhileDragging = computed({
+ get: () => settingStore.get('Comfy.Canvas.AlignNodesWhileDragging'),
+ set: (value) =>
+ settingStore.set('Comfy.Canvas.AlignNodesWhileDragging', value)
+})
+
// CONNECTION LINKS settings
const linkShape = computed({
get: () => settingStore.get('Comfy.Graph.LinkMarkers'),
@@ -160,6 +166,11 @@ function openFullSettings() {
:label="t('rightSidePanel.globalSettings.snapNodesToGrid')"
:tooltip="t('settings.pysssss_SnapToGrid.tooltip')"
/>
+
diff --git a/src/composables/graph/contextMenuConverter.ts b/src/composables/graph/contextMenuConverter.ts
index 905f2934d74..10421eecd32 100644
--- a/src/composables/graph/contextMenuConverter.ts
+++ b/src/composables/graph/contextMenuConverter.ts
@@ -45,6 +45,8 @@ const CORE_MENU_ITEMS = new Set([
'Convert to Subgraph',
'Frame selection',
'Frame Nodes',
+ 'Align Selected To',
+ 'Distribute Nodes',
'Minimize Node',
'Expand',
'Collapse',
@@ -229,6 +231,8 @@ const MENU_ORDER: string[] = [
'Convert to Subgraph',
'Frame selection',
'Frame Nodes',
+ 'Align Selected To',
+ 'Distribute Nodes',
'Minimize Node',
'Expand',
'Collapse',
@@ -301,14 +305,14 @@ export function buildStructuredMenu(options: MenuOption[]): MenuOption[] {
// Section boundaries based on MENU_ORDER indices
// Section 1: 0-2 (Rename, Copy, Duplicate)
// Section 2: 3-8 (Run Branch, Pin, Unpin, Bypass, Remove Bypass, Mute)
- // Section 3: 9-15 (Convert to Subgraph, Frame selection, Minimize Node, Expand, Collapse, Resize, Clone)
- // Section 4: 16-17 (Node Info, Color)
- // Section 5: 18+ (Image operations and fallback items)
+ // Section 3: 9-17 (Convert to Subgraph ... Clone)
+ // Section 4: 18-19 (Node Info, Color)
+ // Section 5: 20+ (Image operations and fallback items)
const getSectionNumber = (index: number): number => {
if (index <= 2) return 1
if (index <= 8) return 2
- if (index <= 15) return 3
- if (index <= 17) return 4
+ if (index <= 17) return 3
+ if (index <= 19) return 4
return 5
}
diff --git a/src/composables/graph/useMoreOptionsMenu.test.ts b/src/composables/graph/useMoreOptionsMenu.test.ts
new file mode 100644
index 00000000000..74981884479
--- /dev/null
+++ b/src/composables/graph/useMoreOptionsMenu.test.ts
@@ -0,0 +1,108 @@
+import { computed, ref } from 'vue'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+import {
+ showNodeOptions,
+ toggleNodeOptions,
+ useMoreOptionsMenu
+} from '@/composables/graph/useMoreOptionsMenu'
+
+const selectedItems = ref([{ id: 'node-1' }, { id: 'node-2' }])
+const selectedNodes = ref([{ id: 'node-1' }, { id: 'node-2' }])
+
+vi.mock('@/renderer/core/canvas/canvasStore', () => ({
+ useCanvasStore: () => ({
+ canvas: null
+ })
+}))
+
+vi.mock('@/utils/litegraphUtil', () => ({
+ isLGraphGroup: () => false
+}))
+
+vi.mock('@/composables/graph/useSelectionState', () => ({
+ useSelectionState: () => ({
+ selectedItems: computed(() => selectedItems.value),
+ selectedNodes: computed(() => selectedNodes.value),
+ nodeDef: computed(() => null),
+ showNodeHelp: vi.fn(),
+ hasSubgraphs: computed(() => false),
+ hasImageNode: computed(() => false),
+ hasOutputNodesSelected: computed(() => false),
+ hasMultipleSelection: computed(() => true),
+ computeSelectionFlags: () => ({
+ collapsed: false,
+ pinned: false,
+ bypassed: false
+ })
+ })
+}))
+
+vi.mock('@/composables/graph/useImageMenuOptions', () => ({
+ useImageMenuOptions: () => ({
+ getImageMenuOptions: () => []
+ })
+}))
+
+vi.mock('@/composables/graph/useNodeMenuOptions', () => ({
+ useNodeMenuOptions: () => ({
+ getNodeInfoOption: () => ({ label: 'Node Info' }),
+ getNodeVisualOptions: () => [],
+ getPinOption: () => ({ label: 'Pin' }),
+ getBypassOption: () => ({ label: 'Bypass' }),
+ getRunBranchOption: () => ({ label: 'Run Branch' })
+ })
+}))
+
+vi.mock('@/composables/graph/useGroupMenuOptions', () => ({
+ useGroupMenuOptions: () => ({
+ getFitGroupToNodesOption: () => ({ label: 'Fit Group to Nodes' }),
+ getGroupColorOptions: () => ({ label: 'Group Color' }),
+ getGroupModeOptions: () => []
+ })
+}))
+
+vi.mock('@/composables/graph/useSelectionMenuOptions', () => ({
+ useSelectionMenuOptions: () => ({
+ getBasicSelectionOptions: () => [{ label: 'Rename' }],
+ getMultipleNodesOptions: () => [{ label: 'Frame Nodes' }],
+ getSubgraphOptions: () => [],
+ getAlignmentOptions: () => [{ label: 'Align Selected To' }]
+ })
+}))
+
+vi.mock('@/core/graph/subgraph/promotedWidgetTypes', () => ({
+ isPromotedWidgetView: () => false
+}))
+
+vi.mock('@/services/litegraphService', () => ({
+ getExtraOptionsForWidget: () => []
+}))
+
+describe('useMoreOptionsMenu', () => {
+ beforeEach(() => {
+ selectedItems.value = [{ id: 'node-1' }, { id: 'node-2' }]
+ selectedNodes.value = [{ id: 'node-1' }, { id: 'node-2' }]
+ toggleNodeOptions(new Event('click'), 'toolbar')
+ })
+
+ it('adds alignment options for right-click menus only', () => {
+ const { menuOptions } = useMoreOptionsMenu()
+
+ expect(
+ menuOptions.value.some((option) => option.label === 'Align Selected To')
+ ).toBe(false)
+
+ showNodeOptions(new MouseEvent('contextmenu'))
+
+ expect(
+ menuOptions.value.some((option) => option.label === 'Align Selected To')
+ ).toBe(true)
+
+ toggleNodeOptions(new Event('click'), 'toolbar')
+
+ expect(
+ menuOptions.value.some((option) => option.label === 'Align Selected To')
+ ).toBe(false)
+ })
+})
diff --git a/src/composables/graph/useMoreOptionsMenu.ts b/src/composables/graph/useMoreOptionsMenu.ts
index 349a1d7f944..e210f8de6ae 100644
--- a/src/composables/graph/useMoreOptionsMenu.ts
+++ b/src/composables/graph/useMoreOptionsMenu.ts
@@ -43,6 +43,8 @@ export interface SubMenuOption {
disabled?: boolean
}
+type NodeOptionsTriggerSource = 'contextmenu' | 'toolbar'
+
export enum BadgeVariant {
NEW = 'new',
DEPRECATED = 'deprecated'
@@ -50,6 +52,7 @@ export enum BadgeVariant {
// Global singleton for NodeOptions component reference
let nodeOptionsInstance: null | NodeOptionsInstance = null
+const nodeOptionsTriggerSource = ref('toolbar')
const hoveredWidget = ref<[string, NodeId | undefined]>()
@@ -57,7 +60,11 @@ const hoveredWidget = ref<[string, NodeId | undefined]>()
* Toggle the node options popover
* @param event - The trigger event
*/
-export function toggleNodeOptions(event: Event) {
+export function toggleNodeOptions(
+ event: Event,
+ triggerSource: NodeOptionsTriggerSource = 'toolbar'
+) {
+ nodeOptionsTriggerSource.value = triggerSource
if (nodeOptionsInstance?.toggle) {
nodeOptionsInstance.toggle(event)
}
@@ -71,8 +78,10 @@ export function toggleNodeOptions(event: Event) {
export function showNodeOptions(
event: MouseEvent,
widgetName?: string,
- nodeId?: NodeId
+ nodeId?: NodeId,
+ triggerSource: NodeOptionsTriggerSource = 'contextmenu'
) {
+ nodeOptionsTriggerSource.value = triggerSource
hoveredWidget.value = widgetName ? [widgetName, nodeId] : undefined
if (nodeOptionsInstance?.show) {
nodeOptionsInstance.show(event)
@@ -147,7 +156,8 @@ export function useMoreOptionsMenu() {
const {
getBasicSelectionOptions,
getMultipleNodesOptions,
- getSubgraphOptions
+ getSubgraphOptions,
+ getAlignmentOptions
} = useSelectionMenuOptions()
const hasSubgraphs = hasSubgraphsComputed
@@ -227,6 +237,9 @@ export function useMoreOptionsMenu() {
)
if (hasMultipleNodes.value) {
options.push(...getMultipleNodesOptions())
+ if (nodeOptionsTriggerSource.value === 'contextmenu') {
+ options.push(...getAlignmentOptions(selectedNodes.value.length))
+ }
}
if (groupContext) {
options.push(getFitGroupToNodesOption(groupContext))
diff --git a/src/composables/graph/useNodeArrangement.ts b/src/composables/graph/useNodeArrangement.ts
index 2df6ec4a6f5..db91ccfe4ee 100644
--- a/src/composables/graph/useNodeArrangement.ts
+++ b/src/composables/graph/useNodeArrangement.ts
@@ -1,6 +1,6 @@
import { useI18n } from 'vue-i18n'
-import type { Direction } from '@/lib/litegraph/src/interfaces'
+import type { ArrangementDirection } from '@/lib/litegraph/src/interfaces'
import { alignNodes, distributeNodes } from '@/lib/litegraph/src/utils/arrange'
import { useCanvasStore } from '@/renderer/core/canvas/canvasStore'
import { isLGraphNode } from '@/utils/litegraphUtil'
@@ -10,7 +10,7 @@ import { useCanvasRefresh } from './useCanvasRefresh'
interface AlignOption {
name: string
localizedName: string
- value: Direction
+ value: ArrangementDirection
icon: string
}
@@ -52,6 +52,18 @@ export function useNodeArrangement() {
localizedName: t('contextMenu.Right'),
value: 'right',
icon: 'icon-[lucide--align-end-horizontal]'
+ },
+ {
+ name: 'horizontal-center',
+ localizedName: t('contextMenu.Horizontal Center'),
+ value: 'horizontal-center',
+ icon: 'icon-[lucide--align-center-horizontal]'
+ },
+ {
+ name: 'vertical-center',
+ localizedName: t('contextMenu.Vertical Center'),
+ value: 'vertical-center',
+ icon: 'icon-[lucide--align-center-vertical]'
}
]
@@ -75,7 +87,7 @@ export function useNodeArrangement() {
isLGraphNode(item)
)
- if (selectedNodes.length === 0) {
+ if (selectedNodes.length < 2) {
return
}
@@ -90,7 +102,7 @@ export function useNodeArrangement() {
isLGraphNode(item)
)
- if (selectedNodes.length < 2) {
+ if (selectedNodes.length < 3) {
return
}
diff --git a/src/composables/graph/useSelectionMenuOptions.test.ts b/src/composables/graph/useSelectionMenuOptions.test.ts
index b35544e87dc..bc6be191499 100644
--- a/src/composables/graph/useSelectionMenuOptions.test.ts
+++ b/src/composables/graph/useSelectionMenuOptions.test.ts
@@ -81,6 +81,27 @@ describe('useSelectionMenuOptions - multiple nodes options', () => {
)
expect(groupNodeOption).toBeDefined()
})
+
+ it('returns align options for two selected nodes', () => {
+ const { getAlignmentOptions } = useSelectionMenuOptions()
+
+ const options = getAlignmentOptions(2)
+
+ expect(options.map((option) => option.label)).toEqual([
+ 'contextMenu.Align Selected To'
+ ])
+ })
+
+ it('returns align and distribute options for three selected nodes', () => {
+ const { getAlignmentOptions } = useSelectionMenuOptions()
+
+ const options = getAlignmentOptions(3)
+
+ expect(options.map((option) => option.label)).toEqual([
+ 'contextMenu.Align Selected To',
+ 'contextMenu.Distribute Nodes'
+ ])
+ })
})
describe('useSelectionMenuOptions - subgraph options', () => {
diff --git a/src/composables/graph/useSelectionMenuOptions.ts b/src/composables/graph/useSelectionMenuOptions.ts
index b571f9ab5de..e68f792c5bc 100644
--- a/src/composables/graph/useSelectionMenuOptions.ts
+++ b/src/composables/graph/useSelectionMenuOptions.ts
@@ -125,22 +125,31 @@ export function useSelectionMenuOptions() {
]
}
- const getAlignmentOptions = (): MenuOption[] => [
- {
- label: t('contextMenu.Align Selected To'),
- icon: 'icon-[lucide--align-start-horizontal]',
- hasSubmenu: true,
- submenu: alignSubmenu.value,
- action: () => {}
- },
- {
- label: t('contextMenu.Distribute Nodes'),
- icon: 'icon-[lucide--align-center-horizontal]',
- hasSubmenu: true,
- submenu: distributeSubmenu.value,
- action: () => {}
+ const getAlignmentOptions = (selectedNodeCount: number): MenuOption[] => {
+ const options: MenuOption[] = []
+
+ if (selectedNodeCount >= 2) {
+ options.push({
+ label: t('contextMenu.Align Selected To'),
+ icon: 'icon-[lucide--align-start-horizontal]',
+ hasSubmenu: true,
+ submenu: alignSubmenu.value,
+ action: () => {}
+ })
}
- ]
+
+ if (selectedNodeCount >= 3) {
+ options.push({
+ label: t('contextMenu.Distribute Nodes'),
+ icon: 'icon-[lucide--align-center-horizontal]',
+ hasSubmenu: true,
+ submenu: distributeSubmenu.value,
+ action: () => {}
+ })
+ }
+
+ return options
+ }
const getDeleteOption = (): MenuOption => ({
label: t('contextMenu.Delete'),
diff --git a/src/lib/litegraph/src/LGraphCanvas.ts b/src/lib/litegraph/src/LGraphCanvas.ts
index 16295d56aea..3c5875d5e75 100644
--- a/src/lib/litegraph/src/LGraphCanvas.ts
+++ b/src/lib/litegraph/src/LGraphCanvas.ts
@@ -40,7 +40,7 @@ import type {
ContextMenuDivElement,
DefaultConnectionColors,
Dictionary,
- Direction,
+ ArrangementDirection,
IBoundaryNodes,
IColorable,
IContextMenuOptions,
@@ -1053,7 +1053,7 @@ export class LGraphCanvas implements CustomEventDispatcher
*/
static alignNodes(
nodes: Dictionary,
- direction: Direction,
+ direction: ArrangementDirection,
align_to?: LGraphNode
): void {
const newPositions = alignNodes(Object.values(nodes), direction, align_to)
@@ -1077,7 +1077,7 @@ export class LGraphCanvas implements CustomEventDispatcher
function inner_clicked(value: string) {
const newPositions = alignNodes(
Object.values(LGraphCanvas.active_canvas.selected_nodes),
- value.toLowerCase() as Direction,
+ value.toLowerCase() as ArrangementDirection,
node
)
LGraphCanvas.active_canvas.repositionNodesVueMode(newPositions)
@@ -1100,7 +1100,7 @@ export class LGraphCanvas implements CustomEventDispatcher
function inner_clicked(value: string) {
const newPositions = alignNodes(
Object.values(LGraphCanvas.active_canvas.selected_nodes),
- value.toLowerCase() as Direction
+ value.toLowerCase() as ArrangementDirection
)
LGraphCanvas.active_canvas.repositionNodesVueMode(newPositions)
LGraphCanvas.active_canvas.setDirty(true, true)
@@ -4923,6 +4923,7 @@ export class LGraphCanvas implements CustomEventDispatcher
if (!LiteGraph.vueNodesMode || !this.overlayCtx) {
this._drawConnectingLinks(ctx)
+ this._drawVueDragAlignmentGuides(ctx)
} else {
this._drawOverlayLinks()
}
@@ -5027,7 +5028,8 @@ export class LGraphCanvas implements CustomEventDispatcher
octx.clearRect(0, 0, overlayCanvas.width, overlayCanvas.height)
- if (!this.linkConnector.isConnecting) return
+ const hasDragGuides = layoutStore.vueDragSnapGuides.value.length > 0
+ if (!this.linkConnector.isConnecting && !hasDragGuides) return
octx.save()
@@ -5036,11 +5038,39 @@ export class LGraphCanvas implements CustomEventDispatcher
this.ds.toCanvasContext(octx)
- this._drawConnectingLinks(octx)
+ if (this.linkConnector.isConnecting) {
+ this._drawConnectingLinks(octx)
+ }
+ this._drawVueDragAlignmentGuides(octx)
octx.restore()
}
+ private _drawVueDragAlignmentGuides(ctx: CanvasRenderingContext2D): void {
+ const guides = layoutStore.vueDragSnapGuides.value
+ if (!guides.length) return
+
+ const scale = this.ds.scale || 1
+ ctx.save()
+ ctx.beginPath()
+ ctx.lineWidth = 1 / scale
+ ctx.strokeStyle = '#ff4d4f'
+ ctx.setLineDash([6 / scale, 4 / scale])
+
+ for (const guide of guides) {
+ if (guide.axis === 'vertical') {
+ ctx.moveTo(guide.coordinate, guide.start)
+ ctx.lineTo(guide.coordinate, guide.end)
+ } else {
+ ctx.moveTo(guide.start, guide.coordinate)
+ ctx.lineTo(guide.end, guide.coordinate)
+ }
+ }
+
+ ctx.stroke()
+ ctx.restore()
+ }
+
/** Get the target snap / highlight point in graph space */
private _getHighlightPosition(): Readonly {
return LiteGraph.snaps_for_comfy
diff --git a/src/lib/litegraph/src/interfaces.ts b/src/lib/litegraph/src/interfaces.ts
index b0bbc884fc3..66e055dc515 100644
--- a/src/lib/litegraph/src/interfaces.ts
+++ b/src/lib/litegraph/src/interfaces.ts
@@ -281,7 +281,13 @@ export interface IBoundaryNodes {
left: LGraphNode
}
-export type Direction = 'top' | 'bottom' | 'left' | 'right'
+export type ArrangementDirection =
+ | 'top'
+ | 'bottom'
+ | 'left'
+ | 'right'
+ | 'horizontal-center'
+ | 'vertical-center'
/** Resize handle positions (compass points) */
export type CompassCorners = 'NE' | 'SE' | 'SW' | 'NW'
diff --git a/src/lib/litegraph/src/utils/arrange.ts b/src/lib/litegraph/src/utils/arrange.ts
index 7408fa3a685..9bcf0a93a86 100644
--- a/src/lib/litegraph/src/utils/arrange.ts
+++ b/src/lib/litegraph/src/utils/arrange.ts
@@ -1,5 +1,18 @@
import type { LGraphNode } from '../LGraphNode'
-import type { Direction, IBoundaryNodes, NewNodePosition } from '../interfaces'
+import type {
+ ArrangementDirection,
+ IBoundaryNodes,
+ NewNodePosition
+} from '../interfaces'
+
+interface NodeSelectionBounds {
+ top: number
+ right: number
+ bottom: number
+ left: number
+ centerX: number
+ centerY: number
+}
/**
* Finds the nodes that are farthest in all four directions, representing the boundary of the nodes.
@@ -45,7 +58,7 @@ export function distributeNodes(
horizontal?: boolean
): NewNodePosition[] {
const nodeCount = nodes?.length
- if (!(nodeCount > 1)) return []
+ if (!(nodeCount > 2)) return []
const index = horizontal ? 0 : 1
@@ -88,7 +101,7 @@ export function distributeNodes(
*/
export function alignNodes(
nodes: LGraphNode[],
- direction: Direction,
+ direction: ArrangementDirection,
align_to?: LGraphNode
): NewNodePosition[] {
if (!nodes) return []
@@ -100,6 +113,16 @@ export function alignNodes(
if (boundary === null) return []
+ const selectionBounds = getNodeSelectionBounds(nodes)
+ const alignToCenterX =
+ align_to === undefined
+ ? selectionBounds.centerX
+ : align_to.pos[0] + align_to.size[0] * 0.5
+ const alignToCenterY =
+ align_to === undefined
+ ? selectionBounds.centerY
+ : align_to.pos[1] + align_to.size[1] * 0.5
+
const nodePositions = nodes.map((node): NewNodePosition => {
switch (direction) {
case 'right':
@@ -134,6 +157,22 @@ export function alignNodes(
y: boundary.bottom.pos[1] + boundary.bottom.size[1] - node.size[1]
}
}
+ case 'horizontal-center':
+ return {
+ node,
+ newPos: {
+ x: node.pos[0],
+ y: alignToCenterY - node.size[1] * 0.5
+ }
+ }
+ case 'vertical-center':
+ return {
+ node,
+ newPos: {
+ x: alignToCenterX - node.size[0] * 0.5,
+ y: node.pos[1]
+ }
+ }
}
})
@@ -142,3 +181,24 @@ export function alignNodes(
}
return nodePositions
}
+
+function getNodeSelectionBounds(nodes: LGraphNode[]): NodeSelectionBounds {
+ const boundary = getBoundaryNodes(nodes)
+ if (!boundary) {
+ throw new TypeError('Cannot calculate selection bounds without nodes.')
+ }
+
+ const top = boundary.top.pos[1]
+ const left = boundary.left.pos[0]
+ const right = boundary.right.pos[0] + boundary.right.size[0]
+ const bottom = boundary.bottom.pos[1] + boundary.bottom.size[1]
+
+ return {
+ top,
+ right,
+ bottom,
+ left,
+ centerX: left + (right - left) * 0.5,
+ centerY: top + (bottom - top) * 0.5
+ }
+}
diff --git a/src/locales/en/main.json b/src/locales/en/main.json
index 19f9ea233ba..3dd9e0c8c22 100644
--- a/src/locales/en/main.json
+++ b/src/locales/en/main.json
@@ -546,6 +546,8 @@
"Bottom": "Bottom",
"Left": "Left",
"Right": "Right",
+ "Horizontal Center": "Horizontal Center",
+ "Vertical Center": "Vertical Center",
"Horizontal": "Horizontal",
"Vertical": "Vertical",
"new": "new",
@@ -3335,6 +3337,7 @@
"nodes2": "Nodes 2.0",
"gridSpacing": "Grid spacing",
"snapNodesToGrid": "Snap nodes to grid",
+ "alignNodesWhileDragging": "Align nodes while dragging",
"linkShape": "Link shape",
"showConnectedLinks": "Show connected links",
"viewAllSettings": "View all settings"
diff --git a/src/locales/en/settings.json b/src/locales/en/settings.json
index 7d11e30c8d7..1cd06401064 100644
--- a/src/locales/en/settings.json
+++ b/src/locales/en/settings.json
@@ -55,6 +55,10 @@
"name": "Show selection toolbox",
"tooltip": "Display a floating toolbar when nodes are selected, providing quick access to common actions."
},
+ "Comfy_Canvas_AlignNodesWhileDragging": {
+ "name": "Align nodes while dragging",
+ "tooltip": "When enabled in Nodes 2.0, dragging a node selection near another node will snap matching edges and centers together."
+ },
"Comfy_ConfirmClear": {
"name": "Require confirmation when clearing workflow"
},
diff --git a/src/platform/settings/constants/coreSettings.ts b/src/platform/settings/constants/coreSettings.ts
index b65c52a3d2f..760429025b7 100644
--- a/src/platform/settings/constants/coreSettings.ts
+++ b/src/platform/settings/constants/coreSettings.ts
@@ -996,6 +996,16 @@ export const CORE_SETTINGS: SettingParams[] = [
defaultValue: true,
versionAdded: '1.10.5'
},
+ {
+ id: 'Comfy.Canvas.AlignNodesWhileDragging',
+ category: ['LiteGraph', 'Canvas', 'AlignNodesWhileDragging'],
+ name: 'Align nodes while dragging',
+ tooltip:
+ 'When enabled in Nodes 2.0, dragging a node selection near another node will snap matching edges and centers together.',
+ type: 'boolean',
+ defaultValue: false,
+ versionAdded: '1.31.0'
+ },
{
id: 'LiteGraph.Reroute.SplineOffset',
name: 'Reroute spline offset',
diff --git a/src/renderer/core/layout/store/layoutStore.ts b/src/renderer/core/layout/store/layoutStore.ts
index d5bab8031eb..8025d3d244f 100644
--- a/src/renderer/core/layout/store/layoutStore.ts
+++ b/src/renderer/core/layout/store/layoutStore.ts
@@ -9,6 +9,7 @@ import { computed, customRef, ref } from 'vue'
import type { ComputedRef, Ref } from 'vue'
import * as Y from 'yjs'
+import type { NodeAlignmentGuide } from '@/renderer/extensions/vueNodes/layout/nodeAlignmentSnap'
import { removeNodeTitleHeight } from '@/renderer/core/layout/utils/nodeSizeUtil'
import { ACTOR_CONFIG } from '@/renderer/core/layout/constants'
@@ -138,6 +139,7 @@ class LayoutStoreImpl implements LayoutStore {
// Vue dragging state for selection toolbox (public ref for direct mutation)
public isDraggingVueNodes = ref(false)
+ public vueDragSnapGuides = ref([])
// Vue resizing state to prevent drag from activating during resize
public isResizingVueNodes = ref(false)
diff --git a/src/renderer/extensions/vueNodes/components/LGraphNode.vue b/src/renderer/extensions/vueNodes/components/LGraphNode.vue
index e70c907158d..cf99ab12859 100644
--- a/src/renderer/extensions/vueNodes/components/LGraphNode.vue
+++ b/src/renderer/extensions/vueNodes/components/LGraphNode.vue
@@ -426,7 +426,7 @@ const handleContextMenu = (event: MouseEvent) => {
handleNodeRightClick(event as PointerEvent, nodeData.id)
// Show the node options menu at the cursor position
- showNodeOptions(event)
+ showNodeOptions(event, undefined, undefined, 'contextmenu')
}
/**
diff --git a/src/renderer/extensions/vueNodes/components/NodeWidgets.vue b/src/renderer/extensions/vueNodes/components/NodeWidgets.vue
index f1fa7509dcd..bb70dc22570 100644
--- a/src/renderer/extensions/vueNodes/components/NodeWidgets.vue
+++ b/src/renderer/extensions/vueNodes/components/NodeWidgets.vue
@@ -275,7 +275,8 @@ const processedWidgets = computed((): ProcessedWidget[] => {
widget.name,
widget.nodeId !== undefined
? String(stripGraphPrefix(widget.nodeId))
- : undefined
+ : undefined,
+ 'contextmenu'
)
}
diff --git a/src/renderer/extensions/vueNodes/composables/useNodePointerInteractions.ts b/src/renderer/extensions/vueNodes/composables/useNodePointerInteractions.ts
index 0dfdae51b16..f1842f476c3 100644
--- a/src/renderer/extensions/vueNodes/composables/useNodePointerInteractions.ts
+++ b/src/renderer/extensions/vueNodes/composables/useNodePointerInteractions.ts
@@ -102,6 +102,7 @@ export function useNodePointerInteractions(
function cleanupDragState() {
layoutStore.isDraggingVueNodes.value = false
+ layoutStore.vueDragSnapGuides.value = []
}
function safeDragStart(event: PointerEvent, nodeId: string) {
diff --git a/src/renderer/extensions/vueNodes/layout/nodeAlignmentSnap.test.ts b/src/renderer/extensions/vueNodes/layout/nodeAlignmentSnap.test.ts
new file mode 100644
index 00000000000..04642174569
--- /dev/null
+++ b/src/renderer/extensions/vueNodes/layout/nodeAlignmentSnap.test.ts
@@ -0,0 +1,128 @@
+import { describe, expect, it } from 'vitest'
+
+import { resolveNodeAlignmentSnap } from './nodeAlignmentSnap'
+
+describe('resolveNodeAlignmentSnap', () => {
+ const selectionBounds = {
+ x: 0,
+ y: 0,
+ width: 100,
+ height: 80
+ }
+
+ it('snaps matching edges within threshold', () => {
+ const result = resolveNodeAlignmentSnap({
+ selectionBounds,
+ candidateBounds: [
+ {
+ x: 200,
+ y: 0,
+ width: 100,
+ height: 80
+ }
+ ],
+ delta: { x: 193, y: 0 },
+ zoomScale: 1
+ })
+
+ expect(result.delta).toEqual({ x: 200, y: 0 })
+ expect(result.guides).toContainEqual({
+ axis: 'vertical',
+ coordinate: 200,
+ start: 0,
+ end: 80
+ })
+ })
+
+ it('snaps matching centers within threshold', () => {
+ const result = resolveNodeAlignmentSnap({
+ selectionBounds,
+ candidateBounds: [
+ {
+ x: 0,
+ y: 200,
+ width: 100,
+ height: 80
+ }
+ ],
+ delta: { x: 0, y: 196 },
+ zoomScale: 1
+ })
+
+ expect(result.delta).toEqual({ x: 0, y: 200 })
+ expect(result.guides).toContainEqual({
+ axis: 'horizontal',
+ coordinate: 200,
+ start: 0,
+ end: 100
+ })
+ })
+
+ it('prefers the nearest candidate correction', () => {
+ const result = resolveNodeAlignmentSnap({
+ selectionBounds,
+ candidateBounds: [
+ {
+ x: 200,
+ y: 0,
+ width: 100,
+ height: 80
+ },
+ {
+ x: 198,
+ y: 0,
+ width: 100,
+ height: 80
+ }
+ ],
+ delta: { x: 193, y: 0 },
+ zoomScale: 1
+ })
+
+ expect(result.delta).toEqual({ x: 198, y: 0 })
+ expect(result.guides).toContainEqual({
+ axis: 'vertical',
+ coordinate: 198,
+ start: 0,
+ end: 80
+ })
+ })
+
+ it('does not snap when outside the zoom-adjusted threshold', () => {
+ const result = resolveNodeAlignmentSnap({
+ selectionBounds,
+ candidateBounds: [
+ {
+ x: 200,
+ y: 200,
+ width: 100,
+ height: 80
+ }
+ ],
+ delta: { x: 183, y: 0 },
+ zoomScale: 0.5
+ })
+
+ expect(result.delta).toEqual({ x: 183, y: 0 })
+ expect(result.guides).toEqual([])
+ })
+
+ it('tightens the canvas threshold as zoom increases', () => {
+ const result = resolveNodeAlignmentSnap({
+ selectionBounds,
+ candidateBounds: [
+ {
+ x: 200,
+ y: 200,
+ width: 100,
+ height: 80
+ }
+ ],
+ delta: { x: 195, y: 0 },
+ zoomScale: 2
+ })
+
+ expect(result.delta).toEqual({ x: 195, y: 0 })
+ expect(result.guides).toEqual([])
+ })
+})
diff --git a/src/renderer/extensions/vueNodes/layout/nodeAlignmentSnap.ts b/src/renderer/extensions/vueNodes/layout/nodeAlignmentSnap.ts
new file mode 100644
index 00000000000..b91be0e03fa
--- /dev/null
+++ b/src/renderer/extensions/vueNodes/layout/nodeAlignmentSnap.ts
@@ -0,0 +1,225 @@
+import type { Bounds, Point } from '@/renderer/core/layout/types'
+
+const DEFAULT_THRESHOLD_PX = 8
+
+type HorizontalAnchor = 'bottom' | 'centerY' | 'top'
+type VerticalAnchor = 'centerX' | 'left' | 'right'
+
+export interface NodeAlignmentGuide {
+ axis: 'horizontal' | 'vertical'
+ coordinate: number
+ start: number
+ end: number
+}
+
+export interface NodeAlignmentSnapResult {
+ delta: Point
+ guides: NodeAlignmentGuide[]
+}
+
+interface AxisMatch {
+ axis: 'horizontal' | 'vertical'
+ anchor: HorizontalAnchor | VerticalAnchor
+ candidateBounds: Bounds
+ correction: number
+}
+
+interface ResolveNodeAlignmentSnapOptions {
+ candidateBounds: Bounds[]
+ delta: Point
+ selectionBounds: Bounds
+ thresholdPx?: number
+ zoomScale: number
+}
+
+export function resolveNodeAlignmentSnap({
+ candidateBounds,
+ delta,
+ selectionBounds,
+ thresholdPx = DEFAULT_THRESHOLD_PX,
+ zoomScale
+}: ResolveNodeAlignmentSnapOptions): NodeAlignmentSnapResult {
+ if (!candidateBounds.length || zoomScale <= 0) {
+ return { delta, guides: [] }
+ }
+
+ const threshold = thresholdPx / zoomScale
+ const translatedSelectionBounds = translateBounds(selectionBounds, delta)
+
+ const verticalMatch = findBestVerticalMatch(
+ translatedSelectionBounds,
+ candidateBounds,
+ threshold
+ )
+ const horizontalMatch = findBestHorizontalMatch(
+ translatedSelectionBounds,
+ candidateBounds,
+ threshold
+ )
+
+ const snappedDelta = {
+ x: delta.x + (verticalMatch?.correction ?? 0),
+ y: delta.y + (horizontalMatch?.correction ?? 0)
+ }
+ const snappedSelectionBounds = translateBounds(selectionBounds, snappedDelta)
+ const guides = [
+ verticalMatch &&
+ createVerticalGuide(
+ snappedSelectionBounds,
+ verticalMatch.candidateBounds
+ ),
+ horizontalMatch &&
+ createHorizontalGuide(
+ snappedSelectionBounds,
+ horizontalMatch.candidateBounds
+ )
+ ].filter((guide): guide is NodeAlignmentGuide => guide !== undefined)
+
+ return {
+ delta: snappedDelta,
+ guides
+ }
+}
+
+function findBestVerticalMatch(
+ selectionBounds: Bounds,
+ candidateBounds: Bounds[],
+ threshold: number
+): AxisMatch | undefined {
+ return findBestMatch(
+ 'vertical',
+ getVerticalAnchorValues(selectionBounds),
+ candidateBounds,
+ threshold,
+ getVerticalAnchorValues
+ )
+}
+
+function findBestHorizontalMatch(
+ selectionBounds: Bounds,
+ candidateBounds: Bounds[],
+ threshold: number
+): AxisMatch | undefined {
+ return findBestMatch(
+ 'horizontal',
+ getHorizontalAnchorValues(selectionBounds),
+ candidateBounds,
+ threshold,
+ getHorizontalAnchorValues
+ )
+}
+
+function findBestMatch(
+ axis: 'horizontal' | 'vertical',
+ selectionAnchors: Record,
+ candidateBounds: Bounds[],
+ threshold: number,
+ getCandidateAnchors: (bounds: Bounds) => Record
+): AxisMatch | undefined {
+ let bestMatch: AxisMatch | undefined
+
+ for (const bounds of candidateBounds) {
+ const candidateAnchors = getCandidateAnchors(bounds)
+
+ for (const anchor of Object.keys(selectionAnchors) as TAnchor[]) {
+ const correction = candidateAnchors[anchor] - selectionAnchors[anchor]
+ if (Math.abs(correction) > threshold) {
+ continue
+ }
+
+ if (!bestMatch || Math.abs(correction) < Math.abs(bestMatch.correction)) {
+ bestMatch = {
+ axis,
+ anchor,
+ candidateBounds: bounds,
+ correction
+ }
+ }
+ }
+ }
+
+ return bestMatch
+}
+
+function getVerticalAnchorValues(
+ bounds: Bounds
+): Record {
+ return {
+ left: bounds.x,
+ centerX: bounds.x + bounds.width * 0.5,
+ right: bounds.x + bounds.width
+ }
+}
+
+function getHorizontalAnchorValues(
+ bounds: Bounds
+): Record {
+ return {
+ top: bounds.y,
+ centerY: bounds.y + bounds.height * 0.5,
+ bottom: bounds.y + bounds.height
+ }
+}
+
+function createVerticalGuide(
+ selectionBounds: Bounds,
+ candidateBounds: Bounds
+): NodeAlignmentGuide {
+ const candidateAnchors = getVerticalAnchorValues(candidateBounds)
+ const selectionAnchors = getVerticalAnchorValues(selectionBounds)
+ const coordinate = getSharedAnchorValue(selectionAnchors, candidateAnchors)
+
+ return {
+ axis: 'vertical',
+ coordinate,
+ start: Math.min(selectionBounds.y, candidateBounds.y),
+ end: Math.max(
+ selectionBounds.y + selectionBounds.height,
+ candidateBounds.y + candidateBounds.height
+ )
+ }
+}
+
+function createHorizontalGuide(
+ selectionBounds: Bounds,
+ candidateBounds: Bounds
+): NodeAlignmentGuide {
+ const candidateAnchors = getHorizontalAnchorValues(candidateBounds)
+ const selectionAnchors = getHorizontalAnchorValues(selectionBounds)
+ const coordinate = getSharedAnchorValue(selectionAnchors, candidateAnchors)
+
+ return {
+ axis: 'horizontal',
+ coordinate,
+ start: Math.min(selectionBounds.x, candidateBounds.x),
+ end: Math.max(
+ selectionBounds.x + selectionBounds.width,
+ candidateBounds.x + candidateBounds.width
+ )
+ }
+}
+
+function getSharedAnchorValue<
+ TAnchor extends HorizontalAnchor | VerticalAnchor
+>(
+ selectionAnchors: Record,
+ candidateAnchors: Record
+): number {
+ const anchors = Object.keys(selectionAnchors) as TAnchor[]
+
+ for (const anchor of anchors) {
+ if (selectionAnchors[anchor] === candidateAnchors[anchor]) {
+ return selectionAnchors[anchor]
+ }
+ }
+
+ return selectionAnchors[anchors[0]]
+}
+
+function translateBounds(bounds: Bounds, delta: Point): Bounds {
+ return {
+ ...bounds,
+ x: bounds.x + delta.x,
+ y: bounds.y + delta.y
+ }
+}
diff --git a/src/renderer/extensions/vueNodes/layout/useNodeDrag.test.ts b/src/renderer/extensions/vueNodes/layout/useNodeDrag.test.ts
new file mode 100644
index 00000000000..e28b475b793
--- /dev/null
+++ b/src/renderer/extensions/vueNodes/layout/useNodeDrag.test.ts
@@ -0,0 +1,150 @@
+import { createPinia, setActivePinia } from 'pinia'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+import { LiteGraph } from '@/lib/litegraph/src/litegraph'
+import { useCanvasStore } from '@/renderer/core/canvas/canvasStore'
+import { layoutStore } from '@/renderer/core/layout/store/layoutStore'
+import { useNodeDrag } from '@/renderer/extensions/vueNodes/layout/useNodeDrag'
+import type * as VueUseModule from '@vueuse/core'
+
+const settingValues: Record = {
+ 'Comfy.Canvas.AlignNodesWhileDragging': false,
+ 'Comfy.SnapToGrid.GridSize': 10,
+ 'pysssss.SnapToGrid': false
+}
+
+vi.mock('@vueuse/core', async () => {
+ const actual = await vi.importActual('@vueuse/core')
+
+ return {
+ ...actual,
+ createSharedComposable: (
+ composable: (...args: TArgs) => TResult
+ ) => composable
+ }
+})
+
+vi.mock('@/platform/settings/settingStore', () => ({
+ useSettingStore: () => ({
+ get: (key: string) => settingValues[key]
+ })
+}))
+
+vi.mock('@/scripts/app', () => ({
+ app: {
+ canvas: null
+ }
+}))
+
+describe('useNodeDrag', () => {
+ beforeEach(() => {
+ setActivePinia(createPinia())
+
+ layoutStore.initializeFromLiteGraph([
+ { id: 'node-1', pos: [0, 40], size: [100, 60] },
+ { id: 'node-2', pos: [40, 40], size: [100, 60] },
+ { id: 'node-3', pos: [200, 40], size: [100, 60] }
+ ])
+ layoutStore.vueDragSnapGuides.value = []
+ layoutStore.isDraggingVueNodes.value = false
+
+ LiteGraph.NODE_TITLE_HEIGHT = 30
+
+ const canvasStore = useCanvasStore()
+ canvasStore.selectedItems = [{ id: 'node-1' }, { id: 'node-2' }] as never[]
+ canvasStore.canvas = {
+ setDirty: vi.fn()
+ } as never
+
+ settingValues['Comfy.Canvas.AlignNodesWhileDragging'] = false
+ settingValues['pysssss.SnapToGrid'] = false
+
+ vi.stubGlobal('requestAnimationFrame', (callback: FrameRequestCallback) => {
+ callback(0)
+ return 1
+ })
+ vi.stubGlobal('cancelAnimationFrame', vi.fn())
+ })
+
+ it('snaps the dragged multi-selection and clears guides on drag end', () => {
+ settingValues['Comfy.Canvas.AlignNodesWhileDragging'] = true
+
+ const { startDrag, handleDrag, endDrag } = useNodeDrag()
+
+ startDrag(
+ new PointerEvent('pointerdown', { clientX: 0, clientY: 0 }),
+ 'node-1'
+ )
+ handleDrag(
+ new PointerEvent('pointermove', {
+ clientX: 193,
+ clientY: 0
+ }),
+ 'node-1'
+ )
+
+ expect(layoutStore.getNodeLayoutRef('node-1').value?.position.x).toBe(200)
+ expect(layoutStore.getNodeLayoutRef('node-2').value?.position.x).toBe(240)
+ expect(layoutStore.vueDragSnapGuides.value).toContainEqual(
+ expect.objectContaining({
+ axis: 'vertical',
+ coordinate: 200
+ })
+ )
+
+ endDrag(
+ new PointerEvent('pointerup', { clientX: 193, clientY: 0 }),
+ 'node-1'
+ )
+
+ expect(layoutStore.vueDragSnapGuides.value).toEqual([])
+ })
+
+ it('excludes already selected nodes from alignment candidates', () => {
+ settingValues['Comfy.Canvas.AlignNodesWhileDragging'] = true
+
+ layoutStore.initializeFromLiteGraph([
+ { id: 'node-1', pos: [0, 40], size: [100, 60] },
+ { id: 'node-2', pos: [60, 40], size: [100, 60] }
+ ])
+
+ const { startDrag, handleDrag } = useNodeDrag()
+
+ startDrag(
+ new PointerEvent('pointerdown', { clientX: 0, clientY: 0 }),
+ 'node-1'
+ )
+ handleDrag(
+ new PointerEvent('pointermove', {
+ clientX: 63,
+ clientY: 0
+ }),
+ 'node-1'
+ )
+
+ expect(layoutStore.getNodeLayoutRef('node-1').value?.position.x).toBe(63)
+ expect(layoutStore.vueDragSnapGuides.value).toEqual([])
+ })
+
+ it('suppresses alignment snapping while grid snapping is active', () => {
+ settingValues['Comfy.Canvas.AlignNodesWhileDragging'] = true
+
+ const { startDrag, handleDrag } = useNodeDrag()
+
+ startDrag(
+ new PointerEvent('pointerdown', { clientX: 0, clientY: 0 }),
+ 'node-1'
+ )
+ handleDrag(
+ new PointerEvent('pointermove', {
+ clientX: 193,
+ clientY: 0,
+ shiftKey: true
+ }),
+ 'node-1'
+ )
+
+ expect(layoutStore.getNodeLayoutRef('node-1').value?.position.x).toBe(193)
+ expect(layoutStore.vueDragSnapGuides.value).toEqual([])
+ })
+})
diff --git a/src/renderer/extensions/vueNodes/layout/useNodeDrag.ts b/src/renderer/extensions/vueNodes/layout/useNodeDrag.ts
index 9b0cb8c4764..773db72979d 100644
--- a/src/renderer/extensions/vueNodes/layout/useNodeDrag.ts
+++ b/src/renderer/extensions/vueNodes/layout/useNodeDrag.ts
@@ -1,12 +1,15 @@
import { storeToRefs } from 'pinia'
import { toValue } from 'vue'
+import { LiteGraph } from '@/lib/litegraph/src/litegraph'
+import { useSettingStore } from '@/platform/settings/settingStore'
import type { LGraphGroup } from '@/lib/litegraph/src/LGraphGroup'
import { useCanvasStore } from '@/renderer/core/canvas/canvasStore'
import { useLayoutMutations } from '@/renderer/core/layout/operations/layoutMutations'
import { layoutStore } from '@/renderer/core/layout/store/layoutStore'
import { LayoutSource } from '@/renderer/core/layout/types'
import type {
+ Bounds,
NodeBoundsUpdate,
NodeId,
Point
@@ -17,11 +20,16 @@ import { useTransformState } from '@/renderer/core/layout/transform/useTransform
import { isLGraphGroup } from '@/utils/litegraphUtil'
import { createSharedComposable } from '@vueuse/core'
+import type { NodeAlignmentSnapResult } from './nodeAlignmentSnap'
+import { resolveNodeAlignmentSnap } from './nodeAlignmentSnap'
+
export const useNodeDrag = createSharedComposable(useNodeDragIndividual)
function useNodeDragIndividual() {
+ const canvasStore = useCanvasStore()
const mutations = useLayoutMutations()
- const { selectedNodeIds, selectedItems } = storeToRefs(useCanvasStore())
+ const { selectedNodeIds, selectedItems } = storeToRefs(canvasStore)
+ const settingStore = useSettingStore()
// Get transform utilities from TransformPane if available
const transformState = useTransformState()
@@ -42,6 +50,8 @@ function useNodeDragIndividual() {
// For groups: track the last applied canvas delta to compute frame delta
let lastCanvasDelta: Point | null = null
let selectedGroups: LGraphGroup[] | null = null
+ let draggedSelectionBounds: Bounds | null = null
+ let alignmentCandidateBounds: Bounds[] = []
function startDrag(event: PointerEvent, nodeId: NodeId) {
const layout = toValue(layoutStore.getNodeLayoutRef(nodeId))
@@ -54,11 +64,15 @@ function useNodeDragIndividual() {
dragStartPos = { ...position }
dragStartMouse = { x: event.clientX, y: event.clientY }
- const selectedNodes = toValue(selectedNodeIds)
+ const selectedNodes = new Set(toValue(selectedNodeIds))
+ selectedNodes.add(nodeId)
+ draggedSelectionBounds = getDraggedSelectionBounds(selectedNodes)
+ alignmentCandidateBounds = getAlignmentCandidateBounds(selectedNodes)
+ updateDragSnapGuides([])
// capture the starting positions of all other selected nodes
// Only move other selected items if the dragged node is part of the selection
- const isDraggedNodeInSelection = selectedNodes?.has(nodeId)
+ const isDraggedNodeInSelection = selectedNodes.has(nodeId)
if (isDraggedNodeInSelection && selectedNodes.size > 1) {
otherSelectedNodesStartPositions = new Map()
@@ -120,11 +134,12 @@ function useNodeDragIndividual() {
x: canvasWithDelta.x - canvasOrigin.x,
y: canvasWithDelta.y - canvasOrigin.y
}
+ const snappedCanvasDelta = maybeResolveAlignmentSnap(event, canvasDelta)
// Calculate new position for the current node
const newPosition = {
- x: dragStartPos.x + canvasDelta.x,
- y: dragStartPos.y + canvasDelta.y
+ x: dragStartPos.x + snappedCanvasDelta.x,
+ y: dragStartPos.y + snappedCanvasDelta.y
}
// Apply mutation through the layout system (Vue batches DOM updates automatically)
@@ -140,8 +155,8 @@ function useNodeDragIndividual() {
startPos
] of otherSelectedNodesStartPositions) {
const newOtherPosition = {
- x: startPos.x + canvasDelta.x,
- y: startPos.y + canvasDelta.y
+ x: startPos.x + snappedCanvasDelta.x,
+ y: startPos.y + snappedCanvasDelta.y
}
mutations.moveNode(otherNodeId, newOtherPosition)
}
@@ -151,8 +166,8 @@ function useNodeDragIndividual() {
// This matches LiteGraph's behavior which uses delta-based movement
if (selectedGroups && selectedGroups.length > 0 && lastCanvasDelta) {
const frameDelta = {
- x: canvasDelta.x - lastCanvasDelta.x,
- y: canvasDelta.y - lastCanvasDelta.y
+ x: snappedCanvasDelta.x - lastCanvasDelta.x,
+ y: snappedCanvasDelta.y - lastCanvasDelta.y
}
for (const group of selectedGroups) {
@@ -160,7 +175,7 @@ function useNodeDragIndividual() {
}
}
- lastCanvasDelta = canvasDelta
+ lastCanvasDelta = snappedCanvasDelta
})
}
@@ -231,6 +246,9 @@ function useNodeDragIndividual() {
otherSelectedNodesStartPositions = null
selectedGroups = null
lastCanvasDelta = null
+ draggedSelectionBounds = null
+ alignmentCandidateBounds = []
+ updateDragSnapGuides([])
// Stop tracking shift key state
stopShiftSync?.()
@@ -248,4 +266,99 @@ function useNodeDragIndividual() {
handleDrag,
endDrag
}
+
+ function maybeResolveAlignmentSnap(
+ event: PointerEvent,
+ canvasDelta: Point
+ ): Point {
+ if (!settingStore.get('Comfy.Canvas.AlignNodesWhileDragging')) {
+ updateDragSnapGuides([])
+ return canvasDelta
+ }
+
+ if (shouldSnap(event) || !draggedSelectionBounds) {
+ updateDragSnapGuides([])
+ return canvasDelta
+ }
+
+ const snapResult: NodeAlignmentSnapResult = resolveNodeAlignmentSnap({
+ selectionBounds: draggedSelectionBounds,
+ candidateBounds: alignmentCandidateBounds,
+ delta: canvasDelta,
+ zoomScale: transformState.camera.z
+ })
+
+ updateDragSnapGuides(snapResult.guides)
+ return snapResult.delta
+ }
+
+ function getDraggedSelectionBounds(nodeIds: Set): Bounds | null {
+ const bounds = Array.from(nodeIds)
+ .map((id) => layoutStore.getNodeLayoutRef(id).value)
+ .filter((layout): layout is NonNullable => layout !== null)
+ .map(getRenderedNodeBounds)
+
+ return mergeBounds(bounds)
+ }
+
+ function getAlignmentCandidateBounds(selectedNodeSet: Set): Bounds[] {
+ const allNodes = layoutStore.getAllNodes().value
+ const candidates: Bounds[] = []
+
+ for (const [nodeId, layout] of allNodes) {
+ if (selectedNodeSet.has(nodeId)) {
+ continue
+ }
+ candidates.push(getRenderedNodeBounds(layout))
+ }
+
+ return candidates
+ }
+
+ function updateDragSnapGuides(
+ guides: typeof layoutStore.vueDragSnapGuides.value
+ ) {
+ layoutStore.vueDragSnapGuides.value = guides
+ canvasStore.canvas?.setDirty(true, true)
+ }
+}
+
+function getRenderedNodeBounds(layout: {
+ position: Point
+ size: { width: number; height: number }
+}): Bounds {
+ const titleHeight = LiteGraph.NODE_TITLE_HEIGHT || 0
+
+ return {
+ x: layout.position.x,
+ y: layout.position.y - titleHeight,
+ width: layout.size.width,
+ height: layout.size.height + titleHeight
+ }
+}
+
+function mergeBounds(boundsList: Bounds[]): Bounds | null {
+ const [firstBounds, ...remainingBounds] = boundsList
+ if (!firstBounds) {
+ return null
+ }
+
+ let left = firstBounds.x
+ let top = firstBounds.y
+ let right = firstBounds.x + firstBounds.width
+ let bottom = firstBounds.y + firstBounds.height
+
+ for (const bounds of remainingBounds) {
+ left = Math.min(left, bounds.x)
+ top = Math.min(top, bounds.y)
+ right = Math.max(right, bounds.x + bounds.width)
+ bottom = Math.max(bottom, bounds.y + bounds.height)
+ }
+
+ return {
+ x: left,
+ y: top,
+ width: right - left,
+ height: bottom - top
+ }
}
diff --git a/src/schemas/apiSchema.ts b/src/schemas/apiSchema.ts
index fb530f54f50..b9ddd70af11 100644
--- a/src/schemas/apiSchema.ts
+++ b/src/schemas/apiSchema.ts
@@ -464,7 +464,8 @@ const zSettings = z.object({
'Comfy.VersionCompatibility.DisableWarnings': z.boolean(),
'Comfy.RightSidePanel.IsOpen': z.boolean(),
'Comfy.RightSidePanel.ShowErrorsTab': z.boolean(),
- 'Comfy.Node.AlwaysShowAdvancedWidgets': z.boolean()
+ 'Comfy.Node.AlwaysShowAdvancedWidgets': z.boolean(),
+ 'Comfy.Canvas.AlignNodesWhileDragging': z.boolean()
})
export type EmbeddingsResponse = z.infer