LCOV - code coverage report
Current view: top level - packages/mask-editor/src - useToolManager.ts Coverage Total Hit
Test: ComfyUI E2E Coverage Lines: 74.5 % 106 79
Test Date: 2026-11-17 04:17:53

            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              : }
        

Generated by: LCOV version 2.0-1