client io architecture

client/ui.go

@@ -1,6 +1,7 @@
 package client
 
 import (
+	"fmt"
 	"image"
 	"math"
 
@@ -193,6 +194,146 @@ func (e *client) eventPosToPixel(eventX, eventY float32) (xPx, yPx int, ok bool)
 	return x, y, true
 }
 
+func (e *client) CanvasScale() float32 {
+	e.metaMu.RLock()
+	defer e.metaMu.RUnlock()
+	if e.lastCanvasScale <= 0 {
+		return 1
+	}
+	return e.lastCanvasScale
+}
+
+func (e *client) ForceFullRedraw() {
+	if e.world == nil {
+		return
+	}
+	e.world.ForceFullRedrawNext()
+}
+
+func (e *client) onRasterWidgetLayout(fyne.Size) {
+	e.updateSizes()
+}
+
+// updateSizes updates only metadata we need for event->pixel conversion and schedules a redraw.
+// It must NOT try to compute pixel viewport sizes (those are known in raster draw callback).
+func (e *client) updateSizes() {
+	canvasObj := fyne.CurrentApp().Driver().CanvasForObject(e.raster)
+	if canvasObj == nil {
+		return
+	}
+
+	sz := e.raster.Size() // logical (Fyne units)
+	scale := canvasObj.Scale()
+
+	e.metaMu.Lock()
+	e.lastRasterLogicW = sz.Width
+	e.lastRasterLogicH = sz.Height
+	e.lastCanvasScale = scale
+	e.metaMu.Unlock()
+
+	e.RequestRefresh()
+}
+
+func (e *client) onDragged(ev *fyne.DragEvent) {
+	e.pan.Dragged(ev)
+}
+
+func (e *client) onDradEnd() {
+	e.pan.DragEnd()
+}
+
+func (e *client) onTapped(ev *fyne.PointEvent) {
+	if e.world == nil || ev == nil {
+		return
+	}
+
+	xPx, yPx, ok := e.eventPosToPixel(ev.Position.X, ev.Position.Y)
+	if !ok {
+		return
+	}
+
+	params := e.getLastRenderedParams()
+	hits, err := e.world.HitTest(e.hits, &params, xPx, yPx)
+	if err != nil {
+		// In UI you probably don't want panic; keep your existing handling.
+		panic(err)
+	}
+
+	m := func(v int) float64 { return float64(v) / float64(world.SCALE) }
+
+	for _, hit := range hits {
+		var coord string
+		if hit.Kind == world.KindLine {
+			coord = fmt.Sprintf("{%f,%f - %f,%f}", m(hit.X1), m(hit.Y1), m(hit.X2), m(hit.Y2))
+		} else {
+			coord = fmt.Sprintf("{%f,%f}", m(hit.X), m(hit.Y))
+		}
+		fmt.Println("hit:", hit.ID, "Coord:", coord)
+	}
+}
+
+func (e *client) onScrolled(s *fyne.ScrollEvent) {
+	if e.world == nil || s == nil {
+		return
+	}
+
+	// Use last rendered viewport sizes (pixel) for zoom logic.
+	e.metaMu.RLock()
+	vw := e.lastRasterPxW
+	vh := e.lastRasterPxH
+	e.metaMu.RUnlock()
+	if vw <= 0 || vh <= 0 {
+		return
+	}
+
+	cxPx, cyPx, ok := e.eventPosToPixel(s.Position.X, s.Position.Y)
+	if !ok {
+		return
+	}
+
+	e.mu.Lock()
+	oldZoom := e.wp.CameraZoom
+
+	// Exponential zoom factor; tune later.
+	const base = 1.005
+	delta := float64(s.Scrolled.DY)
+	newZoom := oldZoom * math.Pow(base, delta)
+
+	newZoom = e.world.CorrectCameraZoom(newZoom, vw, vh)
+	if newZoom == oldZoom {
+		e.mu.Unlock()
+		return
+	}
+
+	oldZoomFp, err := world.CameraZoomToWorldFixed(oldZoom)
+	if err != nil {
+		e.mu.Unlock()
+		return
+	}
+	newZoomFp, err := world.CameraZoomToWorldFixed(newZoom)
+	if err != nil {
+		e.mu.Unlock()
+		return
+	}
+
+	// Pivot zoom for no-wrap behavior.
+	newCamX, newCamY := world.PivotZoomCameraNoWrap(
+		e.wp.CameraXWorldFp, e.wp.CameraYWorldFp,
+		vw, vh,
+		cxPx, cyPx,
+		oldZoomFp, newZoomFp,
+	)
+
+	e.wp.CameraZoom = newZoom
+	e.wp.CameraXWorldFp = newCamX
+	e.wp.CameraYWorldFp = newCamY
+	e.mu.Unlock()
+
+	// Any zoom change should rebuild index and force full redraw.
+	e.world.ForceFullRedrawNext()
+	e.RequestRefresh()
+}
+
 // copyViewportRGBA copies a viewport rectangle from src RGBA into dst RGBA.
 // dst must be sized exactly (0,0)-(vw,vh). This is allocation-free.
 // It avoids SubImage aliasing issues: dst becomes independent from src backing memory.