canvas.go

// SPDX-License-Identifier: Apache-2.0
// Copyright 2026 didvc

//go:build windows

package main

import "fmt"

// ---- hit testing ----

func (a *App) hitResizeEdge(m *Mask, cx, cy int32) int {
	cl, ct := a.desktopToCanvas(m.X, m.Y)
	cr, cb := a.desktopToCanvas(m.X+m.W, m.Y+m.H)
	near := func(v, target int32) bool {
		d := v - target
		if d < 0 {
			d = -d
		}
		return d <= handleSize
	}
	edge := 0
	inY := cy >= ct-handleSize && cy <= cb+handleSize
	inX := cx >= cl-handleSize && cx <= cr+handleSize
	if inY {
		if near(cx, cl) {
			edge |= 1
		}
		if near(cx, cr) {
			edge |= 4
		}
	}
	if inX {
		if near(cy, ct) {
			edge |= 2
		}
		if near(cy, cb) {
			edge |= 8
		}
	}
	return edge
}

// maskAt returns the topmost mask index containing the desktop point.
func (a *App) maskAt(dx, dy int32) int {
	for i := len(a.masks) - 1; i >= 0; i-- {
		if a.masks[i].contains(dx, dy) {
			return i
		}
	}
	return -1
}

// ---- mouse handlers ----

func (a *App) onLButtonDown(x, y int32) {
	if x >= GetClientRect(a.hwnd).Right-panelWidth {
		a.onPanelClick(x, y)
		return
	}
	if !a.pointInCanvas(x, y) {
		return
	}

	// resize handle of the currently selected mask takes priority
	if m := a.selectedMask(); m != nil {
		if edge := a.hitResizeEdge(m, x, y); edge != 0 {
			a.beginDrag(dragResize, x, y, m)
			a.resizeEdge = edge
			return
		}
	}

	dx, dy := a.canvasToDesktop(x, y)
	if i := a.maskAt(dx, dy); i >= 0 {
		a.selected = i
		a.beginDrag(dragMove, x, y, a.masks[i])
		a.redraw()
		return
	}

	// empty space: create a new mask anchored here
	m := &Mask{X: dx, Y: dy, W: 0, H: 0, Opacity: 220, Color: maskPalette[0]}
	a.addMask(m)
	a.beginDrag(dragCreate, x, y, m)
	a.resizeEdge = 4 | 8 // grow right+bottom
	a.redraw()
}

func (a *App) beginDrag(mode dragMode, cx, cy int32, m *Mask) {
	a.drag = mode
	a.dragStartX, a.dragStartY = a.canvasToDesktop(cx, cy)
	a.dragOrigX, a.dragOrigY, a.dragOrigW, a.dragOrigH = m.X, m.Y, m.W, m.H
	SetCapture(a.hwnd)
}

func (a *App) onMouseMove(x, y int32) {
	if a.opacityDrag {
		a.setOpacityFromX(x)
		return
	}
	if a.drag == dragNone {
		return
	}
	m := a.selectedMask()
	if m == nil {
		a.drag = dragNone
		ReleaseCapture()
		return
	}
	dx, dy := a.canvasToDesktop(x, y)
	ddx := dx - a.dragStartX
	ddy := dy - a.dragStartY

	switch a.drag {
	case dragMove:
		m.X = a.dragOrigX + ddx
		m.Y = a.dragOrigY + ddy
	case dragCreate, dragResize:
		m.X, m.Y, m.W, m.H = a.dragOrigX, a.dragOrigY, a.dragOrigW, a.dragOrigH
		if a.resizeEdge&1 != 0 {
			m.X = a.dragOrigX + ddx
			m.W = a.dragOrigW - ddx
		}
		if a.resizeEdge&4 != 0 {
			m.W = a.dragOrigW + ddx
		}
		if a.resizeEdge&2 != 0 {
			m.Y = a.dragOrigY + ddy
			m.H = a.dragOrigH - ddy
		}
		if a.resizeEdge&8 != 0 {
			m.H = a.dragOrigH + ddy
		}
		m.normalize()
	}
	a.syncOverlay(m)
	a.redraw()
}

func (a *App) onLButtonUp(x, y int32) {
	if a.opacityDrag {
		a.opacityDrag = false
		ReleaseCapture()
		return
	}
	if a.drag == dragNone {
		return
	}
	mode := a.drag
	a.drag = dragNone
	ReleaseCapture()

	m := a.selectedMask()
	if m != nil && mode == dragCreate && (m.W < 4 || m.H < 4) {
		// discard accidental click (no meaningful rectangle drawn)
		a.removeMask(a.selected)
	}
	a.redraw()
}

func (a *App) onRButtonDown(x, y int32) {
	if !a.pointInCanvas(x, y) {
		return
	}
	dx, dy := a.canvasToDesktop(x, y)
	if i := a.maskAt(dx, dy); i >= 0 {
		a.removeMask(i)
		a.redraw()
	}
}

func (a *App) updateCursor() bool {
	pt := a.cursorClient()
	if m := a.selectedMask(); m != nil && a.pointInCanvas(pt.X, pt.Y) {
		if a.hitResizeEdge(m, pt.X, pt.Y) != 0 {
			SetCursor(LoadCursor(IDC_SIZENWSE))
			return true
		}
	}
	if a.pointInCanvas(pt.X, pt.Y) {
		dx, dy := a.canvasToDesktop(pt.X, pt.Y)
		if a.maskAt(dx, dy) >= 0 {
			SetCursor(LoadCursor(IDC_SIZEALL))
		} else {
			SetCursor(LoadCursor(IDC_CROSS))
		}
		return true
	}
	return false
}

// ---- canvas painting ----

func (a *App) drawCanvas(dc HDC) {
	// canvas background (the "desktop" — white with grid, per blueprint)
	white := CreateSolidBrush(RGB(255, 255, 255))
	FillRectC(dc, &a.canvas, white)
	DeleteObject(white)

	a.drawGrid(dc)

	// masks
	for i, m := range a.masks {
		a.drawMaskPreview(dc, m, i == a.selected)
	}

	// canvas border
	pen := CreatePen(PS_SOLID, 1, RGB(160, 160, 170))
	old := SelectObject(dc, pen)
	oldBrush := SelectObject(dc, a.getStockNullBrush())
	Rectangle(dc, a.canvas.Left, a.canvas.Top, a.canvas.Right, a.canvas.Bottom)
	SelectObject(dc, old)
	SelectObject(dc, oldBrush)
	DeleteObject(pen)
}

func (a *App) drawGrid(dc HDC) {
	// choose a grid step in desktop px that renders ~80px apart on canvas
	step := int32(100)
	for float64(step)*a.scale < 70 {
		step *= 2
	}
	for float64(step)*a.scale > 160 && step > 50 {
		step /= 2
	}

	pen := CreatePen(PS_SOLID, 1, RGB(232, 232, 238))
	old := SelectObject(dc, pen)
	SetBkMode(dc, TRANSPARENT)
	SetTextColor(dc, RGB(150, 150, 158))
	SelectObject(dc, a.fontSmall)

	// vertical grid lines + x labels
	for gx := (a.vsX/step + 1) * step; gx < a.vsX+a.vsW; gx += step {
		cx, _ := a.desktopToCanvas(gx, a.vsY)
		MoveToEx(dc, cx, a.canvas.Top)
		LineTo(dc, cx, a.canvas.Bottom)
		lbl := fmt.Sprintf("%d", gx)
		r := RECT{Left: cx - 24, Top: a.canvas.Top - 16, Right: cx + 24, Bottom: a.canvas.Top - 2}
		DrawText(dc, lbl, &r, DT_CENTER|DT_SINGLELINE|DT_NOPREFIX)
	}
	// horizontal grid lines + y labels
	for gy := (a.vsY/step + 1) * step; gy < a.vsY+a.vsH; gy += step {
		_, cy := a.desktopToCanvas(a.vsX, gy)
		MoveToEx(dc, a.canvas.Left, cy)
		LineTo(dc, a.canvas.Right, cy)
		lbl := fmt.Sprintf("%d", gy)
		r := RECT{Left: a.canvas.Left - 26, Top: cy - 7, Right: a.canvas.Left - 3, Bottom: cy + 7}
		DrawText(dc, lbl, &r, DT_RIGHT|DT_SINGLELINE|DT_NOPREFIX)
	}
	SelectObject(dc, old)
	DeleteObject(pen)
}

func (a *App) drawMaskPreview(dc HDC, m *Mask, selected bool) {
	cl, ct := a.desktopToCanvas(m.X, m.Y)
	cr, cb := a.desktopToCanvas(m.X+m.W, m.Y+m.H)

	fill := CreateSolidBrush(m.Color)
	r := RECT{Left: cl, Top: ct, Right: cr, Bottom: cb}
	FillRectC(dc, &r, fill)
	DeleteObject(fill)

	borderCol := RGB(90, 90, 100)
	bw := int32(1)
	if selected {
		borderCol = RGB(0, 120, 215)
		bw = 2
	}
	pen := CreatePen(PS_SOLID, bw, borderCol)
	old := SelectObject(dc, pen)
	oldBrush := SelectObject(dc, a.getStockNullBrush())
	Rectangle(dc, cl, ct, cr, cb)
	SelectObject(dc, oldBrush)
	SelectObject(dc, old)
	DeleteObject(pen)

	// label with index + size in desktop px
	if cr-cl > 40 && cb-ct > 18 {
		SetBkMode(dc, TRANSPARENT)
		lum := luminance(m.Color)
		if lum < 128 {
			SetTextColor(dc, RGB(235, 235, 235))
		} else {
			SetTextColor(dc, RGB(20, 20, 20))
		}
		SelectObject(dc, a.fontSmall)
		lbl := fmt.Sprintf("%dx%d", m.W, m.H)
		DrawText(dc, lbl, &r, DT_CENTER|DT_VCENTER|DT_SINGLELINE|DT_NOPREFIX)
	}

	if selected {
		a.drawHandles(dc, cl, ct, cr, cb)
	}
}

func (a *App) drawHandles(dc HDC, cl, ct, cr, cb int32) {
	brush := CreateSolidBrush(RGB(0, 120, 215))
	pts := [][2]int32{
		{cl, ct}, {cr, ct}, {cl, cb}, {cr, cb},
		{(cl + cr) / 2, ct}, {(cl + cr) / 2, cb},
		{cl, (ct + cb) / 2}, {cr, (ct + cb) / 2},
	}
	for _, p := range pts {
		r := RECT{Left: p[0] - 4, Top: p[1] - 4, Right: p[0] + 4, Bottom: p[1] + 4}
		FillRectC(dc, &r, brush)
	}
	DeleteObject(brush)
}

func luminance(c COLORREF) uint32 {
	r := c & 0xff
	g := (c >> 8) & 0xff
	b := (c >> 16) & 0xff
	return (r*299 + g*587 + b*114) / 1000
}