a82be5b feat(overview): unfold the vertical overview stash as a carousel too · neferwl

M docs/config.md +3 -3


@@ -276,8 +276,8 @@ The window must appear within 5 seconds, otherwise it opens normally. Apps that
276	276
277	277		`toggle-overview` (or a four-finger swipe up) shows previews of your workspaces. Arrows, `h/j/k/l` or three-finger swipes move the selection; `Return` or a click opens it; `Escape` goes back. `close-window` and the move-to-workspace binds work on the selected preview.
278	278
279		-	A workspace's stash shows as a pile of cards. Selecting the pile unfolds it, so you see every stashed window: a carousel under the workspace with `layout.overflow = cascade`, a column on its left otherwise. The carousel keeps the selected card in the middle, the earlier cards on its left and the later ones on its right, wrapping round; a wider gap separates the newest card from the oldest. Moves along the unfolded pile pick a card; a pile longer than the screen scrolls with the selection. Leaving it folds it again.
	279	+	A workspace's stash shows as a pile of cards. Selecting the pile unfolds it into a carousel of every stashed window: a row under the workspace with `layout.overflow = cascade`, a column on its left otherwise. The selected card stays in the middle, the earlier cards before it and the later ones after it, wrapping round; a wider gap separates the newest card from the oldest. Moves along the carousel pick a card. With fewer than three cards, or on a workspace holding only stashed windows, it does not wrap round. Leaving it folds it again.
280	280
281		-	With `layout.overflow = cascade`, workspaces sit side by side, each band of columns is a lane, and the stash sits under the lanes. Down (or fingers down on the touchpad, with natural scroll off) moves to the lane below; past the last lane it unfolds the stash. Left/right walk the cards round the carousel; with fewer than three cards, or on a workspace holding only stashed windows, they go to the neighbor workspace past either end. Up leaves the stash for the last lane, at the column you came from.
	281	+	With `layout.overflow = cascade`, workspaces sit side by side, each band of columns is a lane, and the stash sits under the lanes. Down (or fingers down on the touchpad, with natural scroll off) moves to the lane below; past the last lane it unfolds the stash. Left/right walk the cards; where the carousel does not wrap round, they go to the neighbor workspace past either end. Up leaves the stash for the last lane, at the column you came from.
282	282
283		-	Otherwise, left from the first column unfolds the stash. Up/down walk the cards and right goes back to the columns.
	283	+	Otherwise, left from the first column unfolds the stash. Up/down walk the cards, the focus-workspace binds change workspace, and right goes back to the columns.


@@ -276,8 +276,8 @@ The window must appear within 5 seconds, otherwise it opens normally. Apps that
276			276
277		`toggle-overview` (or a four-finger swipe up) shows previews of your workspaces. Arrows, `h/j/k/l` or three-finger swipes move the selection; `Return` or a click opens it; `Escape` goes back. `close-window` and the move-to-workspace binds work on the selected preview.	277		`toggle-overview` (or a four-finger swipe up) shows previews of your workspaces. Arrows, `h/j/k/l` or three-finger swipes move the selection; `Return` or a click opens it; `Escape` goes back. `close-window` and the move-to-workspace binds work on the selected preview.
278			278
279	-	A workspace's stash shows as a pile of cards. Selecting the pile unfolds it, so you see every stashed window: a carousel under the workspace with `layout.overflow = cascade`, a column on its left otherwise. The carousel keeps the selected card in the middle, the earlier cards on its left and the later ones on its right, wrapping round; a wider gap separates the newest card from the oldest. Moves along the unfolded pile pick a card; a pile longer than the screen scrolls with the selection. Leaving it folds it again.	279	+	A workspace's stash shows as a pile of cards. Selecting the pile unfolds it into a carousel of every stashed window: a row under the workspace with `layout.overflow = cascade`, a column on its left otherwise. The selected card stays in the middle, the earlier cards before it and the later ones after it, wrapping round; a wider gap separates the newest card from the oldest. Moves along the carousel pick a card. With fewer than three cards, or on a workspace holding only stashed windows, it does not wrap round. Leaving it folds it again.
280			280
281	-	With `layout.overflow = cascade`, workspaces sit side by side, each band of columns is a lane, and the stash sits under the lanes. Down (or fingers down on the touchpad, with natural scroll off) moves to the lane below; past the last lane it unfolds the stash. Left/right walk the cards round the carousel; with fewer than three cards, or on a workspace holding only stashed windows, they go to the neighbor workspace past either end. Up leaves the stash for the last lane, at the column you came from.	281	+	With `layout.overflow = cascade`, workspaces sit side by side, each band of columns is a lane, and the stash sits under the lanes. Down (or fingers down on the touchpad, with natural scroll off) moves to the lane below; past the last lane it unfolds the stash. Left/right walk the cards; where the carousel does not wrap round, they go to the neighbor workspace past either end. Up leaves the stash for the last lane, at the column you came from.
282			282
283	-	Otherwise, left from the first column unfolds the stash. Up/down walk the cards and right goes back to the columns.	283	+	Otherwise, left from the first column unfolds the stash. Up/down walk the cards, the focus-workspace binds change workspace, and right goes back to the columns.

M internal/core/overview.go +77 -94


@@ -57,9 +57,8 @@ type rowSnapshot struct {
57	57		// (not selected), the stash's own selection is in front at
58	58		// overviewCardZoom, up to overviewCards-1 others behind it, each
59	59		// overviewCardStep further up and right, dimmed. Selected, the pile
60		-	// unfolds along the overview axis (unfold), the selection framed, and the
61		-	// moves along that axis walk it: a column of every card in a vertical
62		-	// overview, a carousel centred on the selection in a horizontal one. A vertical
	60	+	// unfolds along the overview axis into a carousel centred on the selection
	61	+	// (unfold), framed, and the moves along that axis walk it round. A vertical
63	62		// overview pins the pile to the left edge of its row, which takes the width
64	63		// the pile leaves. A horizontal one centres it on its row, in a band
65	64		// reserved under the selected lane (pileBand): the lane and the band are

@@ -159,15 +158,6 @@ func (m Monitor) cardAt(w Workspace) int {
159	158		return -1
160	159		}
161	160
162		-	// carouselCard is the selected card of w's stash when it unfolds as a
163		-	// carousel (a horizontal overview), -1 otherwise.
164		-	func (m Monitor) carouselCard(w Workspace) int {
165		-	if !m.previewing() \|\| m.overviewAxis() != horizontalAxis {
166		-	return -1
167		-	}
168		-	return m.cardAt(w)
169		-	}
170		-
171	161		// overviewTarget resolves the active preview to one window for validation
172	162		// and window actions. Presentation state never falls back to a covering float.
173	163		func (m *Monitor) overviewTarget() WindowID {

@@ -412,11 +402,11 @@ func (m *Monitor) OverviewMove(dx, dy int) {
412	402		}
413	403
414	404		// overviewWorkspaceStep is a focus-workspace bind. A vertical overview
415		-	// walks the unfolded stash and the stack cards before changing workspace
416		-	// (overviewVertical). A side-by-side one always changes workspace, since
417		-	// its stack and unfolded stash run left and right.
	405	+	// walks the stack cards before changing workspace (overviewVertical), not
	406	+	// the unfolded stash, which wraps round. A side-by-side one always changes
	407	+	// workspace, since its stack and unfolded stash run left and right.
418	408		func (m *Monitor) overviewWorkspaceStep(d int) {
419		-	if m.overviewAxis() == verticalAxis {
	409	+	if m.overviewAxis() == verticalAxis && m.cardAt(m.Current()) < 0 {
420	410		m.overviewVertical(d)
421	411		return
422	412		}

@@ -424,17 +414,45 @@ func (m *Monitor) overviewWorkspaceStep(d int) {
424	414		}
425	415
426	416		// cycleCard selects the stash card d entries from the selected one of w in
427		-	// the unfolded pile, stopping at either end. It reports whether a card was
428		-	// selected.
	417	+	// the unfolded pile, wrapping round (wrapsCards), else stopping at either
	418	+	// end. It reports whether a card was selected.
429	419		func (m Monitor) cycleCard(w Workspace, d int) bool {
430	420		at := m.cardAt(w)
431	421		if at < 0 {
432	422		return false
433	423		}
434		-	m.selectCard(w, min(max(at+d, 0), len(w.Stash)-1))
	424	+	if !m.stepCard(w, at, d) {
	425	+	m.selectCard(w, min(max(at+d, 0), len(w.Stash)-1))
	426	+	}
	427	+	return true
	428	+	}
	429	+
	430	+	// stepCard selects the stash card d entries from card at of w, wrapping
	431	+	// round when the carousel does (wrapsCards). It reports false, selecting
	432	+	// nothing, past an end of one that does not.
	433	+	func (m Monitor) stepCard(w Workspace, at, d int) bool {
	434	+	n, next := len(w.Stash), at+d
	435	+	if next < 0 \|\| next >= n {
	436	+	if !w.wrapsCards() {
	437	+	return false
	438	+	}
	439	+	next = (next%n + n) % n
	440	+	}
	441	+	m.selectCard(w, next)
435	442		return true
436	443		}
437	444
	445	+	// wrapsCards reports whether the unfolded stash of w wraps round, drawn
	446	+	// (unfold) and walked (stepCard). A carousel of fewer than three cards does
	447	+	// not, so that each side has the card its move selects; nor does the one
	448	+	// of a stash-only workspace, which has nothing beside its pile to leave it
	449	+	// for. Past the ends of one that does not, a move goes on as from a lane
	450	+	// (cascade) or stops (a vertical overview).
	451	+	func (w *Workspace) wrapsCards() bool {
	452	+	_, k := w.stackHead()
	453	+	return k > 0 && len(w.Stash) >= 3
	454	+	}
	455	+
438	456		// overviewLane is the vertical move of an overview whose workspaces sit side
439	457		// by side (cascade). From the unfolded stash, up leaves it for the last lane
440	458		// (leavePile) and down stays: the stash is the bottom. Else the selection

@@ -490,29 +508,18 @@ func (m Monitor) selectLaneColumn(w Workspace, i int) {
490	508
491	509		// overviewAcross is the horizontal move of an overview whose workspaces sit
492	510		// side by side (cascade): a column inside the selected lane, or a card of
493		-	// the unfolded stash, which wraps round (carousel). Past the first column
494		-	// it goes to the previous workspace; past the last, to the next workspace.
495		-	// A carousel of fewer than three cards does not wrap, nor does the one of a
496		-	// stash-only workspace, which has nothing above its pile: there the ends
497		-	// change workspace like a lane's.
	511	+	// the unfolded stash, which wraps round (stepCard). Past the first column
	512	+	// or a card that does not wrap, it goes to the previous workspace; past
	513	+	// the last, to the next workspace.
498	514		// Covering floats fan
499	515		// along this axis and are traversed before a workspace: the card on the
500	516		// left is the one behind.
501	517		func (m *Monitor) overviewAcross(dx int) {
502	518		w := m.Current()
503	519		if at := m.cardAt(w); at >= 0 {
504		-	n, next := len(w.Stash), at+dx
505		-	if next >= 0 && next < n {
506		-	m.selectCard(w, next)
507		-	return
508		-	}
509		-	if _, k := w.stackHead(); k == 0 \|\| n < 3 {
510		-	// Nothing above the pile to leave it for, or too few
511		-	// cards to wrap round: the ends are the way out.
	520	+	if !m.stepCard(w, at, dx) {
512	521		m.overviewStep(dx)
513		-	return
514	522		}
515		-	m.selectCard(w, (next+n)%n)
516	523		return
517	524		}
518	525		if m.stackFront(w).kind != stackColumns \|\| len(w.Columns) == 0 {

@@ -937,86 +944,62 @@ func (w *Workspace) pile(dst []Placement, axis layoutAxis, slot Rect, dim bool,
937	944		return dst
938	945		}
939	946
940		-	// unfold lays the stash of w out from the folded pile's card rect. A
941		-	// vertical overview lines every card up in a column (strip). A horizontal
942		-	// one spreads them as a carousel (carousel). Cards other than the selected
943		-	// one at are dimmed; those out of the overview area are hidden. The cards
944		-	// are appended to dst.
	947	+	// unfold lays the stash of w out from the folded pile's card rect as a
	948	+	// carousel along axis: a row in a horizontal overview, a column in a
	949	+	// vertical one. The selected card at sits on the pile, in the middle; the
	950	+	// cards before it come on the left (above), the ones after it on the right
	951	+	// (below), in stash order, wrapping round (wrapsCards) with the oldest
	952	+	// following the newest (carouselSlot). A wider gap marks that seam. When the carousel fits the
	953	+	// overview area it is shifted into it; else the cards past the area are
	954	+	// hidden. Cards other than at are dimmed. The cards are appended to dst.
945	955		func (w *Workspace) unfold(dst []Placement, axis layoutAxis, folded Rect, at int) []Placement {
946		-	if axis == horizontalAxis {
947		-	return w.carousel(dst, folded, at)
948		-	}
949		-	return w.strip(dst, folded, at)
950		-	}
951		-
952		-	// strip lays the stash out as a column of every card, in stash order,
953		-	// centred on the pile and kept in the overview area. Longer than the area,
954		-	// it scrolls like a wide row: the selected card at is centred, the strip
955		-	// stopping at the area's edges.
956		-	func (w *Workspace) strip(dst []Placement, folded Rect, at int) []Placement {
957	956		n := len(w.Stash)
958	957		u := w.overviewArea()
959		-	size, lo, hi := folded.H, u.Y, u.Y+u.H
960		-	stride := size + 2*w.cardStep()
961		-	total := n*stride - (stride - size)
962		-	start := folded.Y + size/2 - total/2
963		-	if total > hi-lo {
964		-	start = folded.Y - at*stride
965		-	start = min(max(start, hi-total), lo)
966		-	} else {
967		-	start = min(max(start, lo), hi-total)
968		-	}
969		-	for i := range w.Stash {
970		-	r := folded
971		-	r.Y = start + i*stride
972		-	dst = w.unfoldedCard(dst, i, r, at, u)
	958	+	size, origin, lo, room := folded.W, folded.X, u.X, u.W
	959	+	if axis == verticalAxis {
	960	+	size, origin, lo, room = folded.H, folded.Y, u.Y, u.H
973	961		}
974		-	return dst
975		-	}
976		-
977		-	// carousel lays the stash out as a row centred on the selected card at,
978		-	// under the pile, in stash order wrapping round: the cards before it on
979		-	// the left, the ones after it on the right, the oldest following the
980		-	// newest (carouselSlot). A wider gap marks that seam. When the row fits
981		-	// the overview area it is shifted into it; else the cards past the area
982		-	// are hidden.
983		-	func (w *Workspace) carousel(dst []Placement, folded Rect, at int) []Placement {
984		-	n := len(w.Stash)
985		-	u := w.overviewArea()
986		-	stride := folded.W + 2*w.cardStep()
	962	+	stride := size + 2*w.cardStep()
987	963		// The extra room at the seam, on top of the stride.
988		-	gap := folded.W / 4
989		-	x := func(i int) int {
990		-	s := carouselSlot(i, at, n)
991		-	x := folded.X + s*stride
	964	+	gap := size / 4
	965	+	wraps := w.wrapsCards()
	966	+	pos := func(i int) int {
	967	+	s := carouselSlot(i, at, n, wraps)
	968	+	p := origin + s*stride
992	969		switch {
993	970		case s > 0 && at+s >= n:
994		-	x += gap
	971	+	p += gap
995	972		case s < 0 && at+s < 0:
996		-	x -= gap
	973	+	p -= gap
997	974		}
998		-	return x
	975	+	return p
	976	+	}
	977	+	first, last := pos(0), pos(n-1)
	978	+	if wraps {
	979	+	first, last = pos((at+n-n/2)%n), pos((at+(n-1)/2)%n)
999	980		}
1000		-	first, last := x((at+n-n/2)%n), x((at+(n-1)/2)%n)
1001	981		shift := 0
1002		-	if total := last + folded.W - first; total <= u.W {
1003		-	shift = min(max(first, u.X), u.X+u.W-total) - first
	982	+	if total := last + size - first; total <= room {
	983	+	shift = min(max(first, lo), lo+room-total) - first
1004	984		}
1005	985		for i := range w.Stash {
1006	986		r := folded
1007		-	r.X = x(i) + shift
	987	+	if axis == verticalAxis {
	988	+	r.Y = pos(i) + shift
	989	+	} else {
	990	+	r.X = pos(i) + shift
	991	+	}
1008	992		dst = w.unfoldedCard(dst, i, r, at, u)
1009	993		}
1010	994		return dst
1011	995		}
1012	996
1013	997		// carouselSlot is the place of stash card i in a carousel of n cards
1014		-	// centred on card at: 0 for at, negative on the left, positive on the
1015		-	// right. The left side takes the extra card of an even count. Fewer than
1016		-	// three cards keep the stash order without wrapping round, so that each
1017		-	// side has the card its move selects.
1018		-	func carouselSlot(i, at, n int) int {
1019		-	if n < 3 {
	998	+	// centred on card at: 0 for at, negative on the left (above), positive on
	999	+	// the right (below). Wrapping round, the left side takes the extra card of
	1000	+	// an even count; else the cards keep the stash order.
	1001	+	func carouselSlot(i, at, n int, wraps bool) int {
	1002	+	if !wraps {
1020	1003		return i - at
1021	1004		}
1022	1005		s := (i - at + n) % n

 // (not selected), the stash's own selection is in front at
 // overviewCardZoom, up to overviewCards-1 others behind it, each
 // overviewCardStep further up and right, dimmed. Selected, the pile
-// unfolds along the overview axis (unfold), the selection framed, and the
+// unfolds along the overview axis into a carousel centred on the selection
-// moves along that axis walk it: a column of every card in a vertical
+// (unfold), framed, and the moves along that axis walk it round. A vertical
-// overview, a carousel centred on the selection in a horizontal one. A vertical
 // overview pins the pile to the left edge of its row, which takes the width
 // the pile leaves. A horizontal one centres it on its row, in a band
 // reserved under the selected lane (pileBand): the lane and the band are
 	return -1
 }
-// carouselCard is the selected card of w's stash when it unfolds as a
-// carousel (a horizontal overview), -1 otherwise.
-func (m *Monitor) carouselCard(w *Workspace) int {
-	if !m.previewing() || m.overviewAxis() != horizontalAxis {
-		return -1
-	}
-	return m.cardAt(w)
-}
 // overviewTarget resolves the active preview to one window for validation
 // and window actions. Presentation state never falls back to a covering float.
 func (m *Monitor) overviewTarget() WindowID {
 }
 // overviewWorkspaceStep is a focus-workspace bind. A vertical overview
-// walks the unfolded stash and the stack cards before changing workspace
+// walks the stack cards before changing workspace (overviewVertical), not
-// (overviewVertical). A side-by-side one always changes workspace, since
+// the unfolded stash, which wraps round. A side-by-side one always changes
-// its stack and unfolded stash run left and right.
+// workspace, since its stack and unfolded stash run left and right.
 func (m *Monitor) overviewWorkspaceStep(d int) {
-	if m.overviewAxis() == verticalAxis {
+	if m.overviewAxis() == verticalAxis && m.cardAt(m.Current()) < 0 {
 		m.overviewVertical(d)
 		return
 	}
 }
 // cycleCard selects the stash card d entries from the selected one of w in
-// the unfolded pile, stopping at either end. It reports whether a card was
+// the unfolded pile, wrapping round (wrapsCards), else stopping at either
-// selected.
+// end. It reports whether a card was selected.
 func (m *Monitor) cycleCard(w *Workspace, d int) bool {
 	at := m.cardAt(w)
 	if at < 0 {
 		return false
 	}
-	m.selectCard(w, min(max(at+d, 0), len(w.Stash)-1))
+	if !m.stepCard(w, at, d) {
+		m.selectCard(w, min(max(at+d, 0), len(w.Stash)-1))
+	}
+	return true
+}
+// stepCard selects the stash card d entries from card at of w, wrapping
+// round when the carousel does (wrapsCards). It reports false, selecting
+// nothing, past an end of one that does not.
+func (m *Monitor) stepCard(w *Workspace, at, d int) bool {
+	n, next := len(w.Stash), at+d
+	if next < 0 || next >= n {
+		if !w.wrapsCards() {
+			return false
+		}
+		next = (next%n + n) % n
+	}
+	m.selectCard(w, next)
 	return true
 }
+// wrapsCards reports whether the unfolded stash of w wraps round, drawn
+// (unfold) and walked (stepCard). A carousel of fewer than three cards does
+// not, so that each side has the card its move selects; nor does the one
+// of a stash-only workspace, which has nothing beside its pile to leave it
+// for. Past the ends of one that does not, a move goes on as from a lane
+// (cascade) or stops (a vertical overview).
+func (w *Workspace) wrapsCards() bool {
+	_, k := w.stackHead()
+	return k > 0 && len(w.Stash) >= 3
+}
 // overviewLane is the vertical move of an overview whose workspaces sit side
 // by side (cascade). From the unfolded stash, up leaves it for the last lane
 // (leavePile) and down stays: the stash is the bottom. Else the selection
 // overviewAcross is the horizontal move of an overview whose workspaces sit
 // side by side (cascade): a column inside the selected lane, or a card of
-// the unfolded stash, which wraps round (carousel). Past the first column
+// the unfolded stash, which wraps round (stepCard). Past the first column
-// it goes to the previous workspace; past the last, to the next workspace.
+// or a card that does not wrap, it goes to the previous workspace; past
-// A carousel of fewer than three cards does not wrap, nor does the one of a
+// the last, to the next workspace.
-// stash-only workspace, which has nothing above its pile: there the ends
-// change workspace like a lane's.
 // Covering floats fan
 // 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 at := m.cardAt(w); at >= 0 {
-		n, next := len(w.Stash), at+dx
+		if !m.stepCard(w, at, dx) {
-		if next >= 0 && next < n {
-			m.selectCard(w, next)
-			return
-		}
-		if _, k := w.stackHead(); k == 0 || n < 3 {
-			// Nothing above the pile to leave it for, or too few
-			// cards to wrap round: the ends are the way out.
 			m.overviewStep(dx)
-			return
 		}
-		m.selectCard(w, (next+n)%n)
 		return
 	}
 	if m.stackFront(w).kind != stackColumns || len(w.Columns) == 0 {
 	return dst
 }
-// unfold lays the stash of w out from the folded pile's card rect. A
+// unfold lays the stash of w out from the folded pile's card rect as a
-// vertical overview lines every card up in a column (strip). A horizontal
+// carousel along axis: a row in a horizontal overview, a column in a
-// one spreads them as a carousel (carousel). Cards other than the selected
+// vertical one. The selected card at sits on the pile, in the middle; the
-// one at are dimmed; those out of the overview area are hidden. The cards
+// cards before it come on the left (above), the ones after it on the right
-// are appended to dst.
+// (below), in stash order, wrapping round (wrapsCards) with the oldest
+// following the newest (carouselSlot). A wider gap marks that seam. When the carousel fits the
+// overview area it is shifted into it; else the cards past the area are
+// hidden. Cards other than at are dimmed. The cards are appended to dst.
 func (w *Workspace) unfold(dst []Placement, axis layoutAxis, folded Rect, at int) []Placement {
-	if axis == horizontalAxis {
-		return w.carousel(dst, folded, at)
-	}
-	return w.strip(dst, folded, at)
-}
-// strip lays the stash out as a column of every card, in stash order,
-// centred on the pile and kept in the overview area. Longer than the area,
-// it scrolls like a wide row: the selected card at is centred, the strip
-// stopping at the area's edges.
-func (w *Workspace) strip(dst []Placement, folded Rect, at int) []Placement {
 	n := len(w.Stash)
 	u := w.overviewArea()
-	size, lo, hi := folded.H, u.Y, u.Y+u.H
+	size, origin, lo, room := folded.W, folded.X, u.X, u.W
-	stride := size + 2*w.cardStep()
+	if axis == verticalAxis {
-	total := n*stride - (stride - size)
+		size, origin, lo, room = folded.H, folded.Y, u.Y, u.H
-	start := folded.Y + size/2 - total/2
-	if total > hi-lo {
-		start = folded.Y - at*stride
-		start = min(max(start, hi-total), lo)
-	} else {
-		start = min(max(start, lo), hi-total)
-	}
-	for i := range w.Stash {
-		r := folded
-		r.Y = start + i*stride
-		dst = w.unfoldedCard(dst, i, r, at, u)
 	}
-	return dst
+	stride := size + 2*w.cardStep()
-}
-// carousel lays the stash out as a row centred on the selected card at,
-// under the pile, in stash order wrapping round: the cards before it on
-// the left, the ones after it on the right, the oldest following the
-// newest (carouselSlot). A wider gap marks that seam. When the row fits
-// the overview area it is shifted into it; else the cards past the area
-// are hidden.
-func (w *Workspace) carousel(dst []Placement, folded Rect, at int) []Placement {
-	n := len(w.Stash)
-	u := w.overviewArea()
-	stride := folded.W + 2*w.cardStep()
 	// The extra room at the seam, on top of the stride.
-	gap := folded.W / 4
+	gap := size / 4
-	x := func(i int) int {
+	wraps := w.wrapsCards()
-		s := carouselSlot(i, at, n)
+	pos := func(i int) int {
-		x := folded.X + s*stride
+		s := carouselSlot(i, at, n, wraps)
+		p := origin + s*stride
 		switch {
 		case s > 0 && at+s >= n:
-			x += gap
+			p += gap
 		case s < 0 && at+s < 0:
-			x -= gap
+			p -= gap
 		}
-		return x
+		return p
+	}
+	first, last := pos(0), pos(n-1)
+	if wraps {
+		first, last = pos((at+n-n/2)%n), pos((at+(n-1)/2)%n)
 	}
-	first, last := x((at+n-n/2)%n), x((at+(n-1)/2)%n)
 	shift := 0
-	if total := last + folded.W - first; total <= u.W {
+	if total := last + size - first; total <= room {
-		shift = min(max(first, u.X), u.X+u.W-total) - first
+		shift = min(max(first, lo), lo+room-total) - first
 	}
 	for i := range w.Stash {
 		r := folded
-		r.X = x(i) + shift
+		if axis == verticalAxis {
+			r.Y = pos(i) + shift
+		} else {
+			r.X = pos(i) + shift
+		}
 		dst = w.unfoldedCard(dst, i, r, at, u)
 	}
 	return dst
 }
 // carouselSlot is the place of stash card i in a carousel of n cards
-// centred on card at: 0 for at, negative on the left, positive on the
+// centred on card at: 0 for at, negative on the left (above), positive on
-// right. The left side takes the extra card of an even count. Fewer than
+// the right (below). Wrapping round, the left side takes the extra card of
-// three cards keep the stash order without wrapping round, so that each
+// an even count; else the cards keep the stash order.
-// side has the card its move selects.
+func carouselSlot(i, at, n int, wraps bool) int {
-func carouselSlot(i, at, n int) int {
+	if !wraps {
-	if n < 3 {
 		return i - at
 	}
 	s := (i - at + n) % n

M internal/core/overview_stash_input_test.go +24 -4


@@ -43,9 +43,9 @@ func TestOverviewStashInputNavigation(t *testing.T) {
43	43		var a Action
44	44		switch {
45	45		case dx == 0 && dy < 0:
46		-	a = ActionFocusWorkspacePrev
	46	+	a = ActionFocusWindowUp
47	47		case dx == 0 && dy > 0:
48		-	a = ActionFocusWorkspaceNext
	48	+	a = ActionFocusWindowDown
49	49		case dx > 0 && dy == 0:
50	50		a = ActionFocusColumnRight
51	51		case dx < 0 && dy == 0:

@@ -62,8 +62,8 @@ func TestOverviewStashInputNavigation(t *testing.T) {
62	62		}
63	63		move(0, 1)
64	64		move(0, 1)
65		-	if m.Current() != w \|\| m.cardAt(w) != 2 \|\| !slices.Equal(stashIDs(w), before) {
66		-	t.Fatal("down escaped or reordered the stash")
	65	+	if m.Current() != w \|\| m.cardAt(w) != 0 \|\| !slices.Equal(stashIDs(w), before) {
	66	+	t.Fatalf("down past the last card: card %d, want it to wrap round to 0 in order", m.cardAt(w))
67	67		}
68	68		move(1, 0)
69	69		if m.cardAt(w) >= 0 {

@@ -72,3 +72,23 @@ func TestOverviewStashInputNavigation(t *testing.T) {
72	72		})
73	73		}
74	74		}
	75	+
	76	+	// In a vertical overview, a focus-workspace bind over the unfolded stash
	77	+	// changes workspace: the carousel wraps round, so walking it would never
	78	+	// get there.
	79	+	func TestOverviewWorkspaceBindLeavesCarousel(t *testing.T) {
	80	+	m := pileMonitor()
	81	+	w := m.Current()
	82	+	m.Focus(1)
	83	+	m.AddWindow(30)
	84	+	m.Focus(0)
	85	+	m.ToggleOverview()
	86	+	m.OverviewMove(-1, 0)
	87	+	if m.overviewAxis() != verticalAxis \|\| m.cardAt(w) < 0 {
	88	+	t.Fatal("setup: no card selected in a vertical overview")
	89	+	}
	90	+	m.overviewFocus(ActionFocusWorkspaceNext)
	91	+	if m.Current() == w {
	92	+	t.Fatal("focus-workspace-next over a card stayed on the workspace")
	93	+	}
	94	+	}

 					var a Action
 					switch {
 					case dx == 0 && dy < 0:
-						a = ActionFocusWorkspacePrev
+						a = ActionFocusWindowUp
 					case dx == 0 && dy > 0:
-						a = ActionFocusWorkspaceNext
+						a = ActionFocusWindowDown
 					case dx > 0 && dy == 0:
 						a = ActionFocusColumnRight
 					case dx < 0 && dy == 0:
 			}
 			move(0, 1)
 			move(0, 1)
-			if m.Current() != w || m.cardAt(w) != 2 || !slices.Equal(stashIDs(w), before) {
+			if m.Current() != w || m.cardAt(w) != 0 || !slices.Equal(stashIDs(w), before) {
-				t.Fatal("down escaped or reordered the stash")
+				t.Fatalf("down past the last card: card %d, want it to wrap round to 0 in order", m.cardAt(w))
 			}
 			move(1, 0)
 			if m.cardAt(w) >= 0 {
 		})
 	}
 }
+// In a vertical overview, a focus-workspace bind over the unfolded stash
+// changes workspace: the carousel wraps round, so walking it would never
+// get there.
+func TestOverviewWorkspaceBindLeavesCarousel(t *testing.T) {
+	m := pileMonitor()
+	w := m.Current()
+	m.Focus(1)
+	m.AddWindow(30)
+	m.Focus(0)
+	m.ToggleOverview()
+	m.OverviewMove(-1, 0)
+	if m.overviewAxis() != verticalAxis || m.cardAt(w) < 0 {
+		t.Fatal("setup: no card selected in a vertical overview")
+	}
+	m.overviewFocus(ActionFocusWorkspaceNext)
+	if m.Current() == w {
+		t.Fatal("focus-workspace-next over a card stayed on the workspace")
+	}
+}

M internal/core/overview_test.go +8 -10


@@ -355,7 +355,7 @@ func TestOverviewPileKeepsRowCentred(t *testing.T) {
355	355		}
356	356		}
357	357
358		-	// Left enters the stash pile, up/down browse it without changing rows,
	358	+	// Left enters the stash pile, up/down browse it round without changing rows,
359	359		// and right leaves it immediately. Confirm shows the chosen stash window.
360	360		func TestOverviewPileNavigation(t *testing.T) {
361	361		m := pileMonitor()

@@ -375,17 +375,15 @@ func TestOverviewPileNavigation(t *testing.T) {
375	375		if at := m.cardAt(w); at != 2 {
376	376		t.Fatalf("left changed stash selection to %d", at)
377	377		}
378		-	m.OverviewMove(0, 1) // stops at the last entry, not the next workspace
379		-	if m.Current() != w \|\| m.cardAt(w) != 2 {
380		-	t.Fatal("down escaped the stash pile")
	378	+	m.OverviewMove(0, 1) // wraps round to the first entry, not the next workspace
	379	+	if m.Current() != w \|\| m.cardAt(w) != 0 {
	380	+	t.Fatalf("down past the last entry: card %d, workspace changed %v", m.cardAt(w), m.Current() != w)
381	381		}
382		-	m.OverviewMove(0, -1)
383		-	m.OverviewMove(0, -1)
384		-	m.OverviewMove(0, -1) // stops at the first entry
385		-	if at := m.cardAt(w); at != 0 \|\| m.Current() != w {
386		-	t.Fatalf("up end %d, workspace changed %v", at, m.Current() != w)
	382	+	m.OverviewMove(0, -1) // and back round to the last
	383	+	if at := m.cardAt(w); at != 2 \|\| m.Current() != w {
	384	+	t.Fatalf("up past the first entry: card %d, workspace changed %v", at, m.Current() != w)
387	385		}
388		-	m.OverviewMove(0, 1)
	386	+	m.OverviewMove(0, -1)
389	387		m.ToggleOverview()
390	388		if f, _ := m.Focused(); f != 6 \|\| w.stashHidden \|\| m.ov.open {
391	389		t.Fatalf("confirm on %d, hidden %v", f, w.stashHidden)

 	}
 }
-// Left enters the stash pile, up/down browse it without changing rows,
+// Left enters the stash pile, up/down browse it round without changing rows,
 // and right leaves it immediately. Confirm shows the chosen stash window.
 func TestOverviewPileNavigation(t *testing.T) {
 	m := pileMonitor()
 	if at := m.cardAt(w); at != 2 {
 		t.Fatalf("left changed stash selection to %d", at)
 	}
-	m.OverviewMove(0, 1) // stops at the last entry, not the next workspace
+	m.OverviewMove(0, 1) // wraps round to the first entry, not the next workspace
-	if m.Current() != w || m.cardAt(w) != 2 {
+	if m.Current() != w || m.cardAt(w) != 0 {
-		t.Fatal("down escaped the stash pile")
+		t.Fatalf("down past the last entry: card %d, workspace changed %v", m.cardAt(w), m.Current() != w)
 	}
-	m.OverviewMove(0, -1)
+	m.OverviewMove(0, -1) // and back round to the last
-	m.OverviewMove(0, -1)
+	if at := m.cardAt(w); at != 2 || m.Current() != w {
-	m.OverviewMove(0, -1) // stops at the first entry
+		t.Fatalf("up past the first entry: card %d, workspace changed %v", at, m.Current() != w)
-	if at := m.cardAt(w); at != 0 || m.Current() != w {
-		t.Fatalf("up end %d, workspace changed %v", at, m.Current() != w)
 	}
-	m.OverviewMove(0, 1)
+	m.OverviewMove(0, -1)
 	m.ToggleOverview()
 	if f, _ := m.Focused(); f != 6 || w.stashHidden || m.ov.open {
 		t.Fatalf("confirm on %d, hidden %v", f, w.stashHidden)

M internal/core/overview_unfold_test.go +126 -91


@@ -144,86 +144,58 @@ func TestOverviewCascadeStashFolds(t *testing.T) {
144	144		}
145	145		}
146	146
147		-	// A vertical overview's stash longer than the area scrolls like a wide
148		-	// row: every card is reached in order, the selection stays inside the area
149		-	// and is centred unless the strip stops at an edge of it, and cards past
150		-	// the area are hidden.
151		-	func TestOverviewStashUnfoldScrolls(t *testing.T) {
152		-	m := cascadeOverview()
153		-	w := m.Current()
154		-	w.Overflow = OverflowScroll
155		-	withStash(m, 12)
156		-	m.ToggleOverview()
157		-	if m.overviewAxis() != verticalAxis {
158		-	t.Fatal("setup: wrong overview axis")
159		-	}
160		-	m.selectCard(w, 0)
161		-	u := w.overviewArea()
162		-	lo, hi := u.Y, u.Y+u.H
163		-	centred, hidden := false, false
164		-	for i := range len(w.Stash) {
165		-	if m.cardAt(w) != i {
166		-	t.Fatalf("step %d: card %d", i, m.cardAt(w))
167		-	}
168		-	ps := m.Layout()
169		-	sel := previewOf(t, ps, w.Stash[i].ID)
170		-	at, size := sel.Rect.Y, sel.Rect.H
171		-	if sel.Hidden \|\| !sel.Focused \|\| at < lo \|\| at+size > hi {
172		-	t.Fatalf("card %d off the area: %+v in %v", i, sel, u)
173		-	}
174		-	first := previewOf(t, ps, w.Stash[0].ID).Rect.Y
175		-	last := previewOf(t, ps, w.Stash[len(w.Stash)-1].ID).Rect.Y
176		-	if first > lo \|\| last+size < hi {
177		-	t.Fatalf("card %d: strip %d..%d does not fill the area %d..%d", i, first, last+size, lo, hi)
178		-	}
179		-	if mid := at + size/2; abs(mid-(lo+hi)/2) <= 1 {
180		-	centred = true
181		-	} else if first != lo && last+size != hi {
182		-	t.Fatalf("card %d at %d, neither centred on %d nor clamped", i, mid, (lo+hi)/2)
183		-	}
184		-	for _, e := range w.Stash {
185		-	hidden = hidden \|\| previewOf(t, ps, e.ID).Hidden
186		-	}
187		-	m.OverviewMove(0, 1)
188		-	}
189		-	if !hidden \|\| !centred {
190		-	t.Fatalf("12 cards: hidden %v, centred %v; the test does not scroll", hidden, centred)
191		-	}
192		-	}
193		-
194		-	// A carousel wider than the area keeps every selection centred in it, with
195		-	// cards on both sides; the cards past the area are hidden.
196		-	func TestOverviewCascadeCarouselScrolls(t *testing.T) {
197		-	m := cascadeOverview()
198		-	w := m.Current()
199		-	withStash(m, 12)
200		-	m.ToggleOverview()
201		-	if m.overviewAxis() != horizontalAxis {
202		-	t.Fatal("setup: wrong overview axis")
203		-	}
204		-	m.selectCard(w, 11)
205		-	u := w.overviewArea()
206		-	for step := range len(w.Stash) + 1 {
207		-	i := m.cardAt(w)
208		-	ps := m.Layout()
209		-	sel := previewOf(t, ps, w.Stash[i].ID)
210		-	if sel.Hidden \|\| !sel.Focused \|\| abs(sel.Rect.X+sel.Rect.W/2-(u.X+u.W/2)) > 1 {
211		-	t.Fatalf("step %d: card %d not centred: %+v in %v", step, i, sel, u)
212		-	}
213		-	left, right, hidden := false, false, false
214		-	for _, e := range w.Stash {
215		-	p := previewOf(t, ps, e.ID)
216		-	if p.Hidden {
217		-	hidden = true
218		-	continue
	147	+	// A carousel longer than the area keeps every selection centred in it,
	148	+	// with cards on both sides, on either axis; the cards past the area are
	149	+	// hidden.
	150	+	func TestOverviewCarouselScrolls(t *testing.T) {
	151	+	for _, axis := range []layoutAxis{horizontalAxis, verticalAxis} {
	152	+	t.Run(map[layoutAxis]string{horizontalAxis: "cascade", verticalAxis: "scroll"}[axis], func(t *testing.T) {
	153	+	m := cascadeOverview()
	154	+	w := m.Current()
	155	+	if axis == verticalAxis {
	156	+	w.Overflow = OverflowScroll
219	157		}
220		-	left = left \|\| p.Rect.X < sel.Rect.X
221		-	right = right \|\| p.Rect.X > sel.Rect.X
222		-	}
223		-	if !left \|\| !right \|\| !hidden {
224		-	t.Fatalf("step %d: cards left %v, right %v, hidden %v", step, left, right, hidden)
225		-	}
226		-	m.OverviewMove(1, 0)
	158	+	withStash(m, 12)
	159	+	m.ToggleOverview()
	160	+	if m.overviewAxis() != axis {
	161	+	t.Fatal("setup: wrong overview axis")
	162	+	}
	163	+	m.selectCard(w, 11)
	164	+	u := w.overviewArea()
	165	+	pos := func(r Rect) (int, int) {
	166	+	if axis == verticalAxis {
	167	+	return r.Y, r.Y + r.H/2 - (u.Y + u.H/2)
	168	+	}
	169	+	return r.X, r.X + r.W/2 - (u.X + u.W/2)
	170	+	}
	171	+	for step := range len(w.Stash) + 1 {
	172	+	i := m.cardAt(w)
	173	+	ps := m.Layout()
	174	+	sel := previewOf(t, ps, w.Stash[i].ID)
	175	+	at, off := pos(sel.Rect)
	176	+	if sel.Hidden \|\| !sel.Focused \|\| abs(off) > 1 {
	177	+	t.Fatalf("step %d: card %d not centred: %+v in %v", step, i, sel, u)
	178	+	}
	179	+	before, after, hidden := false, false, false
	180	+	for _, e := range w.Stash {
	181	+	p := previewOf(t, ps, e.ID)
	182	+	if p.Hidden {
	183	+	hidden = true
	184	+	continue
	185	+	}
	186	+	q, _ := pos(p.Rect)
	187	+	before, after = before \|\| q < at, after \|\| q > at
	188	+	}
	189	+	if !before \|\| !after \|\| !hidden {
	190	+	t.Fatalf("step %d: cards before %v, after %v, hidden %v", step, before, after, hidden)
	191	+	}
	192	+	if axis == verticalAxis {
	193	+	m.OverviewMove(0, 1)
	194	+	} else {
	195	+	m.OverviewMove(1, 0)
	196	+	}
	197	+	}
	198	+	})
227	199		}
228	200		}
229	201

@@ -251,8 +223,10 @@ func TestOverviewStashLayoutAllocations(t *testing.T) {
251	223		}
252	224		}
253	225
254		-	// A scroll overview unfolds its pile into a column on the left of the row;
255		-	// up and down walk it, right goes back to the columns.
	226	+	// A scroll overview unfolds its pile into a carousel on the left of the
	227	+	// row: a column centred on the selection, the card before it above and the
	228	+	// one after it below, wrapping round. Up and down walk it round, right goes
	229	+	// back to the columns.
256	230		func TestOverviewScrollStashUnfolds(t *testing.T) {
257	231		m := overviewMonitor()
258	232		w := m.Current()

@@ -267,29 +241,90 @@ func TestOverviewScrollStashUnfolds(t *testing.T) {
267	241		t.Fatal("setup: not a vertical overview")
268	242		}
269	243		m.OverviewMove(-1, 0)
270		-	if m.cardAt(w) < 0 {
	244	+	at := m.cardAt(w)
	245	+	if at < 0 {
271	246		t.Fatal("left from the first column did not select the stash")
272	247		}
273	248		cards := shownCards(t, w, m.Layout())
274	249		if len(cards) != 3 {
275	250		t.Fatalf("%d cards shown, want 3", len(cards))
276	251		}
277		-	for i := 1; i < len(cards); i++ {
278		-	if cards[i].Rect.X != cards[0].Rect.X \|\| cards[i].Rect.Y < cards[i-1].Rect.Y+cards[i-1].Rect.H {
279		-	t.Fatalf("cards not stacked down: %v then %v", cards[i-1].Rect, cards[i].Rect)
	252	+	col := []Placement{cards[(at+2)%3], cards[at], cards[(at+1)%3]}
	253	+	for i := 1; i < len(col); i++ {
	254	+	if col[i].Rect.X != col[0].Rect.X \|\| col[i].Rect.Y < col[i-1].Rect.Y+col[i-1].Rect.H {
	255	+	t.Fatalf("cards not stacked down: %v then %v", col[i-1].Rect, col[i].Rect)
280	256		}
281	257		}
282		-	m.OverviewMove(0, -1)
283		-	m.OverviewMove(0, -1)
284		-	if m.cardAt(w) != 0 {
285		-	t.Fatalf("up: card %d, want 0", m.cardAt(w))
	258	+	if !col[1].Focused {
	259	+	t.Fatal("the selection is not in the middle")
286	260		}
287	261		m.OverviewMove(0, 1)
288		-	if m.cardAt(w) != 1 {
289		-	t.Fatalf("down: card %d, want 1", m.cardAt(w))
	262	+	if want := (at + 1) % 3; m.cardAt(w) != want {
	263	+	t.Fatalf("down: card %d, want %d", m.cardAt(w), want)
	264	+	}
	265	+	m.OverviewMove(0, -1)
	266	+	m.OverviewMove(0, -1)
	267	+	if want := (at + 2) % 3; m.cardAt(w) != want {
	268	+	t.Fatalf("up twice: card %d, want %d", m.cardAt(w), want)
290	269		}
291	270		m.OverviewMove(1, 0)
292	271		if m.cardAt(w) >= 0 \|\| m.overviewTarget() == 0 {
293	272		t.Fatalf("right: card %d, target %d", m.cardAt(w), m.overviewTarget())
294	273		}
295	274		}
	275	+
	276	+	// A stash-only workspace's carousel does not wrap round, drawn or walked:
	277	+	// the selection stays in the middle, the cards in stash order on either
	278	+	// side of it. Past the ends a vertical overview stops; a cascade one
	279	+	// changes workspace.
	280	+	func TestOverviewStashOnlyCarousel(t *testing.T) {
	281	+	for _, axis := range []layoutAxis{horizontalAxis, verticalAxis} {
	282	+	t.Run(map[layoutAxis]string{horizontalAxis: "cascade", verticalAxis: "scroll"}[axis], func(t *testing.T) {
	283	+	m := overviewMonitor()
	284	+	m.Focus(2)
	285	+	m.AddWindow(30)
	286	+	m.Focus(1)
	287	+	w := m.Current()
	288	+	w.Overflow = OverflowCascade
	289	+	if axis == verticalAxis {
	290	+	w.Overflow = OverflowScroll
	291	+	}
	292	+	w.ToggleWindowStash() // its own window
	293	+	for id := WindowID(40); id < 44; id++ {
	294	+	w.AddWindow(id)
	295	+	w.FocusID(id)
	296	+	w.ToggleWindowStash()
	297	+	}
	298	+	m.ToggleOverview()
	299	+	if m.overviewAxis() != axis \|\| len(w.Columns) != 0 \|\| m.cardAt(w) < 0 {
	300	+	t.Fatalf("setup: axis %d, %d columns, card %d", m.overviewAxis(), len(w.Columns), m.cardAt(w))
	301	+	}
	302	+	last := len(w.Stash) - 1
	303	+	m.selectCard(w, last)
	304	+	ps := m.Layout()
	305	+	pos := func(i int) int {
	306	+	if r := previewOf(t, ps, w.Stash[i].ID).Rect; axis == verticalAxis {
	307	+	return r.Y
	308	+	} else {
	309	+	return r.X
	310	+	}
	311	+	}
	312	+	for i := 1; i <= last; i++ {
	313	+	if pos(i) <= pos(i-1) {
	314	+	t.Fatalf("card %d at %d, not after card %d at %d", i, pos(i), i-1, pos(i-1))
	315	+	}
	316	+	}
	317	+	if axis == verticalAxis {
	318	+	m.OverviewMove(0, 1)
	319	+	if m.Current() != w \|\| m.cardAt(w) != last {
	320	+	t.Fatalf("down past the last card: card %d", m.cardAt(w))
	321	+	}
	322	+	return
	323	+	}
	324	+	m.OverviewMove(1, 0)
	325	+	if m.Current() == w {
	326	+	t.Fatal("right past the last card stayed on the workspace")
	327	+	}
	328	+	})
	329	+	}
	330	+	}

 	}
 }
-// A vertical overview's stash longer than the area scrolls like a wide
+// A carousel longer than the area keeps every selection centred in it,
-// row: every card is reached in order, the selection stays inside the area
+// with cards on both sides, on either axis; the cards past the area are
-// and is centred unless the strip stops at an edge of it, and cards past
+// hidden.
-// the area are hidden.
+func TestOverviewCarouselScrolls(t *testing.T) {
-func TestOverviewStashUnfoldScrolls(t *testing.T) {
+	for _, axis := range []layoutAxis{horizontalAxis, verticalAxis} {
-	m := cascadeOverview()
+		t.Run(map[layoutAxis]string{horizontalAxis: "cascade", verticalAxis: "scroll"}[axis], func(t *testing.T) {
-	w := m.Current()
+			m := cascadeOverview()
-	w.Overflow = OverflowScroll
+			w := m.Current()
-	withStash(m, 12)
+			if axis == verticalAxis {
-	m.ToggleOverview()
+				w.Overflow = OverflowScroll
-	if m.overviewAxis() != verticalAxis {
-		t.Fatal("setup: wrong overview axis")
-	}
-	m.selectCard(w, 0)
-	u := w.overviewArea()
-	lo, hi := u.Y, u.Y+u.H
-	centred, hidden := false, false
-	for i := range len(w.Stash) {
-		if m.cardAt(w) != i {
-			t.Fatalf("step %d: card %d", i, m.cardAt(w))
-		}
-		ps := m.Layout()
-		sel := previewOf(t, ps, w.Stash[i].ID)
-		at, size := sel.Rect.Y, sel.Rect.H
-		if sel.Hidden || !sel.Focused || at < lo || at+size > hi {
-			t.Fatalf("card %d off the area: %+v in %v", i, sel, u)
-		}
-		first := previewOf(t, ps, w.Stash[0].ID).Rect.Y
-		last := previewOf(t, ps, w.Stash[len(w.Stash)-1].ID).Rect.Y
-		if first > lo || last+size < hi {
-			t.Fatalf("card %d: strip %d..%d does not fill the area %d..%d", i, first, last+size, lo, hi)
-		}
-		if mid := at + size/2; abs(mid-(lo+hi)/2) <= 1 {
-			centred = true
-		} else if first != lo && last+size != hi {
-			t.Fatalf("card %d at %d, neither centred on %d nor clamped", i, mid, (lo+hi)/2)
-		}
-		for _, e := range w.Stash {
-			hidden = hidden || previewOf(t, ps, e.ID).Hidden
-		}
-		m.OverviewMove(0, 1)
-	}
-	if !hidden || !centred {
-		t.Fatalf("12 cards: hidden %v, centred %v; the test does not scroll", hidden, centred)
-	}
-}
-// A carousel wider than the area keeps every selection centred in it, with
-// cards on both sides; the cards past the area are hidden.
-func TestOverviewCascadeCarouselScrolls(t *testing.T) {
-	m := cascadeOverview()
-	w := m.Current()
-	withStash(m, 12)
-	m.ToggleOverview()
-	if m.overviewAxis() != horizontalAxis {
-		t.Fatal("setup: wrong overview axis")
-	}
-	m.selectCard(w, 11)
-	u := w.overviewArea()
-	for step := range len(w.Stash) + 1 {
-		i := m.cardAt(w)
-		ps := m.Layout()
-		sel := previewOf(t, ps, w.Stash[i].ID)
-		if sel.Hidden || !sel.Focused || abs(sel.Rect.X+sel.Rect.W/2-(u.X+u.W/2)) > 1 {
-			t.Fatalf("step %d: card %d not centred: %+v in %v", step, i, sel, u)
-		}
-		left, right, hidden := false, false, false
-		for _, e := range w.Stash {
-			p := previewOf(t, ps, e.ID)
-			if p.Hidden {
-				hidden = true
-				continue
 			}
-			left = left || p.Rect.X < sel.Rect.X
+			withStash(m, 12)
-			right = right || p.Rect.X > sel.Rect.X
+			m.ToggleOverview()
-		}
+			if m.overviewAxis() != axis {
-		if !left || !right || !hidden {
+				t.Fatal("setup: wrong overview axis")
-			t.Fatalf("step %d: cards left %v, right %v, hidden %v", step, left, right, hidden)
+			}
-		}
+			m.selectCard(w, 11)
-		m.OverviewMove(1, 0)
+			u := w.overviewArea()
+			pos := func(r Rect) (int, int) {
+				if axis == verticalAxis {
+					return r.Y, r.Y + r.H/2 - (u.Y + u.H/2)
+				}
+				return r.X, r.X + r.W/2 - (u.X + u.W/2)
+			}
+			for step := range len(w.Stash) + 1 {
+				i := m.cardAt(w)
+				ps := m.Layout()
+				sel := previewOf(t, ps, w.Stash[i].ID)
+				at, off := pos(sel.Rect)
+				if sel.Hidden || !sel.Focused || abs(off) > 1 {
+					t.Fatalf("step %d: card %d not centred: %+v in %v", step, i, sel, u)
+				}
+				before, after, hidden := false, false, false
+				for _, e := range w.Stash {
+					p := previewOf(t, ps, e.ID)
+					if p.Hidden {
+						hidden = true
+						continue
+					}
+					q, _ := pos(p.Rect)
+					before, after = before || q < at, after || q > at
+				}
+				if !before || !after || !hidden {
+					t.Fatalf("step %d: cards before %v, after %v, hidden %v", step, before, after, hidden)
+				}
+				if axis == verticalAxis {
+					m.OverviewMove(0, 1)
+				} else {
+					m.OverviewMove(1, 0)
+				}
+			}
+		})
 	}
 }
 	}
 }
-// A scroll overview unfolds its pile into a column on the left of the row;
+// A scroll overview unfolds its pile into a carousel on the left of the
-// up and down walk it, right goes back to the columns.
+// row: a column centred on the selection, the card before it above and the
+// one after it below, wrapping round. Up and down walk it round, right goes
+// back to the columns.
 func TestOverviewScrollStashUnfolds(t *testing.T) {
 	m := overviewMonitor()
 	w := m.Current()
 		t.Fatal("setup: not a vertical overview")
 	}
 	m.OverviewMove(-1, 0)
-	if m.cardAt(w) < 0 {
+	at := m.cardAt(w)
+	if at < 0 {
 		t.Fatal("left from the first column did not select the stash")
 	}
 	cards := shownCards(t, w, m.Layout())
 	if len(cards) != 3 {
 		t.Fatalf("%d cards shown, want 3", len(cards))
 	}
-	for i := 1; i < len(cards); i++ {
+	col := []Placement{cards[(at+2)%3], cards[at], cards[(at+1)%3]}
-		if cards[i].Rect.X != cards[0].Rect.X || cards[i].Rect.Y < cards[i-1].Rect.Y+cards[i-1].Rect.H {
+	for i := 1; i < len(col); i++ {
-			t.Fatalf("cards not stacked down: %v then %v", cards[i-1].Rect, cards[i].Rect)
+		if col[i].Rect.X != col[0].Rect.X || col[i].Rect.Y < col[i-1].Rect.Y+col[i-1].Rect.H {
+			t.Fatalf("cards not stacked down: %v then %v", col[i-1].Rect, col[i].Rect)
 		}
 	}
-	m.OverviewMove(0, -1)
+	if !col[1].Focused {
-	m.OverviewMove(0, -1)
+		t.Fatal("the selection is not in the middle")
-	if m.cardAt(w) != 0 {
-		t.Fatalf("up: card %d, want 0", m.cardAt(w))
 	}
 	m.OverviewMove(0, 1)
-	if m.cardAt(w) != 1 {
+	if want := (at + 1) % 3; m.cardAt(w) != want {
-		t.Fatalf("down: card %d, want 1", m.cardAt(w))
+		t.Fatalf("down: card %d, want %d", m.cardAt(w), want)
+	}
+	m.OverviewMove(0, -1)
+	m.OverviewMove(0, -1)
+	if want := (at + 2) % 3; m.cardAt(w) != want {
+		t.Fatalf("up twice: card %d, want %d", m.cardAt(w), want)
 	}
 	m.OverviewMove(1, 0)
 	if m.cardAt(w) >= 0 || m.overviewTarget() == 0 {
 		t.Fatalf("right: card %d, target %d", m.cardAt(w), m.overviewTarget())
 	}
 }
+// A stash-only workspace's carousel does not wrap round, drawn or walked:
+// the selection stays in the middle, the cards in stash order on either
+// side of it. Past the ends a vertical overview stops; a cascade one
+// changes workspace.
+func TestOverviewStashOnlyCarousel(t *testing.T) {
+	for _, axis := range []layoutAxis{horizontalAxis, verticalAxis} {
+		t.Run(map[layoutAxis]string{horizontalAxis: "cascade", verticalAxis: "scroll"}[axis], func(t *testing.T) {
+			m := overviewMonitor()
+			m.Focus(2)
+			m.AddWindow(30)
+			m.Focus(1)
+			w := m.Current()
+			w.Overflow = OverflowCascade
+			if axis == verticalAxis {
+				w.Overflow = OverflowScroll
+			}
+			w.ToggleWindowStash() // its own window
+			for id := WindowID(40); id < 44; id++ {
+				w.AddWindow(id)
+				w.FocusID(id)
+				w.ToggleWindowStash()
+			}
+			m.ToggleOverview()
+			if m.overviewAxis() != axis || len(w.Columns) != 0 || m.cardAt(w) < 0 {
+				t.Fatalf("setup: axis %d, %d columns, card %d", m.overviewAxis(), len(w.Columns), m.cardAt(w))
+			}
+			last := len(w.Stash) - 1
+			m.selectCard(w, last)
+			ps := m.Layout()
+			pos := func(i int) int {
+				if r := previewOf(t, ps, w.Stash[i].ID).Rect; axis == verticalAxis {
+					return r.Y
+				} else {
+					return r.X
+				}
+			}
+			for i := 1; i <= last; i++ {
+				if pos(i) <= pos(i-1) {
+					t.Fatalf("card %d at %d, not after card %d at %d", i, pos(i), i-1, pos(i-1))
+				}
+			}
+			if axis == verticalAxis {
+				m.OverviewMove(0, 1)
+				if m.Current() != w || m.cardAt(w) != last {
+					t.Fatalf("down past the last card: card %d", m.cardAt(w))
+				}
+				return
+			}
+			m.OverviewMove(1, 0)
+			if m.Current() == w {
+				t.Fatal("right past the last card stayed on the workspace")
+			}
+		})
+	}
+}

M internal/core/transition.go +7 -7


@@ -45,8 +45,8 @@ type viewShot struct {
45	45		stashShown bool
46	46		stashAt, stashLen int
47	47		stashPos, stashV float64
48		-	// card is the selected card of an unfolded stash carousel in the
49		-	// preview (Workspace.carousel), -1 without one.
	48	+	// card is the selected card of the unfolded stash carousel in the
	49	+	// overview (Workspace.unfold), -1 without one.
50	50		card int
51	51		// list and pos are the numbered workspaces and the monitor's fractional
52	52		// position in them (index of the current one plus switchView.off); ok is

@@ -640,7 +640,7 @@ func (c *Core) snapshot(now time.Time) []viewShot {
640	640		_, s.switchV = m.switchView.motion.sampleAt(now)
641	641		}
642	642		s.stashShown, s.stashAt, s.stashLen, s.stashPos = w.stashShown(), w.stashAt, len(w.Stash), float64(w.stashAt)+w.stashView.off
643		-	s.card = m.carouselCard(w)
	643	+	s.card = m.cardAt(w)
644	644		if w.stashView.motion.on {
645	645		_, s.stashV = w.stashView.motion.sampleAt(now)
646	646		}

@@ -918,7 +918,7 @@ func (c Core) transitionOverview(b viewShot, now time.Time) {
918	918		}
919	919		rm := sc.rects[p.ID]
920	920		i := slices.IndexFunc(b.rects, func(r rectShot) bool { return r.id == p.ID })
921		-	if i >= 0 && at >= 0 && wrapped(w.stashIndex(p.ID), b.card, at, len(w.Stash)) {
	921	+	if i >= 0 && at >= 0 && wrapped(w.stashIndex(p.ID), b.card, at, len(w.Stash), w.wrapsCards()) {
922	922		// The card went round the carousel to its other end: it
923	923		// fades in there instead of crossing the row.
924	924		rm, i = rectMotion{}, -1

@@ -957,14 +957,14 @@ func carouselStep(b *viewShot) int {
957	957		if b.card < 0 \|\| w != b.ws \|\| len(w.Stash) != b.stashLen {
958	958		return -1
959	959		}
960		-	return m.carouselCard(w)
	960	+	return m.cardAt(w)
961	961		}
962	962
963	963		// wrapped reports whether stash card i of a carousel of n cards went round
964	964		// it, from one end to the other: it moved more than one place
965	965		// (carouselSlot) when the selection went from card from to card to.
966		-	func wrapped(i, from, to, n int) bool {
967		-	return i >= 0 && abs(carouselSlot(i, to, n)-carouselSlot(i, from, n)) > 1
	966	+	func wrapped(i, from, to, n int, wraps bool) bool {
	967	+	return i >= 0 && abs(carouselSlot(i, to, n, wraps)-carouselSlot(i, from, n, wraps)) > 1
968	968		}
969	969
970	970		// movedFrom is the shot of the other screen that showed the workspace b's


@@ -45,8 +45,8 @@ type viewShot struct {
45		stashShown bool	45		stashShown bool
46		stashAt, stashLen int	46		stashAt, stashLen int
47		stashPos, stashV float64	47		stashPos, stashV float64
48	-	// card is the selected card of an unfolded stash carousel in the	48	+	// card is the selected card of the unfolded stash carousel in the
49	-	// preview (Workspace.carousel), -1 without one.	49	+	// overview (Workspace.unfold), -1 without one.
50		card int	50		card int
51		// list and pos are the numbered workspaces and the monitor's fractional	51		// list and pos are the numbered workspaces and the monitor's fractional
52		// position in them (index of the current one plus switchView.off); ok is	52		// position in them (index of the current one plus switchView.off); ok is

@@ -640,7 +640,7 @@ func (c *Core) snapshot(now time.Time) []viewShot {
640		_, s.switchV = m.switchView.motion.sampleAt(now)	640		_, s.switchV = m.switchView.motion.sampleAt(now)
641		}	641		}
642		s.stashShown, s.stashAt, s.stashLen, s.stashPos = w.stashShown(), w.stashAt, len(w.Stash), float64(w.stashAt)+w.stashView.off	642		s.stashShown, s.stashAt, s.stashLen, s.stashPos = w.stashShown(), w.stashAt, len(w.Stash), float64(w.stashAt)+w.stashView.off
643	-	s.card = m.carouselCard(w)	643	+	s.card = m.cardAt(w)
644		if w.stashView.motion.on {	644		if w.stashView.motion.on {
645		_, s.stashV = w.stashView.motion.sampleAt(now)	645		_, s.stashV = w.stashView.motion.sampleAt(now)
646		}	646		}

@@ -918,7 +918,7 @@ func (c Core) transitionOverview(b viewShot, now time.Time) {
918		}	918		}
919		rm := sc.rects[p.ID]	919		rm := sc.rects[p.ID]
920		i := slices.IndexFunc(b.rects, func(r rectShot) bool { return r.id == p.ID })	920		i := slices.IndexFunc(b.rects, func(r rectShot) bool { return r.id == p.ID })
921	-	if i >= 0 && at >= 0 && wrapped(w.stashIndex(p.ID), b.card, at, len(w.Stash)) {	921	+	if i >= 0 && at >= 0 && wrapped(w.stashIndex(p.ID), b.card, at, len(w.Stash), w.wrapsCards()) {
922		// The card went round the carousel to its other end: it	922		// The card went round the carousel to its other end: it
923		// fades in there instead of crossing the row.	923		// fades in there instead of crossing the row.
924		rm, i = rectMotion{}, -1	924		rm, i = rectMotion{}, -1

@@ -957,14 +957,14 @@ func carouselStep(b *viewShot) int {
957		if b.card < 0 \|\| w != b.ws \|\| len(w.Stash) != b.stashLen {	957		if b.card < 0 \|\| w != b.ws \|\| len(w.Stash) != b.stashLen {
958		return -1	958		return -1
959		}	959		}
960	-	return m.carouselCard(w)	960	+	return m.cardAt(w)
961		}	961		}
962			962
963		// wrapped reports whether stash card i of a carousel of n cards went round	963		// wrapped reports whether stash card i of a carousel of n cards went round
964		// it, from one end to the other: it moved more than one place	964		// it, from one end to the other: it moved more than one place
965		// (carouselSlot) when the selection went from card from to card to.	965		// (carouselSlot) when the selection went from card from to card to.
966	-	func wrapped(i, from, to, n int) bool {	966	+	func wrapped(i, from, to, n int, wraps bool) bool {
967	-	return i >= 0 && abs(carouselSlot(i, to, n)-carouselSlot(i, from, n)) > 1	967	+	return i >= 0 && abs(carouselSlot(i, to, n, wraps)-carouselSlot(i, from, n, wraps)) > 1
968		}	968		}
969			969
970		// movedFrom is the shot of the other screen that showed the workspace b's	970		// movedFrom is the shot of the other screen that showed the workspace b's