io/pointer: support nested scrollables

Fixes #185.

Signed-off-by: pierre <pierre.curto@gmail.com>

io/router/pointer.go

@@ -4,6 +4,7 @@ package router
 
 import (
 	"encoding/binary"
+	"image"
 
 	"gioui.org/f32"
 	"gioui.org/internal/opconst"
@@ -59,6 +60,8 @@ type pointerHandler struct {
 	active    bool
 	wantsGrab bool
 	types     pointer.Type
+	// min and max horizontal/vertical scroll
+	scrollRange image.Rectangle
 }
 
 type areaOp struct {
@@ -155,6 +158,17 @@ func (q *pointerQueue) collectHandlers(r *ops.Reader, events *handlerEvents) {
 			h.area = state.area
 			h.wantsGrab = h.wantsGrab || op.Grab
 			h.types = h.types | op.Types
+			bo := binary.LittleEndian.Uint32
+			h.scrollRange = image.Rectangle{
+				Min: image.Point{
+					X: int(int32(bo(encOp.Data[3:]))),
+					Y: int(int32(bo(encOp.Data[7:]))),
+				},
+				Max: image.Point{
+					X: int(int32(bo(encOp.Data[11:]))),
+					Y: int(int32(bo(encOp.Data[15:]))),
+				},
+			}
 		case opconst.TypeCursor:
 			q.cursors = append(q.cursors, cursorNode{
 				name: encOp.Refs[0].(pointer.CursorName),
@@ -320,7 +334,11 @@ func (q *pointerQueue) Push(e pointer.Event, events *handlerEvents) {
 	if e.Type == pointer.Press {
 		p.pressed = true
 	}
-	if e.Type != pointer.Release {
+	switch e.Type {
+	case pointer.Release:
+	case pointer.Scroll:
+		q.deliverScrollEvent(p, events, e)
+	default:
 		q.deliverEvent(p, events, e)
 	}
 	if !p.pressed && len(p.entered) == 0 {
@@ -350,6 +368,31 @@ func (q *pointerQueue) deliverEvent(p *pointerInfo, events *handlerEvents, e poi
 	}
 }
 
+func (q *pointerQueue) deliverScrollEvent(p *pointerInfo, events *handlerEvents, e pointer.Event) {
+	foremost := true
+	if p.pressed && len(p.handlers) == 1 {
+		e.Priority = pointer.Grabbed
+		foremost = false
+	}
+	var sx, sy = e.Scroll.X, e.Scroll.Y
+	for _, k := range p.handlers {
+		if sx == 0 && sy == 0 {
+			return
+		}
+		h := q.handlers[k]
+		// Distribute the scroll to the handler based on its ScrollRange.
+		sx, e.Scroll.X = setScrollEvent(sx, h.scrollRange.Min.X, h.scrollRange.Max.X)
+		sy, e.Scroll.Y = setScrollEvent(sy, h.scrollRange.Min.Y, h.scrollRange.Max.Y)
+		e := e
+		if foremost {
+			foremost = false
+			e.Priority = pointer.Foremost
+		}
+		e.Position = q.invTransform(h.area, e.Position)
+		events.Add(k, e)
+	}
+}
+
 func (q *pointerQueue) deliverEnterLeaveEvents(p *pointerInfo, events *handlerEvents, e pointer.Event) {
 	q.scratch = q.scratch[:0]
 	q.opHit(&q.scratch, e.Position)
@@ -454,3 +497,13 @@ func (op *areaOp) Hit(pos f32.Point) bool {
 		panic("invalid area kind")
 	}
 }
+
+func setScrollEvent(scroll float32, min, max int) (left, scrolled float32) {
+	if v := float32(max); scroll > v {
+		return scroll - v, v
+	}
+	if v := float32(min); scroll < v {
+		return scroll - v, v
+	}
+	return 0, scroll
+}

io/router/pointer_test.go

@@ -185,39 +185,73 @@ func TestPointerTypes(t *testing.T) {
 func TestPointerPriority(t *testing.T) {
 	handler1 := new(int)
 	handler2 := new(int)
+	handler3 := new(int)
 	var ops op.Ops
 
+	st := op.Save(&ops)
 	pointer.Rect(image.Rect(0, 0, 100, 100)).Add(&ops)
-	pointer.InputOp{Tag: handler1, Types: pointer.Scroll}.Add(&ops)
+	pointer.InputOp{
+		Tag:          handler1,
+		Types:        pointer.Scroll,
+		ScrollBounds: image.Rectangle{Max: image.Point{X: 100}},
+	}.Add(&ops)
 
 	pointer.Rect(image.Rect(0, 0, 100, 50)).Add(&ops)
-	pointer.InputOp{Tag: handler2, Types: pointer.Scroll}.Add(&ops)
+	pointer.InputOp{
+		Tag:          handler2,
+		Types:        pointer.Scroll,
+		ScrollBounds: image.Rectangle{Max: image.Point{X: 20}},
+	}.Add(&ops)
+	st.Load()
+
+	pointer.Rect(image.Rect(0, 100, 100, 200)).Add(&ops)
+	pointer.InputOp{
+		Tag:          handler3,
+		Types:        pointer.Scroll,
+		ScrollBounds: image.Rectangle{Min: image.Point{X: -20, Y: -40}},
+	}.Add(&ops)
 
 	var r Router
 	r.Frame(&ops)
 	r.Queue(
-		// Hit both handlers.
+		// Hit handler 1 and 2.
 		pointer.Event{
 			Type:     pointer.Scroll,
 			Position: f32.Pt(50, 25),
+			Scroll:   f32.Pt(50, 0),
 		},
 		// Hit handler 1.
 		pointer.Event{
 			Type:     pointer.Scroll,
 			Position: f32.Pt(50, 75),
+			Scroll:   f32.Pt(50, 50),
+		},
+		// Hit handler 3.
+		pointer.Event{
+			Type:     pointer.Scroll,
+			Position: f32.Pt(50, 150),
+			Scroll:   f32.Pt(-30, -30),
 		},
 		// Hit no handlers.
 		pointer.Event{
 			Type:     pointer.Scroll,
-			Position: f32.Pt(50, 125),
+			Position: f32.Pt(50, 225),
 		},
 	)
+
 	hev1 := r.Events(handler1)
 	hev2 := r.Events(handler2)
+	hev3 := r.Events(handler3)
 	assertEventSequence(t, hev1, pointer.Cancel, pointer.Scroll, pointer.Scroll)
 	assertEventSequence(t, hev2, pointer.Cancel, pointer.Scroll)
+	assertEventSequence(t, hev3, pointer.Cancel, pointer.Scroll)
 	assertEventPriorities(t, hev1, pointer.Shared, pointer.Shared, pointer.Foremost)
 	assertEventPriorities(t, hev2, pointer.Shared, pointer.Foremost)
+	assertEventPriorities(t, hev3, pointer.Shared, pointer.Foremost)
+	assertScrollEvent(t, hev1[1], f32.Pt(30, 0))
+	assertScrollEvent(t, hev2[1], f32.Pt(20, 0))
+	assertScrollEvent(t, hev1[2], f32.Pt(50, 0))
+	assertScrollEvent(t, hev3[1], f32.Pt(-20, -30))
 }
 
 func TestPointerEnterLeave(t *testing.T) {
@@ -663,6 +697,14 @@ func assertEventPriorities(t *testing.T, events []event.Event, prios ...pointer.
 	}
 }
 
+// assertScrollEvent checks that the event scrolling amount matches the supplied value.
+func assertScrollEvent(t *testing.T, ev event.Event, scroll f32.Point) {
+	t.Helper()
+	if got, want := ev.(pointer.Event).Scroll, scroll; got != want {
+		t.Errorf("got %v; want %v", got, want)
+	}
+}
+
 func BenchmarkRouterAdd(b *testing.B) {
 	// Set this to the number of overlapping handlers that you want to
 	// evaluate performance for. Typical values for the example applications