aee8623 fix(overview): contain cascade previews and preserve mixed navigation · neferwl

M internal/core/core.go +11 -4


@@ -287,11 +287,10 @@ func (c *Core) apply(cfg ports.Config) error {
287	287		if err != nil {
288	288		return err
289	289		}
290		-	// A successful configuration update starts a fresh overview gesture.
291		-	// Selection and opening snapshots remain identity-based across layouts.
	290	+	// Reload is cold-path work; preserve gestures on unrelated changes.
	291	+	axes := make(map[*Monitor]layoutPolicy, len(c.screens))
292	292		for _, s := range c.screens {
293		-	s.mon.ov.scrollX, s.mon.ov.scrollY = 0, 0
294		-	s.mon.ov.scrolled, s.mon.ov.sideways = false, false
	293	+	axes[s.mon] = s.mon.Current().policy()
295	294		}
296	295		c.cfg = cfg
297	296		c.binds = binds

@@ -303,6 +302,14 @@ func (c *Core) apply(cfg ports.Config) error {
303	302		c.settings(s.mon)
304	303		}
305	304		c.applyOutputConfig()
	305	+	for _, s := range c.screens {
	306	+	old := axes[s.mon]
	307	+	now := s.mon.Current().policy()
	308	+	if old.content != now.content \|\| old.workspace != now.workspace {
	309	+	s.mon.ov.scrollX, s.mon.ov.scrollY = 0, 0
	310	+	s.mon.ov.scrolled, s.mon.ov.sideways = false, false
	311	+	}
	312	+	}
306	313		return nil
307	314		}
308	315

 	if err != nil {
 		return err
 	}
-	// A successful configuration update starts a fresh overview gesture.
+	// Reload is cold-path work; preserve gestures on unrelated changes.
-	// Selection and opening snapshots remain identity-based across layouts.
+	axes := make(map[*Monitor]layoutPolicy, len(c.screens))
 	for _, s := range c.screens {
-		s.mon.ov.scrollX, s.mon.ov.scrollY = 0, 0
+		axes[s.mon] = s.mon.Current().policy()
-		s.mon.ov.scrolled, s.mon.ov.sideways = false, false
 	}
 	c.cfg = cfg
 	c.binds = binds
 		c.settings(s.mon)
 	}
 	c.applyOutputConfig()
+	for _, s := range c.screens {
+		old := axes[s.mon]
+		now := s.mon.Current().policy()
+		if old.content != now.content || old.workspace != now.workspace {
+			s.mon.ov.scrollX, s.mon.ov.scrollY = 0, 0
+			s.mon.ov.scrolled, s.mon.ov.sideways = false, false
+		}
+	}
 	return nil
 }

M internal/core/overview.go +20 -7


@@ -521,7 +521,9 @@ func (m Monitor) overviewRows() (map[Workspace]Rect, []ports.Separator) {
521	521		rows[w] = Rect{Y: y + hc + spacing}
522	522		}
523	523		if cur.policy().workspace == horizontalAxis {
524		-	dx := u.W + spacing
	524	+	width := int(math.Round(float64(cur.Usable.W)*cur.overviewZoom())) + cur.pileWidth()
	525	+	neighborWidth := int(math.Round(float64(w.Usable.W)*w.overviewZoom())) + w.pileWidth()
	526	+	dx := (width+neighborWidth)/2 + spacing
525	527		if next < i {
526	528		dx = -dx
527	529		}

@@ -531,9 +533,10 @@ func (m Monitor) overviewRows() (map[Workspace]Rect, []ports.Separator) {
531	533		margin := u.W * 4 / 100
532	534		r := Rect{X: u.X + margin, Y: top + spacing/2, W: u.W - 2*margin, H: 1}
533	535		if cur.policy().workspace == horizontalAxis {
534		-	x := u.X + u.W + spacing/2
	536	+	width := int(math.Round(float64(cur.Usable.W)*cur.overviewZoom())) + cur.pileWidth()
	537	+	x := u.X + u.W/2 + width/2 + spacing/2
535	538		if next < i {
536		-	x = u.X - spacing/2
	539	+	x = u.X + u.W/2 - width/2 - spacing/2
537	540		}
538	541		r = Rect{X: x, Y: u.Y + u.H4/100, W: 1, H: u.H 92 / 100}
539	542		}

@@ -865,8 +868,9 @@ func (w *Workspace) previewGeometry(y int, dim, lit bool, tiles []Placement, pre
865	868		x = u.X + u.W/2 - scale(sel.X+sel.W/2)
866	869		x = min(max(x, u.X+u.W-width), u.X)
867	870		}
	871	+	top, bottom := y, y+min(scale(preview.bounds.H), u.H*8/10)
868	872		if w.policy().wraps && preview.bounds.H > w.Usable.H {
869		-	room := min(scale(preview.bounds.H), u.H*8/10)
	873	+	room := bottom - top
870	874		offset := room/2 - scale(sel.Y+sel.H/2)
871	875		y += min(0, max(room-scale(preview.bounds.H), offset))
872	876		}

@@ -877,6 +881,10 @@ func (w *Workspace) previewGeometry(y int, dim, lit bool, tiles []Placement, pre
877	881		r := tiles[i].Rect
878	882		x0, y0 := scale(r.X), scale(r.Y)
879	883		tiles[i].Rect = Rect{X: x + x0, Y: y + y0, W: scale(r.X+r.W) - x0, H: scale(r.Y+r.H) - y0}
	884	+	if w.policy().wraps && (tiles[i].Rect.Y < top \|\| tiles[i].Rect.Y+tiles[i].Rect.H > bottom) {
	885	+	tiles[i].Hidden, tiles[i].Focused, tiles[i].Preview = true, false, 0
	886	+	continue
	887	+	}
880	888		tiles[i].Preview = z
881	889		if dim {
882	890		tiles[i].peeking(1)

@@ -1020,7 +1028,7 @@ const (
1020	1028		func (m *Monitor) overviewScroll(a ports.PointerAxis) (changed bool) {
1021	1029		// The accumulator uses logical content/workspace axes, independent of
1022	1030		// their physical orientation. Stash selection retains its own axes.
1023		-	if m.Current().policy().wraps && m.cardAt(m.Current()) < 0 {
	1031	+	if a.Source == ports.AxisFinger && m.Current().policy().wraps && m.cardAt(m.Current()) < 0 {
1024	1032		a.Vertical, a.Horizontal = a.Horizontal, a.Vertical
1025	1033		}
1026	1034		if a.Vertical.Stop \|\| a.Horizontal.Stop {

@@ -1056,8 +1064,13 @@ func (m *Monitor) overviewScroll(a ports.PointerAxis) (changed bool) {
1056	1064		for {
1057	1065		switch {
1058	1066		case math.Abs(m.ov.scrollY) >= overviewScrollStep && math.Abs(m.ov.scrollY) >= math.Abs(m.ov.scrollX):
1059		-	m.OverviewMove(0, sign(m.ov.scrollY))
1060		-	m.ov.scrollY -= float64(sign(m.ov.scrollY)) * overviewScrollStep
	1067	+	step := sign(m.ov.scrollY)
	1068	+	axis := m.Current().policy().workspace
	1069	+	m.OverviewMove(0, step)
	1070	+	if axis != m.Current().policy().workspace {
	1071	+	return true
	1072	+	}
	1073	+	m.ov.scrollY -= float64(step) * overviewScrollStep
1061	1074		m.ov.scrollX = 0
1062	1075		if finger {
1063	1076		m.ov.scrollX, m.ov.scrollY, m.ov.scrolled = 0, 0, true

 			rows[w] = Rect{Y: y + hc + spacing}
 		}
 		if cur.policy().workspace == horizontalAxis {
-			dx := u.W + spacing
+			width := int(math.Round(float64(cur.Usable.W)*cur.overviewZoom())) + cur.pileWidth()
+			neighborWidth := int(math.Round(float64(w.Usable.W)*w.overviewZoom())) + w.pileWidth()
+			dx := (width+neighborWidth)/2 + spacing
 			if next < i {
 				dx = -dx
 			}
 			margin := u.W * 4 / 100
 			r := Rect{X: u.X + margin, Y: top + spacing/2, W: u.W - 2*margin, H: 1}
 			if cur.policy().workspace == horizontalAxis {
-				x := u.X + u.W + spacing/2
+				width := int(math.Round(float64(cur.Usable.W)*cur.overviewZoom())) + cur.pileWidth()
+				x := u.X + u.W/2 + width/2 + spacing/2
 				if next < i {
-					x = u.X - spacing/2
+					x = u.X + u.W/2 - width/2 - spacing/2
 				}
 				r = Rect{X: x, Y: u.Y + u.H*4/100, W: 1, H: u.H * 92 / 100}
 			}
 		x = u.X + u.W/2 - scale(sel.X+sel.W/2)
 		x = min(max(x, u.X+u.W-width), u.X)
 	}
+	top, bottom := y, y+min(scale(preview.bounds.H), u.H*8/10)
 	if w.policy().wraps && preview.bounds.H > w.Usable.H {
-		room := min(scale(preview.bounds.H), u.H*8/10)
+		room := bottom - top
 		offset := room/2 - scale(sel.Y+sel.H/2)
 		y += min(0, max(room-scale(preview.bounds.H), offset))
 	}
 		r := tiles[i].Rect
 		x0, y0 := scale(r.X), scale(r.Y)
 		tiles[i].Rect = Rect{X: x + x0, Y: y + y0, W: scale(r.X+r.W) - x0, H: scale(r.Y+r.H) - y0}
+		if w.policy().wraps && (tiles[i].Rect.Y < top || tiles[i].Rect.Y+tiles[i].Rect.H > bottom) {
+			tiles[i].Hidden, tiles[i].Focused, tiles[i].Preview = true, false, 0
+			continue
+		}
 		tiles[i].Preview = z
 		if dim {
 			tiles[i].peeking(1)
 func (m *Monitor) overviewScroll(a ports.PointerAxis) (changed bool) {
 	// The accumulator uses logical content/workspace axes, independent of
 	// their physical orientation. Stash selection retains its own axes.
-	if m.Current().policy().wraps && m.cardAt(m.Current()) < 0 {
+	if a.Source == ports.AxisFinger && m.Current().policy().wraps && m.cardAt(m.Current()) < 0 {
 		a.Vertical, a.Horizontal = a.Horizontal, a.Vertical
 	}
 	if a.Vertical.Stop || a.Horizontal.Stop {
 	for {
 		switch {
 		case math.Abs(m.ov.scrollY) >= overviewScrollStep && math.Abs(m.ov.scrollY) >= math.Abs(m.ov.scrollX):
-			m.OverviewMove(0, sign(m.ov.scrollY))
+			step := sign(m.ov.scrollY)
-			m.ov.scrollY -= float64(sign(m.ov.scrollY)) * overviewScrollStep
+			axis := m.Current().policy().workspace
+			m.OverviewMove(0, step)
+			if axis != m.Current().policy().workspace {
+				return true
+			}
+			m.ov.scrollY -= float64(step) * overviewScrollStep
 			m.ov.scrollX = 0
 			if finger {
 				m.ov.scrollX, m.ov.scrollY, m.ov.scrolled = 0, 0, true

A internal/core/overview_bench_test.go +20 -0

@@ -0,0 +1,20 @@
	1	+	package core
	2	+
	3	+	import "testing"
	4	+
	5	+	func BenchmarkOverviewCascade(b *testing.B) {
	6	+	m := NewMonitor()
	7	+	m.SetOutput(900, 600)
	8	+	m.SetMaxColumns(3)
	9	+	m.SetOverflow(OverflowCascade)
	10	+	for id := WindowID(1); id <= 7; id++ {
	11	+	m.AddWindow(id)
	12	+	}
	13	+	m.ToggleOverview()
	14	+	buf := m.Layout()
	15	+	b.ReportAllocs()
	16	+	b.ResetTimer()
	17	+	for range b.N {
	18	+	buf = m.layoutInto(buf[:0])
	19	+	}
	20	+	}

@@ -0,0 +1,20 @@
	1	+	package core
	2	+
	3	+	import "testing"
	4	+
	5	+	func BenchmarkOverviewCascade(b *testing.B) {
	6	+	m := NewMonitor()
	7	+	m.SetOutput(900, 600)
	8	+	m.SetMaxColumns(3)
	9	+	m.SetOverflow(OverflowCascade)
	10	+	for id := WindowID(1); id <= 7; id++ {
	11	+	m.AddWindow(id)
	12	+	}
	13	+	m.ToggleOverview()
	14	+	buf := m.Layout()
	15	+	b.ReportAllocs()
	16	+	b.ResetTimer()
	17	+	for range b.N {
	18	+	buf = m.layoutInto(buf[:0])
	19	+	}
	20	+	}

M internal/core/overview_cascade_test.go +14 -0


@@ -64,6 +64,20 @@ func TestOverviewCascadeReloadRetainsSelection(t *testing.T) {
64	64		}
65	65		}
66	66
	67	+	func TestOverviewMixedWheelDoesNotBounce(t *testing.T) {
	68	+	for _, source := range []ports.AxisSource{ports.AxisWheel, ports.AxisContinuous} {
	69	+	m := overviewMonitor()
	70	+	m.SetOverflow(OverflowFixed)
	71	+	m.Workspaces[1].Overflow = OverflowCascade
	72	+	m.ToggleOverview()
	73	+	from := m.Current()
	74	+	m.overviewScroll(ports.PointerAxis{Source: source, Vertical: ports.ScrollAxis{Set: true, Value: overviewScrollStep, V120: 120}})
	75	+	if m.Current() == from {
	76	+	t.Fatalf("source %v bounced", source)
	77	+	}
	78	+	}
	79	+	}
	80	+
67	81		func TestOverviewCascadeStashScale(t *testing.T) {
68	82		w := cascadeWorkspace(7)
69	83		w.Stash = []Float{{ID: 20}}


@@ -64,6 +64,20 @@ func TestOverviewCascadeReloadRetainsSelection(t *testing.T) {
64	}	64		}
65	}	65		}
66		66
		67	+	func TestOverviewMixedWheelDoesNotBounce(t *testing.T) {
		68	+	for _, source := range []ports.AxisSource{ports.AxisWheel, ports.AxisContinuous} {
		69	+	m := overviewMonitor()
		70	+	m.SetOverflow(OverflowFixed)
		71	+	m.Workspaces[1].Overflow = OverflowCascade
		72	+	m.ToggleOverview()
		73	+	from := m.Current()
		74	+	m.overviewScroll(ports.PointerAxis{Source: source, Vertical: ports.ScrollAxis{Set: true, Value: overviewScrollStep, V120: 120}})
		75	+	if m.Current() == from {
		76	+	t.Fatalf("source %v bounced", source)
		77	+	}
		78	+	}
		79	+	}
		80	+
67	func TestOverviewCascadeStashScale(t *testing.T) {	81		func TestOverviewCascadeStashScale(t *testing.T) {
68	w := cascadeWorkspace(7)	82		w := cascadeWorkspace(7)
69	w.Stash = []Float{{ID: 20}}	83		w.Stash = []Float{{ID: 20}}