Line data Source code
1 : import { ref, watch } from 'vue'
2 :
3 : import { isMiddleButtonHeld, isMiddlePointerInput } from './pointer'
4 :
5 : import type { Point2D as Point } from '@comfyorg/shared-frontend-utils/geometry'
6 : import type { ImageLayer, ToolInternalSettings } from './types'
7 : import { Tools } from './types'
8 : import { useMaskEditorStore } from './maskEditorStore'
9 : import { useBrushDrawing } from './useBrushDrawing'
10 : import { useCanvasTools } from './useCanvasTools'
11 : import { useCoordinateTransform } from './useCoordinateTransform'
12 : import type { useKeyboard } from './useKeyboard'
13 : import type { usePanAndZoom } from './usePanAndZoom'
14 :
15 29 : export function useToolManager(
16 : keyboard: ReturnType<typeof useKeyboard>,
17 : panZoom: ReturnType<typeof usePanAndZoom>,
18 : brushAdjustment?: Parameters<typeof useBrushDrawing>[0]
19 : ) {
20 29 : const store = useMaskEditorStore()
21 :
22 29 : const coordinateTransform = useCoordinateTransform()
23 :
24 29 : const brushDrawing = useBrushDrawing(brushAdjustment)
25 29 : const canvasTools = useCanvasTools()
26 :
27 29 : const mouseDownPoint = ref<Point | null>(null)
28 :
29 29 : const toolSettings: Record<Tools, Partial<ToolInternalSettings>> = {
30 : [Tools.MaskPen]: {
31 : newActiveLayerOnSet: 'mask'
32 : },
33 : [Tools.Eraser]: {},
34 : [Tools.PaintPen]: {
35 : newActiveLayerOnSet: 'rgb'
36 : },
37 : [Tools.MaskBucket]: {
38 : cursor: `url('${new URL('./assets/cursors/paintBucket.png', import.meta.url).href}') 30 25, auto`,
39 : newActiveLayerOnSet: 'mask'
40 : },
41 : [Tools.MaskColorFill]: {
42 : cursor: `url('${new URL('./assets/cursors/colorSelect.png', import.meta.url).href}') 15 25, auto`,
43 : newActiveLayerOnSet: 'mask'
44 : }
45 : }
46 :
47 29 : const setActiveLayer = (layer: ImageLayer) => {
48 0 : store.activeLayer = layer
49 0 : const currentTool = store.currentTool
50 :
51 : const maskOnlyTools = [Tools.MaskPen, Tools.MaskBucket, Tools.MaskColorFill]
52 0 : if (maskOnlyTools.includes(currentTool) && layer === 'rgb') {
53 0 : switchTool(Tools.PaintPen)
54 : }
55 :
56 0 : if (currentTool === Tools.PaintPen && layer === 'mask') {
57 0 : switchTool(Tools.MaskPen)
58 : }
59 : }
60 :
61 29 : const switchTool = (tool: Tools) => {
62 5 : store.currentTool = tool
63 :
64 5 : const newActiveLayer = toolSettings[tool].newActiveLayerOnSet
65 5 : if (newActiveLayer) {
66 2 : store.activeLayer = newActiveLayer
67 : }
68 :
69 5 : const cursor = toolSettings[tool].cursor
70 5 : const pointerZone = store.pointerZone
71 :
72 5 : if (cursor && pointerZone) {
73 0 : store.brushVisible = false
74 0 : pointerZone.style.cursor = cursor
75 5 : } else if (pointerZone) {
76 5 : store.brushVisible = true
77 5 : pointerZone.style.cursor = 'none'
78 : }
79 : }
80 :
81 29 : const updateCursor = () => {
82 50 : const currentTool = store.currentTool
83 50 : const cursor = toolSettings[currentTool].cursor
84 50 : const pointerZone = store.pointerZone
85 :
86 50 : if (cursor && pointerZone) {
87 0 : store.brushVisible = false
88 0 : pointerZone.style.cursor = cursor
89 50 : } else if (pointerZone) {
90 50 : store.brushVisible = true
91 50 : pointerZone.style.cursor = 'none'
92 : }
93 :
94 50 : store.brushPreviewGradientVisible = false
95 : }
96 :
97 29 : watch(
98 : () => store.currentTool,
99 : (newTool) => {
100 5 : if (newTool !== Tools.MaskColorFill) {
101 5 : canvasTools.clearLastColorSelectPoint()
102 : }
103 : }
104 : )
105 :
106 29 : const handlePointerDown = async (event: PointerEvent): Promise<void> => {
107 20 : event.preventDefault()
108 20 : if (event.pointerType === 'touch') return
109 :
110 20 : if (event.pointerType === 'pen') {
111 0 : panZoom.addPenPointerId(event.pointerId)
112 : }
113 :
114 20 : if (shouldStartPan(event)) {
115 1 : panZoom.handlePanStart(event)
116 :
117 1 : store.brushVisible = false
118 1 : return
119 : }
120 :
121 20 : if (store.currentTool === Tools.PaintPen && event.button === 0) {
122 1 : await brushDrawing.startDrawing(event)
123 :
124 1 : return
125 : }
126 :
127 20 : if (store.currentTool === Tools.PaintPen && event.buttons === 1) {
128 0 : await brushDrawing.handleDrawing(event)
129 0 : return
130 : }
131 :
132 20 : if (store.currentTool === Tools.MaskBucket && event.button === 0) {
133 0 : const offset = { x: event.offsetX, y: event.offsetY }
134 0 : const coords_canvas = coordinateTransform.screenToCanvas(offset)
135 0 : canvasTools.paintBucketFill(coords_canvas)
136 0 : return
137 : }
138 :
139 20 : if (store.currentTool === Tools.MaskColorFill && event.button === 0) {
140 0 : const offset = { x: event.offsetX, y: event.offsetY }
141 0 : const coords_canvas = coordinateTransform.screenToCanvas(offset)
142 0 : await canvasTools.colorSelectFill(coords_canvas)
143 0 : return
144 : }
145 :
146 20 : if (event.altKey && event.button === 2) {
147 0 : store.isAdjustingBrush = true
148 0 : await brushDrawing.startBrushAdjustment(event)
149 0 : return
150 : }
151 :
152 18 : const isDrawingTool = [
153 : Tools.MaskPen,
154 : Tools.Eraser,
155 : Tools.PaintPen
156 : ].includes(store.currentTool)
157 :
158 20 : if ([0, 2].includes(event.button) && isDrawingTool) {
159 18 : await brushDrawing.startDrawing(event)
160 18 : return
161 : }
162 : }
163 :
164 29 : const handlePointerMove = async (event: PointerEvent): Promise<void> => {
165 230 : event.preventDefault()
166 230 : if (event.pointerType === 'touch') return
167 :
168 230 : const newCursorPoint = { x: event.clientX, y: event.clientY }
169 230 : panZoom.updateCursorPosition(newCursorPoint)
170 :
171 230 : if (shouldContinuePan(event)) {
172 10 : await panZoom.handlePanMove(event)
173 10 : return
174 : }
175 :
176 : const isDrawingTool = [
177 : Tools.MaskPen,
178 : Tools.Eraser,
179 : Tools.PaintPen
180 : ].includes(store.currentTool)
181 230 : if (!isDrawingTool) return
182 :
183 230 : if (
184 : store.isAdjustingBrush &&
185 : (store.currentTool === Tools.MaskPen ||
186 : store.currentTool === Tools.Eraser) &&
187 : event.altKey &&
188 : event.buttons === 2
189 : ) {
190 0 : await brushDrawing.handleBrushAdjustment(event)
191 0 : return
192 : }
193 :
194 230 : if (event.buttons === 1 || event.buttons === 2) {
195 190 : await brushDrawing.handleDrawing(event)
196 190 : return
197 : }
198 : }
199 :
200 29 : const handlePointerUp = async (event: PointerEvent): Promise<void> => {
201 20 : store.isPanning = false
202 20 : store.brushVisible = true
203 :
204 20 : if (event.pointerType === 'pen') {
205 0 : panZoom.removePenPointerId(event.pointerId)
206 : }
207 :
208 20 : if (event.pointerType === 'touch') return
209 20 : updateCursor()
210 20 : store.isAdjustingBrush = false
211 20 : await brushDrawing.drawEnd(event)
212 20 : mouseDownPoint.value = null
213 : }
214 :
215 239 : function isLeftButtonSpacePan(event: PointerEvent) {
216 239 : return event.buttons === 1 && keyboard.isKeyDown(' ')
217 : }
218 :
219 20 : function shouldStartPan(event: PointerEvent) {
220 20 : return isMiddlePointerInput(event) || isLeftButtonSpacePan(event)
221 : }
222 :
223 230 : function shouldContinuePan(event: PointerEvent) {
224 230 : return isMiddleButtonHeld(event) || isLeftButtonSpacePan(event)
225 : }
226 :
227 29 : return {
228 : switchTool,
229 : setActiveLayer,
230 : updateCursor,
231 :
232 : handlePointerDown,
233 : handlePointerMove,
234 : handlePointerUp,
235 :
236 : brushDrawing
237 : }
238 : }
|