Merge pull request 'feat(core): centre the cascade overview stash across the lane's bottom edge' (#51) from feat/cascade-stash-bottom into main

Reviewed-on: https://git.bnema.dev/bnema/neferwl/pulls/51

commit: 24a63d348a52bb45cfcd71127e950e402ca5e221
author: bnema · 8d ago · 2026-10-14 20:05 UTC
merge of: f4ebc85 + 4183d39 · diff against the first parent
signature: SSH UnverifiedSHA256:VOCA5lYARHcbKDZ7GhTV45VmcjWnJ6ZQIBazj17LivA The key is unknown

5 files · +282 -130

M internal/core/layout_buffers_test.go +3 -3


@@ -146,7 +146,7 @@ func TestLayoutResultsDoNotAlias(t *testing.T) {
146	146		buf = m.layoutInto(buf)
147	147		buf = m.Current().layoutInto(buf)
148	148		m.Current().previewTiles()
149		-	m.Current().overviewZoom()
	149	+	m.Current().overviewZoom(m.overviewAxis())
150	150		}
151	151		// layoutInto builds in the caller's buffer, never in a scratch of
152	152		// the workspace: with the capacity there it returns that storage.

@@ -164,8 +164,8 @@ func TestLayoutResultsDoNotAlias(t *testing.T) {
164	164		// unchanged.
165	165		mine := w.layoutInto(make([]Placement, 0, len(res)))
166	166		mineKept := slices.Clone(mine)
167		-	w.overviewZoom()
168		-	w.peekStep()
	167	+	w.overviewZoom(m.overviewAxis())
	168	+	w.peekStep(m.overviewAxis())
169	169		w.previewTiles()
170	170		w.columnRects()
171	171		_ = w.Layout()


@@ -146,7 +146,7 @@ func TestLayoutResultsDoNotAlias(t *testing.T) {
146		buf = m.layoutInto(buf)	146		buf = m.layoutInto(buf)
147		buf = m.Current().layoutInto(buf)	147		buf = m.Current().layoutInto(buf)
148		m.Current().previewTiles()	148		m.Current().previewTiles()
149	-	m.Current().overviewZoom()	149	+	m.Current().overviewZoom(m.overviewAxis())
150		}	150		}
151		// layoutInto builds in the caller's buffer, never in a scratch of	151		// layoutInto builds in the caller's buffer, never in a scratch of
152		// the workspace: with the capacity there it returns that storage.	152		// the workspace: with the capacity there it returns that storage.

@@ -164,8 +164,8 @@ func TestLayoutResultsDoNotAlias(t *testing.T) {
164		// unchanged.	164		// unchanged.
165		mine := w.layoutInto(make([]Placement, 0, len(res)))	165		mine := w.layoutInto(make([]Placement, 0, len(res)))
166		mineKept := slices.Clone(mine)	166		mineKept := slices.Clone(mine)
167	-	w.overviewZoom()	167	+	w.overviewZoom(m.overviewAxis())
168	-	w.peekStep()	168	+	w.peekStep(m.overviewAxis())
169		w.previewTiles()	169		w.previewTiles()
170		w.columnRects()	170		w.columnRects()
171		_ = w.Layout()	171		_ = w.Layout()

M internal/core/overview.go +108 -86


@@ -53,10 +53,12 @@ type rowSnapshot struct {
53	53		// workspace. A pinned fullscreen window is the front card of its row, the
54	54		// windows it hides behind it; choosing one of them leaves fullscreen.
55	55
56		-	// A workspace's stash shows as a pile of cards pinned to the left edge of
57		-	// its row: the selected stashed window in front at overviewCardZoom, up to
58		-	// overviewCards-1 others behind it, each overviewCardStep further up and
59		-	// right, dimmed. The row takes the width the pile leaves.
	56	+	// A workspace's stash shows as a pile of cards: the selected stashed window
	57	+	// in front at overviewCardZoom, up to overviewCards-1 others behind it, each
	58	+	// overviewCardStep further up and right, dimmed. A vertical overview pins
	59	+	// the pile to the left edge of its row, which takes the width the pile
	60	+	// leaves. A horizontal one centres it on its row, straddling the bottom edge
	61	+	// of the selected lane, over the tiles.
60	62		const (
61	63		overviewCardZoom = 0.2
62	64		overviewCards = 4

@@ -423,15 +425,22 @@ func (m Monitor) cycleCard(w Workspace, d int) bool {
423	425		// overviewLane is the vertical move of an overview whose workspaces sit side
424	426		// by side (cascade): a selected stash card cycles the pile; else the
425	427		// selection goes to the previous or next lane (band), at the closest column,
426		-	// stopping at the first and last. Covering floats stack along the horizontal
427		-	// axis, not this one.
	428	+	// stopping at the first. Down past the last lane, or from a card that is not
	429	+	// the columns, enters the stash, which sits below. Covering floats stack
	430	+	// along the horizontal axis, not this one.
428	431		func (m *Monitor) overviewLane(dy int) {
429	432		w := m.Current()
430		-	if m.cycleCard(w, dy) \|\| m.stackFront(w).kind != stackColumns \|\| len(w.Columns) == 0 {
	433	+	if m.cycleCard(w, dy) {
431	434		return
432	435		}
433		-	if i := w.laneNeighbor(dy); i >= 0 {
434		-	m.selectLaneColumn(w, i)
	436	+	if m.stackFront(w).kind == stackColumns && len(w.Columns) > 0 {
	437	+	if i := w.laneNeighbor(dy); i >= 0 {
	438	+	m.selectLaneColumn(w, i)
	439	+	return
	440	+	}
	441	+	}
	442	+	if dy > 0 && len(w.Stash) > 0 {
	443	+	m.selectCard(w, w.stashAt)
435	444		}
436	445		}
437	446

@@ -444,10 +453,11 @@ func (m Monitor) selectLaneColumn(w Workspace, i int) {
444	453
445	454		// overviewAcross is the horizontal move of an overview whose workspaces sit
446	455		// side by side (cascade): a column inside the selected lane. Past the
447		-	// lane's first column it goes to the stash, else to the previous workspace;
448		-	// past the last column, to the next workspace. Covering floats fan along
449		-	// this axis and are traversed before the stash or a workspace: the card on
450		-	// the left is the one behind.
	456	+	// lane's first column it goes to the previous workspace; past the last
	457	+	// column, to the next workspace. From a stash card, left goes to the
	458	+	// previous workspace and right back to the columns. Covering floats fan
	459	+	// along this axis and are traversed before a workspace: the card on the
	460	+	// left is the one behind.
451	461		func (m *Monitor) overviewAcross(dx int) {
452	462		w := m.Current()
453	463		if m.cardAt(w) >= 0 {

@@ -459,15 +469,18 @@ func (m *Monitor) overviewAcross(dx int) {
459	469		}
460	470		m.clearCard()
461	471		m.ov.selected = 0
462		-	if m.stackFront(w).kind == stackColumns && len(w.Columns) > 0 {
463		-	// The first column of the focused lane.
	472	+	if len(w.Columns) > 0 {
	473	+	// The columns come to the front, even when down entered the
	474	+	// stash from a covering float: at the first column of the
	475	+	// focused lane.
	476	+	m.setFront(w, stackItem{kind: stackColumns})
464	477		i, _ := w.laneBounds(w.laneOf(w.Focus))
465	478		m.selectLaneColumn(w, i)
466	479		}
467	480		return
468	481		}
469	482		if m.stackFront(w).kind != stackColumns \|\| len(w.Columns) == 0 {
470		-	m.laneEdge(w, dx)
	483	+	m.laneEdge(dx)
471	484		return
472	485		}
473	486		first, last := w.laneBounds(w.laneOf(w.Focus))

@@ -475,20 +488,15 @@ func (m *Monitor) overviewAcross(dx int) {
475	488		m.selectLaneColumn(w, next)
476	489		return
477	490		}
478		-	m.laneEdge(w, dx)
	491	+	m.laneEdge(dx)
479	492		}
480	493
481	494		// laneEdge is a horizontal move off the edge of the selected lane, or off a
482		-	// card that is not the columns: the stack first, then the stash on the left
483		-	// or a workspace.
484		-	func (m Monitor) laneEdge(w Workspace, dx int) {
	495	+	// card that is not the columns: the stack first, then a workspace.
	496	+	func (m *Monitor) laneEdge(dx int) {
485	497		if m.moveStack(-dx) {
486	498		return
487	499		}
488		-	if dx < 0 && len(w.Stash) > 0 {
489		-	m.selectCard(w, w.stashAt)
490		-	return
491		-	}
492	500		m.overviewStep(dx)
493	501		}
494	502

@@ -628,8 +636,8 @@ func (m *Monitor) overviewAxis() layoutAxis { return m.Current().policy().worksp
628	636		//
629	637		// Vertical axis: full-width slots, the current one centred; the rule is
630	638		// horizontal. Horizontal axis: full-height slots as wide as their content,
631		-	// stash pile and stack peeks included, the current one centred; the rule is
632		-	// vertical, in the spacing between two slots.
	639	+	// stack peeks included (the stash pile sits over the row), the current one
	640	+	// centred; the rule is vertical, in the spacing between two slots.
633	641		func (m Monitor) overviewRows() (map[Workspace]Rect, []ports.Separator) {
634	642		cur := m.Current()
635	643		u := cur.overviewArea()

@@ -637,13 +645,10 @@ func (m Monitor) overviewRows() (map[Workspace]Rect, []ports.Separator) {
637	645		axis := m.overviewAxis()
638	646		var cs Rect
639	647		if axis == horizontalAxis {
640		-	// The row stays centred on the area; the pile extends the slot to
641		-	// the left, pushing the previous workspace, unless it would leave
642		-	// the area.
643		-	pile, row := cur.pileWidth(), cur.rowWidth()
644		-	cs = Rect{X: max(u.X+(u.W-row)/2-pile, u.X), Y: u.Y, W: pile + row, H: u.H}
	648	+	row := cur.rowWidth(axis)
	649	+	cs = Rect{X: u.X + (u.W-row)/2, Y: u.Y, W: row, H: u.H}
645	650		} else {
646		-	hc := cur.rowHeight()
	651	+	hc := cur.rowHeight(axis)
647	652		cs = Rect{X: u.X, Y: u.Y + (u.H-hc)/2, W: u.W, H: hc}
648	653		}
649	654		rows := map[*Workspace]Rect{cur: cs}

@@ -673,7 +678,7 @@ func (m Monitor) overviewRows() (map[Workspace]Rect, []ports.Separator) {
673	678		// slot cs along axis, spacing away; gapAt is where the spacing begins.
674	679		func neighborSlot(axis layoutAxis, u, cs Rect, w *Workspace, before bool, spacing int) (slot Rect, gapAt int) {
675	680		if axis == horizontalAxis {
676		-	slot = Rect{Y: u.Y, W: w.slotWidth(), H: u.H}
	681	+	slot = Rect{Y: u.Y, W: w.rowWidth(axis), H: u.H}
677	682		if before {
678	683		gapAt = cs.X - spacing
679	684		slot.X = gapAt - slot.W

@@ -683,7 +688,7 @@ func neighborSlot(axis layoutAxis, u, cs Rect, w *Workspace, before bool, spacin
683	688		}
684	689		return slot, gapAt
685	690		}
686		-	h := w.rowHeight()
	691	+	h := w.rowHeight(axis)
687	692		slot = Rect{X: u.X, W: u.W, H: h}
688	693		if before {
689	694		gapAt = cs.Y - spacing

@@ -718,7 +723,7 @@ func (m *Monitor) overviewLayout(result []Placement) []Placement {
718	723		at := m.cardAt(w)
719	724		result = append(result, m.stackRow(w, axis, slot, w != cur, at < 0)...)
720	725		if len(w.Stash) > 0 {
721		-	result = append(result, w.pile(w.pileBand(axis, slot), w != cur, at)...)
	726	+	result = append(result, w.pile(axis, slot, w != cur, at)...)
722	727		}
723	728		}
724	729		for _, f := range w.Floats {

@@ -802,8 +807,8 @@ func fan(cards [][]Placement, front, maxBehind, maxBefore int, circular bool,
802	807		return out
803	808		}
804	809
805		-	// pileWidth is the room the stash pile of w takes on the left of its row,
806		-	// its margin included; 0 without a stash.
	810	+	// pileWidth is the room the stash pile of w takes on the left of its row in
	811	+	// a vertical overview, its margin included; 0 without a stash.
807	812		func (w *Workspace) pileWidth() int {
808	813		if len(w.Stash) == 0 {
809	814		return 0

@@ -820,11 +825,11 @@ func (w *Workspace) cardStep() int {
820	825		return min(overviewCardStep, a.W/100, a.H/50)
821	826		}
822	827
823		-	// pile places the stash of w as cards on the left of band (see pileBand):
824		-	// entry front (the stash selection when -1) in
	828	+	// pile places the stash of w as cards in its slot along axis (see the
	829	+	// overview's stash comment): entry front (the stash selection when -1) in
825	830		// front, the next ones behind it, dimmed, the rest hidden. Only a front card
826	831		// of the current row (dim false) with front set is selected.
827		-	func (w *Workspace) pile(band Rect, dim bool, front int) []Placement {
	832	+	func (w *Workspace) pile(axis layoutAxis, slot Rect, dim bool, front int) []Placement {
828	833		n := len(w.Stash)
829	834		if n == 0 {
830	835		return nil

@@ -838,10 +843,21 @@ func (w *Workspace) pile(band Rect, dim bool, front int) []Placement {
838	843		u := w.overviewArea()
839	844		cw := int(math.Round(float64(r.W) * overviewCardZoom))
840	845		ch := int(math.Round(float64(r.H) * overviewCardZoom))
841		-	rowH := int(math.Round(float64(w.Usable.H) * w.overviewZoom()))
842		-	// Stack rows reserve two peek steps above the front card. Align the
843		-	// stash with that front band, not with the top of its envelope.
844		-	x0, y0 := band.X+u.W/100, band.Y+(rowH-ch)/2
	846	+	rowH := int(math.Round(float64(w.Usable.H) * w.overviewZoom(axis)))
	847	+	var x0, y0 int
	848	+	if axis == horizontalAxis {
	849	+	// Centred on the row, across the bottom edge of the selected
	850	+	// lane, which is centred in the slot. Both scale with the area
	851	+	// (the lane at most overviewMaxZoom of it), so the pile stays
	852	+	// inside whatever its size.
	853	+	x0 = slot.X + (slot.W-cw)/2
	854	+	y0 = slot.Y + (slot.H-rowH)/2 + rowH - ch/2
	855	+	} else {
	856	+	// Stack rows reserve two peek steps above the front card. Align
	857	+	// the stash with that front band, not with the top of its envelope.
	858	+	band := w.frontSlot(axis, slot)
	859	+	x0, y0 = band.X+u.W/100, band.Y+(rowH-ch)/2
	860	+	}
845	861		cards := make([][]Placement, n)
846	862		for i := range w.Stash {
847	863		cards[i] = []Placement{{ID: w.Stash[i].ID, Rect: Rect{X: x0, Y: y0, W: cw, H: ch}, Preview: overviewCardZoom, Focused: selected}}

@@ -853,22 +869,26 @@ func (w *Workspace) pile(band Rect, dim bool, front int) []Placement {
853	869		}
854	870
855	871		// overviewZoom is the scale that fits every column of w in the usable
856		-	// width, within the overview bounds.
857		-	func (w *Workspace) overviewZoom() float64 {
858		-	z, _ := w.zoomSpan()
	872	+	// width, within the overview bounds, in an overview along axis: only a
	873	+	// vertical one sets the stash pile beside the row.
	874	+	func (w *Workspace) overviewZoom(axis layoutAxis) float64 {
	875	+	z, _ := w.zoomSpan(axis)
859	876		return z
860	877		}
861	878
862	879		// zoomSpan is overviewZoom with the unscaled span of the tiles it fits. A
863	880		// cascade workspace spans one screen whatever its band count.
864		-	func (w *Workspace) zoomSpan() (float64, int) {
	881	+	func (w *Workspace) zoomSpan(axis layoutAxis) (float64, int) {
865	882		// Only the span is read: the tiles go in the zoom scratch, dead on return.
866	883		var span int
867	884		w.zoomBuf, span, _ = w.previewTilesInto(w.zoomBuf[:0])
868	885		if span <= 0 {
869	886		return overviewMaxZoom, span
870	887		}
871		-	room := float64(w.overviewArea().W-w.pileWidth()) * 0.96
	888	+	room := float64(w.overviewArea().W) * 0.96
	889	+	if axis == verticalAxis {
	890	+	room = float64(w.overviewArea().W-w.pileWidth()) * 0.96
	891	+	}
872	892		z := min(max(room/float64(span), overviewMinZoom), overviewMaxZoom)
873	893		if w.stacked() {
874	894		// Reserve two clear peeks on either side of the front row.

@@ -877,31 +897,25 @@ func (w *Workspace) zoomSpan() (float64, int) {
877	897		return z, span
878	898		}
879	899
880		-	// slotWidth is the width of the slot of w in a horizontal overview: its
881		-	// stash pile and its row.
882		-	func (w *Workspace) slotWidth() int {
883		-	return w.pileWidth() + w.rowWidth()
884		-	}
885		-
886		-	// rowWidth is the width of the row of w in a horizontal overview: what its
887		-	// tiles take (at most what the pile leaves of the area), plus the room for
888		-	// the covering floats peeking on either side of the front card.
889		-	func (w *Workspace) rowWidth() int {
890		-	z, span := w.zoomSpan()
	900	+	// rowWidth is the width of the slot of w in a horizontal overview: what its
	901	+	// tiles take (at most the area), plus the room for the covering floats
	902	+	// peeking on either side of the front card.
	903	+	func (w *Workspace) rowWidth(axis layoutAxis) int {
	904	+	z, span := w.zoomSpan(axis)
891	905		if span <= 0 {
892	906		// An empty workspace keeps the room of a screen.
893	907		span = w.Usable.W
894	908		}
895		-	width := min(int(math.Round(float64(span)*z)), w.overviewArea().W-w.pileWidth())
	909	+	width := min(int(math.Round(float64(span)*z)), w.overviewArea().W)
896	910		if w.stacked() {
897		-	width += 4 * w.peekStep()
	911	+	width += 4 * w.peekStep(axis)
898	912		}
899	913		return width
900	914		}
901	915
902	916		// peekStep is the shared step for a stack row and its front-card inset.
903		-	func (w *Workspace) peekStep() int {
904		-	return max(1, int(math.Round(float64(w.Usable.H)w.overviewZoom()overviewPeekStep)))
	917	+	func (w *Workspace) peekStep(axis layoutAxis) int {
	918	+	return max(1, int(math.Round(float64(w.Usable.H)w.overviewZoom(axis)overviewPeekStep)))
905	919		}
906	920
907	921		// frontSlot is the part of slot the front card of w takes: slot shifted

@@ -910,7 +924,7 @@ func (w *Workspace) peekStep() int {
910	924		// the room of the two after it. A single-card row keeps slot.
911	925		func (w *Workspace) frontSlot(axis layoutAxis, slot Rect) Rect {
912	926		if w.stacked() {
913		-	p := w.peekStep()
	927	+	p := w.peekStep(axis)
914	928		axis.offset(&slot, 2*p)
915	929		if axis == horizontalAxis {
916	930		slot.W -= 4 * p

@@ -919,24 +933,12 @@ func (w *Workspace) frontSlot(axis layoutAxis, slot Rect) Rect {
919	933		return slot
920	934		}
921	935
922		-	// pileBand is the band the stash pile of w aligns with in its slot. A
923		-	// vertical overview aligns it with the front card (see frontSlot). A
924		-	// horizontal one puts it level with the selected lane, left of the whole
925		-	// stack of cards.
926		-	func (w *Workspace) pileBand(axis layoutAxis, slot Rect) Rect {
927		-	if axis == verticalAxis {
928		-	return w.frontSlot(axis, slot)
929		-	}
930		-	slot.Y += (slot.H - int(math.Round(float64(w.Usable.H)*w.overviewZoom()))) / 2
931		-	return slot
932		-	}
933		-
934	936		// rowHeight includes the largest possible stack envelope (two peeks above
935	937		// and two below). Neighbor rows use the same measure as the current row.
936		-	func (w *Workspace) rowHeight() int {
937		-	h := int(math.Round(float64(w.Usable.H) * w.overviewZoom()))
	938	+	func (w *Workspace) rowHeight(axis layoutAxis) int {
	939	+	h := int(math.Round(float64(w.Usable.H) * w.overviewZoom(axis)))
938	940		if w.stacked() {
939		-	h += 4 * w.peekStep()
	941	+	h += 4 * w.peekStep(axis)
940	942		}
941	943		return h
942	944		}

@@ -1024,7 +1026,7 @@ func (w *Workspace) previewTilesInto(tiles []Placement) ([]Placement, int, Rect)
1024	1026
1025	1027		// previewRow scales the tiles of w into a row placed in slot, centred
1026	1028		// in the slot's width, or scrolled so the focused column shows when the
1027		-	// row is wider, right of the stash pile. Dimmed rows (neighbor
	1029	+	// row is wider (right of the stash pile in a vertical overview). Dimmed rows (neighbor
1028	1030		// workspaces) have no focus; neither has a row whose pile has it (lit
1029	1031		// false).
1030	1032		func (w *Workspace) previewRow(axis layoutAxis, slot Rect, dim, lit bool) []Placement {

@@ -1043,7 +1045,7 @@ func (w *Workspace) previewRow(axis layoutAxis, slot Rect, dim, lit bool) []Plac
1043	1045		// the overview axis shows only its selected lane. In a horizontal overview,
1044	1046		// tiles entirely outside the area are hidden.
1045	1047		func (w *Workspace) previewRowTiles(axis layoutAxis, slot Rect, dim, lit, lanes bool, tiles []Placement, span int, sel Rect) []Placement {
1046		-	z := w.overviewZoom()
	1048	+	z := w.overviewZoom(axis)
1047	1049		scale := func(v int) int { return int(math.Round(float64(v) * z)) }
1048	1050		width := scale(span)
1049	1051		u := w.overviewArea()

@@ -1051,9 +1053,13 @@ func (w *Workspace) previewRowTiles(axis layoutAxis, slot Rect, dim, lit, lanes
1051	1053		if axis == horizontalAxis {
1052	1054		top = slot.Y + (slot.H-scale(w.Usable.H))/2
1053	1055		}
1054		-	// Rows stay centred on the output like rows without a stash; the pile
1055		-	// only pushes a row right when they would overlap.
1056		-	left := w.pileWidth()
	1056	+	// Rows stay centred on the output like rows without a stash; in a
	1057	+	// vertical overview the pile only pushes a row right when they would
	1058	+	// overlap. A horizontal one draws the pile over the row.
	1059	+	left := 0
	1060	+	if axis == verticalAxis {
	1061	+	left = w.pileWidth()
	1062	+	}
1057	1063		x := max(slot.X+(slot.W-width)/2, slot.X+left)
1058	1064		ux, uw := slot.X+left, slot.W-left
1059	1065		if width > uw {

@@ -1142,6 +1148,22 @@ func overviewIn(layout []Placement, x, y float64) WindowID {
1142	1148		return 0
1143	1149		}
1144	1150
	1151	+	// overviewHit is overviewIn with the stash piles first: a pile is drawn
	1152	+	// over its row (a horizontal overview), the cards behind its front one
	1153	+	// included.
	1154	+	func (m *Monitor) overviewHit(layout []Placement, x, y float64) WindowID {
	1155	+	var piles []Placement
	1156	+	for _, p := range layout {
	1157	+	if w, _ := m.find(p.ID); w != nil && w.stashIndex(p.ID) >= 0 {
	1158	+	piles = append(piles, p)
	1159	+	}
	1160	+	}
	1161	+	if id := overviewIn(piles, x, y); id != 0 {
	1162	+	return id
	1163	+	}
	1164	+	return overviewIn(layout, x, y)
	1165	+	}
	1166	+
1145	1167		// overviewClick closes the overview on the preview under the pointer, on
1146	1168		// the output it shows on. picked is false when no preview is there.
1147	1169		func (c *Core) overviewClick(ctx context.Context) (picked bool, err error) {

@@ -1155,7 +1177,7 @@ func (c *Core) overviewClick(ctx context.Context) (picked bool, err error) {
1155	1177		}
1156	1178		// The cards are hit where they are drawn: a click during the open or a
1157	1179		// navigation animation picks what moves under the pointer.
1158		-	id := overviewIn(sc.shownLayout(), c.cursorX-float64(sc.x), c.cursorY-float64(sc.y))
	1180	+	id := sc.mon.overviewHit(sc.shownLayout(), c.cursorX-float64(sc.x), c.cursorY-float64(sc.y))
1159	1181		if id == 0 {
1160	1182		return false, nil
1161	1183		}

 // workspace. A pinned fullscreen window is the front card of its row, the
 // windows it hides behind it; choosing one of them leaves fullscreen.
-// A workspace's stash shows as a pile of cards pinned to the left edge of
+// A workspace's stash shows as a pile of cards: the selected stashed window
-// its row: the selected stashed window in front at overviewCardZoom, up to
+// in front at overviewCardZoom, up to overviewCards-1 others behind it, each
-// overviewCards-1 others behind it, each overviewCardStep further up and
+// overviewCardStep further up and right, dimmed. A vertical overview pins
-// right, dimmed. The row takes the width the pile leaves.
+// the pile to the left edge of its row, which takes the width the pile
+// leaves. A horizontal one centres it on its row, straddling the bottom edge
+// of the selected lane, over the tiles.
 const (
 	overviewCardZoom = 0.2
 	overviewCards    = 4
 // overviewLane is the vertical move of an overview whose workspaces sit side
 // by side (cascade): a selected stash card cycles the pile; else the
 // selection goes to the previous or next lane (band), at the closest column,
-// stopping at the first and last. Covering floats stack along the horizontal
+// stopping at the first. Down past the last lane, or from a card that is not
-// axis, not this one.
+// the columns, enters the stash, which sits below. Covering floats stack
+// along the horizontal axis, not this one.
 func (m *Monitor) overviewLane(dy int) {
 	w := m.Current()
-	if m.cycleCard(w, dy) || m.stackFront(w).kind != stackColumns || len(w.Columns) == 0 {
+	if m.cycleCard(w, dy) {
 		return
 	}
-	if i := w.laneNeighbor(dy); i >= 0 {
+	if m.stackFront(w).kind == stackColumns && len(w.Columns) > 0 {
-		m.selectLaneColumn(w, i)
+		if i := w.laneNeighbor(dy); i >= 0 {
+			m.selectLaneColumn(w, i)
+			return
+		}
+	}
+	if dy > 0 && len(w.Stash) > 0 {
+		m.selectCard(w, w.stashAt)
 	}
 }
 // overviewAcross is the horizontal move of an overview whose workspaces sit
 // side by side (cascade): a column inside the selected lane. Past the
-// lane's first column it goes to the stash, else to the previous workspace;
+// lane's first column it goes to the previous workspace; past the last
-// past the last column, to the next workspace. Covering floats fan along
+// column, to the next workspace. From a stash card, left goes to the
-// this axis and are traversed before the stash or a workspace: the card on
+// previous workspace and right back to the columns. Covering floats fan
-// the left is the one behind.
+// along this axis and are traversed before a workspace: the card on the
+// left is the one behind.
 func (m *Monitor) overviewAcross(dx int) {
 	w := m.Current()
 	if m.cardAt(w) >= 0 {
 		}
 		m.clearCard()
 		m.ov.selected = 0
-		if m.stackFront(w).kind == stackColumns && len(w.Columns) > 0 {
+		if len(w.Columns) > 0 {
-			// The first column of the focused lane.
+			// The columns come to the front, even when down entered the
+			// stash from a covering float: at the first column of the
+			// focused lane.
+			m.setFront(w, stackItem{kind: stackColumns})
 			i, _ := w.laneBounds(w.laneOf(w.Focus))
 			m.selectLaneColumn(w, i)
 		}
 		return
 	}
 	if m.stackFront(w).kind != stackColumns || len(w.Columns) == 0 {
-		m.laneEdge(w, dx)
+		m.laneEdge(dx)
 		return
 	}
 	first, last := w.laneBounds(w.laneOf(w.Focus))
 		m.selectLaneColumn(w, next)
 		return
 	}
-	m.laneEdge(w, dx)
+	m.laneEdge(dx)
 }
 // laneEdge is a horizontal move off the edge of the selected lane, or off a
-// card that is not the columns: the stack first, then the stash on the left
+// card that is not the columns: the stack first, then a workspace.
-// or a workspace.
+func (m *Monitor) laneEdge(dx int) {
-func (m *Monitor) laneEdge(w *Workspace, dx int) {
 	if m.moveStack(-dx) {
 		return
 	}
-	if dx < 0 && len(w.Stash) > 0 {
-		m.selectCard(w, w.stashAt)
-		return
-	}
 	m.overviewStep(dx)
 }
 //
 // Vertical axis: full-width slots, the current one centred; the rule is
 // horizontal. Horizontal axis: full-height slots as wide as their content,
-// stash pile and stack peeks included, the current one centred; the rule is
+// stack peeks included (the stash pile sits over the row), the current one
-// vertical, in the spacing between two slots.
+// centred; the rule is vertical, in the spacing between two slots.
 func (m *Monitor) overviewRows() (map[*Workspace]Rect, []ports.Separator) {
 	cur := m.Current()
 	u := cur.overviewArea()
 	axis := m.overviewAxis()
 	var cs Rect
 	if axis == horizontalAxis {
-		// The row stays centred on the area; the pile extends the slot to
+		row := cur.rowWidth(axis)
-		// the left, pushing the previous workspace, unless it would leave
+		cs = Rect{X: u.X + (u.W-row)/2, Y: u.Y, W: row, H: u.H}
-		// the area.
-		pile, row := cur.pileWidth(), cur.rowWidth()
-		cs = Rect{X: max(u.X+(u.W-row)/2-pile, u.X), Y: u.Y, W: pile + row, H: u.H}
 	} else {
-		hc := cur.rowHeight()
+		hc := cur.rowHeight(axis)
 		cs = Rect{X: u.X, Y: u.Y + (u.H-hc)/2, W: u.W, H: hc}
 	}
 	rows := map[*Workspace]Rect{cur: cs}
 // slot cs along axis, spacing away; gapAt is where the spacing begins.
 func neighborSlot(axis layoutAxis, u, cs Rect, w *Workspace, before bool, spacing int) (slot Rect, gapAt int) {
 	if axis == horizontalAxis {
-		slot = Rect{Y: u.Y, W: w.slotWidth(), H: u.H}
+		slot = Rect{Y: u.Y, W: w.rowWidth(axis), H: u.H}
 		if before {
 			gapAt = cs.X - spacing
 			slot.X = gapAt - slot.W
 		}
 		return slot, gapAt
 	}
-	h := w.rowHeight()
+	h := w.rowHeight(axis)
 	slot = Rect{X: u.X, W: u.W, H: h}
 	if before {
 		gapAt = cs.Y - spacing
 			at := m.cardAt(w)
 			result = append(result, m.stackRow(w, axis, slot, w != cur, at < 0)...)
 			if len(w.Stash) > 0 {
-				result = append(result, w.pile(w.pileBand(axis, slot), w != cur, at)...)
+				result = append(result, w.pile(axis, slot, w != cur, at)...)
 			}
 		}
 		for _, f := range w.Floats {
 	return out
 }
-// pileWidth is the room the stash pile of w takes on the left of its row,
+// pileWidth is the room the stash pile of w takes on the left of its row in
-// its margin included; 0 without a stash.
+// a vertical overview, its margin included; 0 without a stash.
 func (w *Workspace) pileWidth() int {
 	if len(w.Stash) == 0 {
 		return 0
 	return min(overviewCardStep, a.W/100, a.H/50)
 }
-// pile places the stash of w as cards on the left of band (see pileBand):
+// pile places the stash of w as cards in its slot along axis (see the
-// entry front (the stash selection when -1) in
+// overview's stash comment): entry front (the stash selection when -1) in
 // front, the next ones behind it, dimmed, the rest hidden. Only a front card
 // of the current row (dim false) with front set is selected.
-func (w *Workspace) pile(band Rect, dim bool, front int) []Placement {
+func (w *Workspace) pile(axis layoutAxis, slot Rect, dim bool, front int) []Placement {
 	n := len(w.Stash)
 	if n == 0 {
 		return nil
 	u := w.overviewArea()
 	cw := int(math.Round(float64(r.W) * overviewCardZoom))
 	ch := int(math.Round(float64(r.H) * overviewCardZoom))
-	rowH := int(math.Round(float64(w.Usable.H) * w.overviewZoom()))
+	rowH := int(math.Round(float64(w.Usable.H) * w.overviewZoom(axis)))
-	// Stack rows reserve two peek steps above the front card. Align the
+	var x0, y0 int
-	// stash with that front band, not with the top of its envelope.
+	if axis == horizontalAxis {
-	x0, y0 := band.X+u.W/100, band.Y+(rowH-ch)/2
+		// Centred on the row, across the bottom edge of the selected
+		// lane, which is centred in the slot. Both scale with the area
+		// (the lane at most overviewMaxZoom of it), so the pile stays
+		// inside whatever its size.
+		x0 = slot.X + (slot.W-cw)/2
+		y0 = slot.Y + (slot.H-rowH)/2 + rowH - ch/2
+	} else {
+		// Stack rows reserve two peek steps above the front card. Align
+		// the stash with that front band, not with the top of its envelope.
+		band := w.frontSlot(axis, slot)
+		x0, y0 = band.X+u.W/100, band.Y+(rowH-ch)/2
+	}
 	cards := make([][]Placement, n)
 	for i := range w.Stash {
 		cards[i] = []Placement{{ID: w.Stash[i].ID, Rect: Rect{X: x0, Y: y0, W: cw, H: ch}, Preview: overviewCardZoom, Focused: selected}}
 }
 // overviewZoom is the scale that fits every column of w in the usable
-// width, within the overview bounds.
+// width, within the overview bounds, in an overview along axis: only a
-func (w *Workspace) overviewZoom() float64 {
+// vertical one sets the stash pile beside the row.
-	z, _ := w.zoomSpan()
+func (w *Workspace) overviewZoom(axis layoutAxis) float64 {
+	z, _ := w.zoomSpan(axis)
 	return z
 }
 // zoomSpan is overviewZoom with the unscaled span of the tiles it fits. A
 // cascade workspace spans one screen whatever its band count.
-func (w *Workspace) zoomSpan() (float64, int) {
+func (w *Workspace) zoomSpan(axis layoutAxis) (float64, int) {
 	// Only the span is read: the tiles go in the zoom scratch, dead on return.
 	var span int
 	w.zoomBuf, span, _ = w.previewTilesInto(w.zoomBuf[:0])
 	if span <= 0 {
 		return overviewMaxZoom, span
 	}
-	room := float64(w.overviewArea().W-w.pileWidth()) * 0.96
+	room := float64(w.overviewArea().W) * 0.96
+	if axis == verticalAxis {
+		room = float64(w.overviewArea().W-w.pileWidth()) * 0.96
+	}
 	z := min(max(room/float64(span), overviewMinZoom), overviewMaxZoom)
 	if w.stacked() {
 		// Reserve two clear peeks on either side of the front row.
 	return z, span
 }
-// slotWidth is the width of the slot of w in a horizontal overview: its
+// rowWidth is the width of the slot of w in a horizontal overview: what its
-// stash pile and its row.
+// tiles take (at most the area), plus the room for the covering floats
-func (w *Workspace) slotWidth() int {
+// peeking on either side of the front card.
-	return w.pileWidth() + w.rowWidth()
+func (w *Workspace) rowWidth(axis layoutAxis) int {
-}
+	z, span := w.zoomSpan(axis)
-// rowWidth is the width of the row of w in a horizontal overview: what its
-// tiles take (at most what the pile leaves of the area), plus the room for
-// the covering floats peeking on either side of the front card.
-func (w *Workspace) rowWidth() int {
-	z, span := w.zoomSpan()
 	if span <= 0 {
 		// An empty workspace keeps the room of a screen.
 		span = w.Usable.W
 	}
-	width := min(int(math.Round(float64(span)*z)), w.overviewArea().W-w.pileWidth())
+	width := min(int(math.Round(float64(span)*z)), w.overviewArea().W)
 	if w.stacked() {
-		width += 4 * w.peekStep()
+		width += 4 * w.peekStep(axis)
 	}
 	return width
 }
 // peekStep is the shared step for a stack row and its front-card inset.
-func (w *Workspace) peekStep() int {
+func (w *Workspace) peekStep(axis layoutAxis) int {
-	return max(1, int(math.Round(float64(w.Usable.H)*w.overviewZoom()*overviewPeekStep)))
+	return max(1, int(math.Round(float64(w.Usable.H)*w.overviewZoom(axis)*overviewPeekStep)))
 }
 // frontSlot is the part of slot the front card of w takes: slot shifted
 // the room of the two after it. A single-card row keeps slot.
 func (w *Workspace) frontSlot(axis layoutAxis, slot Rect) Rect {
 	if w.stacked() {
-		p := w.peekStep()
+		p := w.peekStep(axis)
 		axis.offset(&slot, 2*p)
 		if axis == horizontalAxis {
 			slot.W -= 4 * p
 	return slot
 }
-// pileBand is the band the stash pile of w aligns with in its slot. A
-// vertical overview aligns it with the front card (see frontSlot). A
-// horizontal one puts it level with the selected lane, left of the whole
-// stack of cards.
-func (w *Workspace) pileBand(axis layoutAxis, slot Rect) Rect {
-	if axis == verticalAxis {
-		return w.frontSlot(axis, slot)
-	}
-	slot.Y += (slot.H - int(math.Round(float64(w.Usable.H)*w.overviewZoom()))) / 2
-	return slot
-}
 // rowHeight includes the largest possible stack envelope (two peeks above
 // and two below). Neighbor rows use the same measure as the current row.
-func (w *Workspace) rowHeight() int {
+func (w *Workspace) rowHeight(axis layoutAxis) int {
-	h := int(math.Round(float64(w.Usable.H) * w.overviewZoom()))
+	h := int(math.Round(float64(w.Usable.H) * w.overviewZoom(axis)))
 	if w.stacked() {
-		h += 4 * w.peekStep()
+		h += 4 * w.peekStep(axis)
 	}
 	return h
 }
 // previewRow scales the tiles of w into a row placed in slot, centred
 // in the slot's width, or scrolled so the focused column shows when the
-// row is wider, right of the stash pile. Dimmed rows (neighbor
+// row is wider (right of the stash pile in a vertical overview). Dimmed rows (neighbor
 // workspaces) have no focus; neither has a row whose pile has it (lit
 // false).
 func (w *Workspace) previewRow(axis layoutAxis, slot Rect, dim, lit bool) []Placement {
 // the overview axis shows only its selected lane. In a horizontal overview,
 // tiles entirely outside the area are hidden.
 func (w *Workspace) previewRowTiles(axis layoutAxis, slot Rect, dim, lit, lanes bool, tiles []Placement, span int, sel Rect) []Placement {
-	z := w.overviewZoom()
+	z := w.overviewZoom(axis)
 	scale := func(v int) int { return int(math.Round(float64(v) * z)) }
 	width := scale(span)
 	u := w.overviewArea()
 	if axis == horizontalAxis {
 		top = slot.Y + (slot.H-scale(w.Usable.H))/2
 	}
-	// Rows stay centred on the output like rows without a stash; the pile
+	// Rows stay centred on the output like rows without a stash; in a
-	// only pushes a row right when they would overlap.
+	// vertical overview the pile only pushes a row right when they would
-	left := w.pileWidth()
+	// overlap. A horizontal one draws the pile over the row.
+	left := 0
+	if axis == verticalAxis {
+		left = w.pileWidth()
+	}
 	x := max(slot.X+(slot.W-width)/2, slot.X+left)
 	ux, uw := slot.X+left, slot.W-left
 	if width > uw {
 	return 0
 }
+// overviewHit is overviewIn with the stash piles first: a pile is drawn
+// over its row (a horizontal overview), the cards behind its front one
+// included.
+func (m *Monitor) overviewHit(layout []Placement, x, y float64) WindowID {
+	var piles []Placement
+	for _, p := range layout {
+		if w, _ := m.find(p.ID); w != nil && w.stashIndex(p.ID) >= 0 {
+			piles = append(piles, p)
+		}
+	}
+	if id := overviewIn(piles, x, y); id != 0 {
+		return id
+	}
+	return overviewIn(layout, x, y)
+}
 // overviewClick closes the overview on the preview under the pointer, on
 // the output it shows on. picked is false when no preview is there.
 func (c *Core) overviewClick(ctx context.Context) (picked bool, err error) {
 	}
 	// The cards are hit where they are drawn: a click during the open or a
 	// navigation animation picks what moves under the pointer.
-	id := overviewIn(sc.shownLayout(), c.cursorX-float64(sc.x), c.cursorY-float64(sc.y))
+	id := sc.mon.overviewHit(sc.shownLayout(), c.cursorX-float64(sc.x), c.cursorY-float64(sc.y))
 	if id == 0 {
 		return false, nil
 	}

M internal/core/overview_behavior_test.go +5 -4


@@ -50,12 +50,13 @@ func TestOverviewPeekEnvelopeAndSingleCardHorizontal(t *testing.T) {
50	50		front := previewOf(t, m.Layout(), 7)
51	51		back := previewOf(t, m.Layout(), 8)
52	52		step := float64(front.Rect.Y - back.Rect.Y)
53		-	if step < float64(w.Usable.H)w.overviewZoom()0.06 {
	53	+	if step < float64(w.Usable.H)w.overviewZoom(verticalAxis)0.06 {
54	54		t.Fatalf("peek step %.1f", step)
55	55		}
56		-	y := w.Usable.Y + (w.Usable.H-w.rowHeight())/2
57		-	if back.Rect.Y < y \|\| front.Rect.Y+front.Rect.H > y+w.rowHeight() {
58		-	t.Fatalf("outside row front %+v back %+v row %d..%d", front, back, y, y+w.rowHeight())
	56	+	h := w.rowHeight(verticalAxis)
	57	+	y := w.Usable.Y + (w.Usable.H-h)/2
	58	+	if back.Rect.Y < y \|\| front.Rect.Y+front.Rect.H > y+h {
	59	+	t.Fatalf("outside row front %+v back %+v row %d..%d", front, back, y, y+h)
59	60		}
60	61		m.OverviewMove(1, 0)
61	62		if m.stackFront(w) != (stackItem{stackFloat, 7}) {

 	front := previewOf(t, m.Layout(), 7)
 	back := previewOf(t, m.Layout(), 8)
 	step := float64(front.Rect.Y - back.Rect.Y)
-	if step < float64(w.Usable.H)*w.overviewZoom()*0.06 {
+	if step < float64(w.Usable.H)*w.overviewZoom(verticalAxis)*0.06 {
 		t.Fatalf("peek step %.1f", step)
 	}
-	y := w.Usable.Y + (w.Usable.H-w.rowHeight())/2
+	h := w.rowHeight(verticalAxis)
-	if back.Rect.Y < y || front.Rect.Y+front.Rect.H > y+w.rowHeight() {
+	y := w.Usable.Y + (w.Usable.H-h)/2
-		t.Fatalf("outside row front %+v back %+v row %d..%d", front, back, y, y+w.rowHeight())
+	if back.Rect.Y < y || front.Rect.Y+front.Rect.H > y+h {
+		t.Fatalf("outside row front %+v back %+v row %d..%d", front, back, y, y+h)
 	}
 	m.OverviewMove(1, 0)
 	if m.stackFront(w) != (stackItem{stackFloat, 7}) {

M internal/core/overview_cascade_test.go +165 -36


@@ -2,6 +2,7 @@ package core
2	2
3	3		import (
4	4		"fmt"
	5	+	"math"
5	6		"slices"
6	7		"testing"
7	8

@@ -70,7 +71,7 @@ func hiddenOff(p Placement) bool { return p.Hidden && p.Preview == 0 && !p.Focus
70	71
71	72		// The zoom does not depend on the number of bands.
72	73		func TestOverviewCascadeZoomIgnoresBandCount(t *testing.T) {
73		-	if one, three := cascadeWorkspace(3).overviewZoom(), cascadeWorkspace(7).overviewZoom(); one != three \|\| one != overviewMaxZoom {
	74	+	if one, three := cascadeWorkspace(3).overviewZoom(horizontalAxis), cascadeWorkspace(7).overviewZoom(horizontalAxis); one != three \|\| one != overviewMaxZoom {
74	75		t.Fatalf("zoom with one band %v, with three %v", one, three)
75	76		}
76	77		}

@@ -216,31 +217,40 @@ func TestOverviewCascadeNeighborBelowScrollShowsOneBand(t *testing.T) {
216	217		}
217	218		}
218	219
219		-	// The stash pile is inside the current slot, left of the band; the
220		-	// previous workspace stays clear of it.
	220	+	// The stash pile is centred on the current row, straddling the bottom edge
	221	+	// of the selected lane, over the tiles; it takes no room in the slot.
221	222		func TestOverviewCascadeStashInSlot(t *testing.T) {
222	223		m := cascadeOverview()
	224	+	m.ToggleOverview()
	225	+	bare, _ := m.overviewRows()
	226	+	m.CancelOverview()
223	227		withStash(m, 2)
224	228		m.ToggleOverview()
225	229		rows, _ := m.overviewRows()
226		-	cur, prev := rows[m.Current()], rows[m.Workspaces[0]]
	230	+	w := m.Current()
	231	+	cur, prev := rows[w], rows[m.Workspaces[0]]
	232	+	if cur != bare[w] {
	233	+	t.Fatalf("the pile changed the slot: %v, without it %v", cur, bare[w])
	234	+	}
227	235		ps := m.Layout()
228		-	left := cur.X + cur.W
229		-	for _, id := range []WindowID{7, 8, 9} {
230		-	left = min(left, previewOf(t, ps, id).Rect.X)
	236	+	lane := previewOf(t, ps, 8).Rect
	237	+	// 41 is the front card of the pile, 40 behind it.
	238	+	front := previewOf(t, ps, 41)
	239	+	if front.Hidden \|\| front.Peek \|\| front.Preview != overviewCardZoom {
	240	+	t.Fatalf("front card: %+v", front)
231	241		}
232		-	for _, id := range []WindowID{40, 41} {
233		-	p := previewOf(t, ps, id)
234		-	if p.Hidden \|\| p.Preview != overviewCardZoom {
235		-	t.Fatalf("pile card %d: %+v", id, p)
236		-	}
237		-	if p.Rect.X < cur.X \|\| p.Rect.X+p.Rect.W > left {
238		-	t.Fatalf("pile card %d not inside the slot, left of the band (%d..%d): %+v", id, cur.X, left, p.Rect)
239		-	}
240		-	// 41 is the front card of the pile.
241		-	if id == 41 && !within1(centreY(p.Rect), centreY(previewOf(t, ps, 8).Rect)) {
242		-	t.Fatalf("pile not level with the selected lane: %+v", p.Rect)
243		-	}
	242	+	if back := previewOf(t, ps, 40); back.Hidden \|\| !back.Peek {
	243	+	t.Fatalf("card behind: %+v", back)
	244	+	}
	245	+	if !within1(front.Rect.X+front.Rect.W/2, cur.X+cur.W/2) {
	246	+	t.Fatalf("pile not centred on the row %v: %+v", cur, front.Rect)
	247	+	}
	248	+	// The lane is centred in the slot; its tiles stop a gap short of its
	249	+	// bottom edge.
	250	+	rowH := int(math.Round(float64(w.Usable.H) * w.overviewZoom(horizontalAxis)))
	251	+	bottom := cur.Y + (cur.H-rowH)/2 + rowH
	252	+	if !within1(centreY(front.Rect), bottom) \|\| front.Rect.Y >= lane.Y+lane.H {
	253	+	t.Fatalf("pile not across the lane's bottom edge %d (lane %v): %+v", bottom, lane, front.Rect)
244	254		}
245	255		// The pile does not shift the band: its row stays centred on the area.
246	256		u := m.Current().overviewArea()

@@ -248,11 +258,6 @@ func TestOverviewCascadeStashInSlot(t *testing.T) {
248	258		if mid := (lo.X + hi.X + hi.W) / 2; !within1(mid, u.X+u.W/2) {
249	259		t.Fatalf("band centre %d with a stash, area centre %d", mid, u.X+u.W/2)
250	260		}
251		-	for _, id := range []WindowID{1, 2, 3} {
252		-	if p := previewOf(t, ps, id); !p.Hidden && p.Rect.X+p.Rect.W > cur.X {
253		-	t.Fatalf("previous workspace overlaps the slot with the pile: %+v", p.Rect)
254		-	}
255		-	}
256	261		if prev.X+prev.W > cur.X {
257	262		t.Fatalf("slots overlap: %v %v", prev, cur)
258	263		}

@@ -334,21 +339,32 @@ func TestOverviewCascadeKeys(t *testing.T) {
334	339		}
335	340		m.CancelOverview()
336	341
337		-	// With a stash: left from the first column enters it, right
338		-	// comes back to the band's first column, left twice goes to
339		-	// the previous workspace.
	342	+	// With a stash: left from the first column still goes to the
	343	+	// previous workspace. Down past the last band enters the
	344	+	// stash, right comes back to the band's first column, and
	345	+	// left from the stash goes to the previous workspace.
340	346		withStash(m, 2)
341	347		w.FocusID(7)
342	348		m.ToggleOverview()
343	349		d.move(m, -1, 0)
	350	+	if m.Current() != prev {
	351	+	t.Fatal("left from the first column with a stash did not reach the previous workspace")
	352	+	}
	353	+	m.CancelOverview()
	354	+	m.ToggleOverview()
	355	+	d.move(m, 0, 1)
	356	+	if m.cardAt(w) >= 0 \|\| sel() != 10 {
	357	+	t.Fatalf("down to the last band: card %d, column %d", m.cardAt(w), sel())
	358	+	}
	359	+	d.move(m, 0, 1)
344	360		if m.cardAt(w) < 0 {
345		-	t.Fatal("left from the first column did not select the stash")
	361	+	t.Fatal("down past the last band did not select the stash")
346	362		}
347	363		d.move(m, 1, 0)
348		-	if m.cardAt(w) >= 0 \|\| sel() != 7 {
	364	+	if m.cardAt(w) >= 0 \|\| sel() != 10 {
349	365		t.Fatalf("right from the stash: card %d, column %d", m.cardAt(w), sel())
350	366		}
351		-	d.move(m, -1, 0)
	367	+	d.move(m, 0, 1)
352	368		d.move(m, -1, 0)
353	369		if m.Current() != prev {
354	370		t.Fatal("left from the stash did not reach the previous workspace")

@@ -369,9 +385,9 @@ func TestOverviewCascadeStashPile(t *testing.T) {
369	385		m := cascadeOverview()
370	386		withStash(m, 3)
371	387		w := m.Current()
372		-	w.FocusID(7)
	388	+	w.FocusID(10)
373	389		m.ToggleOverview()
374		-	d.move(m, -1, 0)
	390	+	d.move(m, 0, 1)
375	391		if m.cardAt(w) != w.stashAt {
376	392		t.Fatalf("entered at %d", m.cardAt(w))
377	393		}

@@ -467,6 +483,23 @@ func TestOverviewCascadeThreeFinger(t *testing.T) {
467	483		}
468	484		}
469	485
	486	+	// Three fingers down past the last band enter the stash below it.
	487	+	func TestOverviewCascadeThreeFingerDownEntersStash(t *testing.T) {
	488	+	c, m := cascadeCore(t)
	489	+	withStash(m, 2)
	490	+	w := m.Current()
	491	+	w.FocusID(6)
	492	+	m.ToggleOverview()
	493	+	c.swipeBegin(ports.SwipeBegin{Fingers: 3})
	494	+	for range 4 {
	495	+	c.swipeUpdate(ports.SwipeUpdate{DY: 40})
	496	+	}
	497	+	c.swipeEnd(ports.SwipeEnd{})
	498	+	if m.Current() != w \|\| m.cardAt(w) != w.stashAt {
	499	+	t.Fatalf("swipe down from the last band: card %d, want %d", m.cardAt(w), w.stashAt)
	500	+	}
	501	+	}
	502	+
470	503		// Right from a stash card lands on the maximized column, which keeps its
471	504		// maximization: it is alone in its band.
472	505		func TestOverviewCascadeStashToMaximized(t *testing.T) {

@@ -505,6 +538,102 @@ func TestOverviewCascadeNamedDivider(t *testing.T) {
505	538		}
506	539		}
507	540
	541	+	// A card behind the front one of the pile is clicked where it shows,
	542	+	// over the selected lane's tiles.
	543	+	func TestOverviewCascadeStashPeekClick(t *testing.T) {
	544	+	m := cascadeOverview()
	545	+	withStash(m, 2)
	546	+	m.ToggleOverview()
	547	+	ps := m.Layout()
	548	+	front, back := previewOf(t, ps, 41).Rect, previewOf(t, ps, 40).Rect
	549	+	// The strip of 40 above the front card, inside the lane's tiles.
	550	+	x, y := float64(back.X+back.W-1), float64(back.Y)
	551	+	if back.Y >= front.Y \|\| back.Y < previewOf(t, ps, 8).Rect.Y {
	552	+	t.Fatalf("setup: back %v front %v", back, front)
	553	+	}
	554	+	if id := overviewIn(ps, x, y); id == 40 {
	555	+	t.Fatal("setup: the tiles do not cover the strip")
	556	+	}
	557	+	if id := m.overviewHit(ps, x, y); id != 40 {
	558	+	t.Fatalf("clicked %d, want 40", id)
	559	+	}
	560	+	if id := m.overviewHit(ps, float64(front.X+front.W/2), float64(front.Y+front.H/2)); id != 41 {
	561	+	t.Fatalf("front card clicked %d, want 41", id)
	562	+	}
	563	+	}
	564	+
	565	+	// The pile stays inside the area, down to a tiny output.
	566	+	func TestOverviewCascadeStashInsideArea(t *testing.T) {
	567	+	for _, size := range [][2]int{{300, 200}, {1920, 1080}, {1080, 1920}, {3440, 1440}, {60, 40}} {
	568	+	m := cascadeOverview()
	569	+	m.SetOutput(size[0], size[1])
	570	+	withStash(m, 4)
	571	+	m.ToggleOverview()
	572	+	u := m.Current().overviewArea()
	573	+	for _, id := range []WindowID{40, 41, 42, 43} {
	574	+	p := previewOf(t, m.Layout(), id)
	575	+	if !p.Hidden && (p.Rect.Y < u.Y \|\| p.Rect.Y+p.Rect.H > u.Y+u.H \|\| p.Rect.X < u.X \|\| p.Rect.X+p.Rect.W > u.X+u.W) {
	576	+	t.Fatalf("%v: card %d %v outside %v", size, id, p.Rect, u)
	577	+	}
	578	+	}
	579	+	}
	580	+	}
	581	+
	582	+	// A stash takes no room in a cascade overview, on a neighbor either: a
	583	+	// wide scroll workspace beside it keeps its zoom and slot.
	584	+	func TestOverviewCascadeNeighborStashKeepsSlot(t *testing.T) {
	585	+	m := cascadeOverview()
	586	+	prev := m.Workspaces[0]
	587	+	m.Focus(0)
	588	+	for id := WindowID(60); id < 64; id++ {
	589	+	m.AddWindow(id)
	590	+	}
	591	+	m.Focus(1)
	592	+	m.ToggleOverview()
	593	+	bare, _ := m.overviewRows()
	594	+	zoom := prev.overviewZoom(horizontalAxis)
	595	+	m.CancelOverview()
	596	+	if zoom <= overviewMinZoom \|\| zoom >= overviewMaxZoom {
	597	+	t.Fatalf("setup: neighbor zoom %v is at a bound", zoom)
	598	+	}
	599	+	// The same columns, with one more window stashed.
	600	+	m.Focus(0)
	601	+	m.AddWindow(64)
	602	+	prev.FocusID(64)
	603	+	prev.ToggleWindowStash()
	604	+	m.Focus(1)
	605	+	m.ToggleOverview()
	606	+	rows, _ := m.overviewRows()
	607	+	if rows[prev] != bare[prev] \|\| prev.overviewZoom(horizontalAxis) != zoom {
	608	+	t.Fatalf("neighbor slot %v zoom %v with a stash, %v %v without", rows[prev], prev.overviewZoom(horizontalAxis), bare[prev], zoom)
	609	+	}
	610	+	if p := previewOf(t, m.Layout(), 64); p.Hidden \|\| !p.Peek {
	611	+	t.Fatalf("neighbor pile card: %+v", p)
	612	+	}
	613	+	}
	614	+
	615	+	// Down from a covering float enters the stash; right brings the columns
	616	+	// back to the front.
	617	+	func TestOverviewCascadeFloatStashRight(t *testing.T) {
	618	+	m := cascadeOverview()
	619	+	withStash(m, 1)
	620	+	w := m.Current()
	621	+	w.AddFloating(90, 300, 200)
	622	+	w.FocusID(90)
	623	+	m.ToggleOverview()
	624	+	if f := m.stackFront(w); f.kind != stackFloat {
	625	+	t.Fatalf("setup: front %+v", f)
	626	+	}
	627	+	m.OverviewMove(0, 1)
	628	+	if m.cardAt(w) < 0 {
	629	+	t.Fatal("down from the float did not select the stash")
	630	+	}
	631	+	m.OverviewMove(1, 0)
	632	+	if m.cardAt(w) >= 0 \|\| m.stackFront(w).kind != stackColumns \|\| m.overviewTarget() == 0 {
	633	+	t.Fatalf("right from the stash: card %d, front %+v, target %d", m.cardAt(w), m.stackFront(w), m.overviewTarget())
	634	+	}
	635	+	}
	636	+
508	637		// Covering floats fan along the horizontal axis: left goes deeper in the
509	638		// stack (the cards behind show on the left), right comes back to the front.
510	639		func TestOverviewCascadeCoveringFloat(t *testing.T) {

@@ -553,8 +682,8 @@ func TestOverviewCascadeCoveringFloat(t *testing.T) {
553	682		// The cards behind fan to the left: coming to the front, the
554	683		// columns move right by one peek step.
555	684		front := previewOf(t, m.Layout(), 10)
556		-	if front.Peek \|\| front.Rect.X-behind.Rect.X != w.peekStep() {
557		-	t.Fatalf("columns behind %v, in front %v, peek step %d", behind.Rect, front.Rect, w.peekStep())
	685	+	if front.Peek \|\| front.Rect.X-behind.Rect.X != w.peekStep(horizontalAxis) {
	686	+	t.Fatalf("columns behind %v, in front %v, peek step %d", behind.Rect, front.Rect, w.peekStep(horizontalAxis))
558	687		}
559	688		d.move(m, 1, 0)
560	689		if f := m.stackFront(w); f.kind != stackFloat \|\| f.id != 90 {

@@ -617,9 +746,9 @@ func TestOverviewCascadeFocusBinds(t *testing.T) {
617	746
618	747		// A selected stash card keeps the pile cycle.
619	748		withStash(m, 3)
620		-	w.FocusID(7)
	749	+	w.FocusID(10)
621	750		m.ToggleOverview()
622		-	m.OverviewMove(-1, 0)
	751	+	m.OverviewMove(0, 1)
623	752		at := m.cardAt(w)
624	753		m.overviewFocus(ActionFocusWorkspacePrev)
625	754		if m.Current() != w \|\| m.cardAt(w) != at-1 {


@@ -2,6 +2,7 @@ package core
2			2
3		import (	3		import (
4		"fmt"	4		"fmt"
			5	+	"math"
5		"slices"	6		"slices"
6		"testing"	7		"testing"
7			8

@@ -70,7 +71,7 @@ func hiddenOff(p Placement) bool { return p.Hidden && p.Preview == 0 && !p.Focus
70			71
71		// The zoom does not depend on the number of bands.	72		// The zoom does not depend on the number of bands.
72		func TestOverviewCascadeZoomIgnoresBandCount(t *testing.T) {	73		func TestOverviewCascadeZoomIgnoresBandCount(t *testing.T) {
73	-	if one, three := cascadeWorkspace(3).overviewZoom(), cascadeWorkspace(7).overviewZoom(); one != three \|\| one != overviewMaxZoom {	74	+	if one, three := cascadeWorkspace(3).overviewZoom(horizontalAxis), cascadeWorkspace(7).overviewZoom(horizontalAxis); one != three \|\| one != overviewMaxZoom {
74		t.Fatalf("zoom with one band %v, with three %v", one, three)	75		t.Fatalf("zoom with one band %v, with three %v", one, three)
75		}	76		}
76		}	77		}

@@ -216,31 +217,40 @@ func TestOverviewCascadeNeighborBelowScrollShowsOneBand(t *testing.T) {
216		}	217		}
217		}	218		}
218			219
219	-	// The stash pile is inside the current slot, left of the band; the	220	+	// The stash pile is centred on the current row, straddling the bottom edge
220	-	// previous workspace stays clear of it.	221	+	// of the selected lane, over the tiles; it takes no room in the slot.
221		func TestOverviewCascadeStashInSlot(t *testing.T) {	222		func TestOverviewCascadeStashInSlot(t *testing.T) {
222		m := cascadeOverview()	223		m := cascadeOverview()
			224	+	m.ToggleOverview()
			225	+	bare, _ := m.overviewRows()
			226	+	m.CancelOverview()
223		withStash(m, 2)	227		withStash(m, 2)
224		m.ToggleOverview()	228		m.ToggleOverview()
225		rows, _ := m.overviewRows()	229		rows, _ := m.overviewRows()
226	-	cur, prev := rows[m.Current()], rows[m.Workspaces[0]]	230	+	w := m.Current()
			231	+	cur, prev := rows[w], rows[m.Workspaces[0]]
			232	+	if cur != bare[w] {
			233	+	t.Fatalf("the pile changed the slot: %v, without it %v", cur, bare[w])
			234	+	}
227		ps := m.Layout()	235		ps := m.Layout()
228	-	left := cur.X + cur.W	236	+	lane := previewOf(t, ps, 8).Rect
229	-	for _, id := range []WindowID{7, 8, 9} {	237	+	// 41 is the front card of the pile, 40 behind it.
230	-	left = min(left, previewOf(t, ps, id).Rect.X)	238	+	front := previewOf(t, ps, 41)
			239	+	if front.Hidden \|\| front.Peek \|\| front.Preview != overviewCardZoom {
			240	+	t.Fatalf("front card: %+v", front)
231		}	241		}
232	-	for _, id := range []WindowID{40, 41} {	242	+	if back := previewOf(t, ps, 40); back.Hidden \|\| !back.Peek {
233	-	p := previewOf(t, ps, id)	243	+	t.Fatalf("card behind: %+v", back)
234	-	if p.Hidden \|\| p.Preview != overviewCardZoom {	244	+	}
235	-	t.Fatalf("pile card %d: %+v", id, p)	245	+	if !within1(front.Rect.X+front.Rect.W/2, cur.X+cur.W/2) {
236	-	}	246	+	t.Fatalf("pile not centred on the row %v: %+v", cur, front.Rect)
237	-	if p.Rect.X < cur.X \|\| p.Rect.X+p.Rect.W > left {	247	+	}
238	-	t.Fatalf("pile card %d not inside the slot, left of the band (%d..%d): %+v", id, cur.X, left, p.Rect)	248	+	// The lane is centred in the slot; its tiles stop a gap short of its
239	-	}	249	+	// bottom edge.
240	-	// 41 is the front card of the pile.	250	+	rowH := int(math.Round(float64(w.Usable.H) * w.overviewZoom(horizontalAxis)))
241	-	if id == 41 && !within1(centreY(p.Rect), centreY(previewOf(t, ps, 8).Rect)) {	251	+	bottom := cur.Y + (cur.H-rowH)/2 + rowH
242	-	t.Fatalf("pile not level with the selected lane: %+v", p.Rect)	252	+	if !within1(centreY(front.Rect), bottom) \|\| front.Rect.Y >= lane.Y+lane.H {
243	-	}	253	+	t.Fatalf("pile not across the lane's bottom edge %d (lane %v): %+v", bottom, lane, front.Rect)
244		}	254		}
245		// The pile does not shift the band: its row stays centred on the area.	255		// The pile does not shift the band: its row stays centred on the area.
246		u := m.Current().overviewArea()	256		u := m.Current().overviewArea()

@@ -248,11 +258,6 @@ func TestOverviewCascadeStashInSlot(t *testing.T) {
248		if mid := (lo.X + hi.X + hi.W) / 2; !within1(mid, u.X+u.W/2) {	258		if mid := (lo.X + hi.X + hi.W) / 2; !within1(mid, u.X+u.W/2) {
249		t.Fatalf("band centre %d with a stash, area centre %d", mid, u.X+u.W/2)	259		t.Fatalf("band centre %d with a stash, area centre %d", mid, u.X+u.W/2)
250		}	260		}
251	-	for _, id := range []WindowID{1, 2, 3} {
252	-	if p := previewOf(t, ps, id); !p.Hidden && p.Rect.X+p.Rect.W > cur.X {
253	-	t.Fatalf("previous workspace overlaps the slot with the pile: %+v", p.Rect)
254	-	}
255	-	}
256		if prev.X+prev.W > cur.X {	261		if prev.X+prev.W > cur.X {
257		t.Fatalf("slots overlap: %v %v", prev, cur)	262		t.Fatalf("slots overlap: %v %v", prev, cur)
258		}	263		}

@@ -334,21 +339,32 @@ func TestOverviewCascadeKeys(t *testing.T) {
334		}	339		}
335		m.CancelOverview()	340		m.CancelOverview()
336			341
337	-	// With a stash: left from the first column enters it, right	342	+	// With a stash: left from the first column still goes to the
338	-	// comes back to the band's first column, left twice goes to	343	+	// previous workspace. Down past the last band enters the
339	-	// the previous workspace.	344	+	// stash, right comes back to the band's first column, and
			345	+	// left from the stash goes to the previous workspace.
340		withStash(m, 2)	346		withStash(m, 2)
341		w.FocusID(7)	347		w.FocusID(7)
342		m.ToggleOverview()	348		m.ToggleOverview()
343		d.move(m, -1, 0)	349		d.move(m, -1, 0)
			350	+	if m.Current() != prev {
			351	+	t.Fatal("left from the first column with a stash did not reach the previous workspace")
			352	+	}
			353	+	m.CancelOverview()
			354	+	m.ToggleOverview()
			355	+	d.move(m, 0, 1)
			356	+	if m.cardAt(w) >= 0 \|\| sel() != 10 {
			357	+	t.Fatalf("down to the last band: card %d, column %d", m.cardAt(w), sel())
			358	+	}
			359	+	d.move(m, 0, 1)
344		if m.cardAt(w) < 0 {	360		if m.cardAt(w) < 0 {
345	-	t.Fatal("left from the first column did not select the stash")	361	+	t.Fatal("down past the last band did not select the stash")
346		}	362		}
347		d.move(m, 1, 0)	363		d.move(m, 1, 0)
348	-	if m.cardAt(w) >= 0 \|\| sel() != 7 {	364	+	if m.cardAt(w) >= 0 \|\| sel() != 10 {
349		t.Fatalf("right from the stash: card %d, column %d", m.cardAt(w), sel())	365		t.Fatalf("right from the stash: card %d, column %d", m.cardAt(w), sel())
350		}	366		}
351	-	d.move(m, -1, 0)	367	+	d.move(m, 0, 1)
352		d.move(m, -1, 0)	368		d.move(m, -1, 0)
353		if m.Current() != prev {	369		if m.Current() != prev {
354		t.Fatal("left from the stash did not reach the previous workspace")	370		t.Fatal("left from the stash did not reach the previous workspace")

@@ -369,9 +385,9 @@ func TestOverviewCascadeStashPile(t *testing.T) {
369		m := cascadeOverview()	385		m := cascadeOverview()
370		withStash(m, 3)	386		withStash(m, 3)
371		w := m.Current()	387		w := m.Current()
372	-	w.FocusID(7)	388	+	w.FocusID(10)
373		m.ToggleOverview()	389		m.ToggleOverview()
374	-	d.move(m, -1, 0)	390	+	d.move(m, 0, 1)
375		if m.cardAt(w) != w.stashAt {	391		if m.cardAt(w) != w.stashAt {
376		t.Fatalf("entered at %d", m.cardAt(w))	392		t.Fatalf("entered at %d", m.cardAt(w))
377		}	393		}

@@ -467,6 +483,23 @@ func TestOverviewCascadeThreeFinger(t *testing.T) {
467		}	483		}
468		}	484		}
469			485
			486	+	// Three fingers down past the last band enter the stash below it.
			487	+	func TestOverviewCascadeThreeFingerDownEntersStash(t *testing.T) {
			488	+	c, m := cascadeCore(t)
			489	+	withStash(m, 2)
			490	+	w := m.Current()
			491	+	w.FocusID(6)
			492	+	m.ToggleOverview()
			493	+	c.swipeBegin(ports.SwipeBegin{Fingers: 3})
			494	+	for range 4 {
			495	+	c.swipeUpdate(ports.SwipeUpdate{DY: 40})
			496	+	}
			497	+	c.swipeEnd(ports.SwipeEnd{})
			498	+	if m.Current() != w \|\| m.cardAt(w) != w.stashAt {
			499	+	t.Fatalf("swipe down from the last band: card %d, want %d", m.cardAt(w), w.stashAt)
			500	+	}
			501	+	}
			502	+
470		// Right from a stash card lands on the maximized column, which keeps its	503		// Right from a stash card lands on the maximized column, which keeps its
471		// maximization: it is alone in its band.	504		// maximization: it is alone in its band.
472		func TestOverviewCascadeStashToMaximized(t *testing.T) {	505		func TestOverviewCascadeStashToMaximized(t *testing.T) {

@@ -505,6 +538,102 @@ func TestOverviewCascadeNamedDivider(t *testing.T) {
505		}	538		}
506		}	539		}
507			540
			541	+	// A card behind the front one of the pile is clicked where it shows,
			542	+	// over the selected lane's tiles.
			543	+	func TestOverviewCascadeStashPeekClick(t *testing.T) {
			544	+	m := cascadeOverview()
			545	+	withStash(m, 2)
			546	+	m.ToggleOverview()
			547	+	ps := m.Layout()
			548	+	front, back := previewOf(t, ps, 41).Rect, previewOf(t, ps, 40).Rect
			549	+	// The strip of 40 above the front card, inside the lane's tiles.
			550	+	x, y := float64(back.X+back.W-1), float64(back.Y)
			551	+	if back.Y >= front.Y \|\| back.Y < previewOf(t, ps, 8).Rect.Y {
			552	+	t.Fatalf("setup: back %v front %v", back, front)
			553	+	}
			554	+	if id := overviewIn(ps, x, y); id == 40 {
			555	+	t.Fatal("setup: the tiles do not cover the strip")
			556	+	}
			557	+	if id := m.overviewHit(ps, x, y); id != 40 {
			558	+	t.Fatalf("clicked %d, want 40", id)
			559	+	}
			560	+	if id := m.overviewHit(ps, float64(front.X+front.W/2), float64(front.Y+front.H/2)); id != 41 {
			561	+	t.Fatalf("front card clicked %d, want 41", id)
			562	+	}
			563	+	}
			564	+
			565	+	// The pile stays inside the area, down to a tiny output.
			566	+	func TestOverviewCascadeStashInsideArea(t *testing.T) {
			567	+	for _, size := range [][2]int{{300, 200}, {1920, 1080}, {1080, 1920}, {3440, 1440}, {60, 40}} {
			568	+	m := cascadeOverview()
			569	+	m.SetOutput(size[0], size[1])
			570	+	withStash(m, 4)
			571	+	m.ToggleOverview()
			572	+	u := m.Current().overviewArea()
			573	+	for _, id := range []WindowID{40, 41, 42, 43} {
			574	+	p := previewOf(t, m.Layout(), id)
			575	+	if !p.Hidden && (p.Rect.Y < u.Y \|\| p.Rect.Y+p.Rect.H > u.Y+u.H \|\| p.Rect.X < u.X \|\| p.Rect.X+p.Rect.W > u.X+u.W) {
			576	+	t.Fatalf("%v: card %d %v outside %v", size, id, p.Rect, u)
			577	+	}
			578	+	}
			579	+	}
			580	+	}
			581	+
			582	+	// A stash takes no room in a cascade overview, on a neighbor either: a
			583	+	// wide scroll workspace beside it keeps its zoom and slot.
			584	+	func TestOverviewCascadeNeighborStashKeepsSlot(t *testing.T) {
			585	+	m := cascadeOverview()
			586	+	prev := m.Workspaces[0]
			587	+	m.Focus(0)
			588	+	for id := WindowID(60); id < 64; id++ {
			589	+	m.AddWindow(id)
			590	+	}
			591	+	m.Focus(1)
			592	+	m.ToggleOverview()
			593	+	bare, _ := m.overviewRows()
			594	+	zoom := prev.overviewZoom(horizontalAxis)
			595	+	m.CancelOverview()
			596	+	if zoom <= overviewMinZoom \|\| zoom >= overviewMaxZoom {
			597	+	t.Fatalf("setup: neighbor zoom %v is at a bound", zoom)
			598	+	}
			599	+	// The same columns, with one more window stashed.
			600	+	m.Focus(0)
			601	+	m.AddWindow(64)
			602	+	prev.FocusID(64)
			603	+	prev.ToggleWindowStash()
			604	+	m.Focus(1)
			605	+	m.ToggleOverview()
			606	+	rows, _ := m.overviewRows()
			607	+	if rows[prev] != bare[prev] \|\| prev.overviewZoom(horizontalAxis) != zoom {
			608	+	t.Fatalf("neighbor slot %v zoom %v with a stash, %v %v without", rows[prev], prev.overviewZoom(horizontalAxis), bare[prev], zoom)
			609	+	}
			610	+	if p := previewOf(t, m.Layout(), 64); p.Hidden \|\| !p.Peek {
			611	+	t.Fatalf("neighbor pile card: %+v", p)
			612	+	}
			613	+	}
			614	+
			615	+	// Down from a covering float enters the stash; right brings the columns
			616	+	// back to the front.
			617	+	func TestOverviewCascadeFloatStashRight(t *testing.T) {
			618	+	m := cascadeOverview()
			619	+	withStash(m, 1)
			620	+	w := m.Current()
			621	+	w.AddFloating(90, 300, 200)
			622	+	w.FocusID(90)
			623	+	m.ToggleOverview()
			624	+	if f := m.stackFront(w); f.kind != stackFloat {
			625	+	t.Fatalf("setup: front %+v", f)
			626	+	}
			627	+	m.OverviewMove(0, 1)
			628	+	if m.cardAt(w) < 0 {
			629	+	t.Fatal("down from the float did not select the stash")
			630	+	}
			631	+	m.OverviewMove(1, 0)
			632	+	if m.cardAt(w) >= 0 \|\| m.stackFront(w).kind != stackColumns \|\| m.overviewTarget() == 0 {
			633	+	t.Fatalf("right from the stash: card %d, front %+v, target %d", m.cardAt(w), m.stackFront(w), m.overviewTarget())
			634	+	}
			635	+	}
			636	+
508		// Covering floats fan along the horizontal axis: left goes deeper in the	637		// Covering floats fan along the horizontal axis: left goes deeper in the
509		// stack (the cards behind show on the left), right comes back to the front.	638		// stack (the cards behind show on the left), right comes back to the front.
510		func TestOverviewCascadeCoveringFloat(t *testing.T) {	639		func TestOverviewCascadeCoveringFloat(t *testing.T) {

@@ -553,8 +682,8 @@ func TestOverviewCascadeCoveringFloat(t *testing.T) {
553		// The cards behind fan to the left: coming to the front, the	682		// The cards behind fan to the left: coming to the front, the
554		// columns move right by one peek step.	683		// columns move right by one peek step.
555		front := previewOf(t, m.Layout(), 10)	684		front := previewOf(t, m.Layout(), 10)
556	-	if front.Peek \|\| front.Rect.X-behind.Rect.X != w.peekStep() {	685	+	if front.Peek \|\| front.Rect.X-behind.Rect.X != w.peekStep(horizontalAxis) {
557	-	t.Fatalf("columns behind %v, in front %v, peek step %d", behind.Rect, front.Rect, w.peekStep())	686	+	t.Fatalf("columns behind %v, in front %v, peek step %d", behind.Rect, front.Rect, w.peekStep(horizontalAxis))
558		}	687		}
559		d.move(m, 1, 0)	688		d.move(m, 1, 0)
560		if f := m.stackFront(w); f.kind != stackFloat \|\| f.id != 90 {	689		if f := m.stackFront(w); f.kind != stackFloat \|\| f.id != 90 {

@@ -617,9 +746,9 @@ func TestOverviewCascadeFocusBinds(t *testing.T) {
617			746
618		// A selected stash card keeps the pile cycle.	747		// A selected stash card keeps the pile cycle.
619		withStash(m, 3)	748		withStash(m, 3)
620	-	w.FocusID(7)	749	+	w.FocusID(10)
621		m.ToggleOverview()	750		m.ToggleOverview()
622	-	m.OverviewMove(-1, 0)	751	+	m.OverviewMove(0, 1)
623		at := m.cardAt(w)	752		at := m.cardAt(w)
624		m.overviewFocus(ActionFocusWorkspacePrev)	753		m.overviewFocus(ActionFocusWorkspacePrev)
625		if m.Current() != w \|\| m.cardAt(w) != at-1 {	754		if m.Current() != w \|\| m.cardAt(w) != at-1 {

M internal/core/overview_stack.go +1 -1


@@ -354,7 +354,7 @@ func (m Monitor) stackRow(w Workspace, axis layoutAxis, slot Rect, dim, lit bo
354	354		at = slices.Index(items, m.stackFront(w))
355	355		}
356	356		cards := make([][]Placement, len(items))
357		-	step := w.peekStep()
	357	+	step := w.peekStep(axis)
358	358		// along is the offset of d steps on the overview axis.
359	359		along := func(d int) (int, int) {
360	360		var r Rect


@@ -354,7 +354,7 @@ func (m Monitor) stackRow(w Workspace, axis layoutAxis, slot Rect, dim, lit bo
354		at = slices.Index(items, m.stackFront(w))	354		at = slices.Index(items, m.stackFront(w))
355		}	355		}
356		cards := make([][]Placement, len(items))	356		cards := make([][]Placement, len(items))
357	-	step := w.peekStep()	357	+	step := w.peekStep(axis)
358		// along is the offset of d steps on the overview axis.	358		// along is the offset of d steps on the overview axis.
359		along := func(d int) (int, int) {	359		along := func(d int) (int, int) {
360		var r Rect	360		var r Rect