01e6d9a fix(core): focus the neighbor workspace before the neighbor screen at the column edge · neferwl

M internal/core/action.go +6 -6


@@ -389,19 +389,19 @@ func (c *Core) dispatchAction(a Action) Effect {
389	389		}
390	390
391	391		// edgeFocus moves focus-column-left/right (dir -1/1, toward d) past the
392		-	// content edge, in order: to the neighbor monitor on that side; else to the
393		-	// occupied workspace on that side when the workspace axis is horizontal;
	392	+	// content edge, in order: to the occupied workspace on that side when the
	393	+	// workspace axis is horizontal; else to the neighbor monitor on that side;
394	394		// else to the trailing empty workspace. It reports whether focus moved.
395	395		func (c *Core) edgeFocus(dir int, d direction) bool {
396	396		m := c.cur().mon
397		-	if i := c.neighbor(d); i >= 0 {
398		-	c.focusScreen = i
399		-	return true
400		-	}
401	397		if to := m.occupiedStep(horizontalAxis, dir); to >= 0 {
402	398		m.Focus(to)
403	399		return true
404	400		}
	401	+	if i := c.neighbor(d); i >= 0 {
	402	+	c.focusScreen = i
	403	+	return true
	404	+	}
405	405		return m.stepWorkspace(horizontalAxis, dir)
406	406		}
407	407

 }
 // edgeFocus moves focus-column-left/right (dir -1/1, toward d) past the
-// content edge, in order: to the neighbor monitor on that side; else to the
+// content edge, in order: to the occupied workspace on that side when the
-// occupied workspace on that side when the workspace axis is horizontal;
+// workspace axis is horizontal; else to the neighbor monitor on that side;
 // else to the trailing empty workspace. It reports whether focus moved.
 func (c *Core) edgeFocus(dir int, d direction) bool {
 	m := c.cur().mon
-	if i := c.neighbor(d); i >= 0 {
-		c.focusScreen = i
-		return true
-	}
 	if to := m.occupiedStep(horizontalAxis, dir); to >= 0 {
 		m.Focus(to)
 		return true
 	}
+	if i := c.neighbor(d); i >= 0 {
+		c.focusScreen = i
+		return true
+	}
 	return m.stepWorkspace(horizontalAxis, dir)
 }

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


@@ -43,9 +43,8 @@ func TestCascadeMoveColumnInsideBandSwaps(t *testing.T) {
43	43		wantColumns(t, w, 2, 1, 3, 4, 5)
44	44		}
45	45
46		-	// A neighbor monitor on the left screen's right side wins over an occupied
47		-	// workspace there: focus-column-right at the band edge goes to the screen.
48		-	func TestCascadeFocusColumnEdgePrefersMonitorOverWorkspace(t *testing.T) {
	46	+	// An occupied workspace wins over the neighbor monitor at the band edge.
	47	+	func TestCascadeFocusColumnEdgePrefersWorkspaceOverMonitor(t *testing.T) {
49	48		c := layoutCore(0, tile{"L", 0, 0, 900, 600}, tile{"R", 900, 0, 900, 600})
50	49		m := c.cur().mon
51	50		m.SetOverflow(OverflowCascade)

@@ -58,8 +57,8 @@ func TestCascadeFocusColumnEdgePrefersMonitorOverWorkspace(t *testing.T) {
58	57		m.normalize()
59	58		m.Current().FocusID(2)
60	59		c.applyAction(ActionFocusColumnRight)
61		-	wantFocus(t, c, "R", 0)
62		-	wantActive(t, m, 0)
	60	+	wantFocus(t, c, "L", 3)
	61	+	wantActive(t, m, 1)
63	62		}
64	63
65	64		// With no monitor on that side, the occupied neighbor workspace is next.

 	wantColumns(t, w, 2, 1, 3, 4, 5)
 }
-// A neighbor monitor on the left screen's right side wins over an occupied
+// An occupied workspace wins over the neighbor monitor at the band edge.
-// workspace there: focus-column-right at the band edge goes to the screen.
+func TestCascadeFocusColumnEdgePrefersWorkspaceOverMonitor(t *testing.T) {
-func TestCascadeFocusColumnEdgePrefersMonitorOverWorkspace(t *testing.T) {
 	c := layoutCore(0, tile{"L", 0, 0, 900, 600}, tile{"R", 900, 0, 900, 600})
 	m := c.cur().mon
 	m.SetOverflow(OverflowCascade)
 	m.normalize()
 	m.Current().FocusID(2)
 	c.applyAction(ActionFocusColumnRight)
-	wantFocus(t, c, "R", 0)
+	wantFocus(t, c, "L", 3)
-	wantActive(t, m, 0)
+	wantActive(t, m, 1)
 }
 // With no monitor on that side, the occupied neighbor workspace is next.

M internal/core/workspace_axis_test.go +54 -23


@@ -50,26 +50,22 @@ func TestCascadeFocusColumnStepsWorkspaceAtBandEdge(t *testing.T) {
50	50		}
51	51		}
52	52
53		-	// A monitor on that side wins over an occupied workspace, so the opposite
54		-	// key brings focus back; the workspace is reached only with no monitor.
55		-	func TestCascadeFocusColumnGoesToMonitorBeforeWorkspace(t *testing.T) {
	53	+	// Occupied workspaces win over monitors; monitors still precede trailing empties.
	54	+	func TestCascadeFocusColumnGoesToWorkspaceBeforeMonitor(t *testing.T) {
56	55		c, m := axisCore(t, true, OverflowCascade, 3)
57	56		m.Current().FocusID(23)
58	57		c.applyAction(ActionFocusColumnRight)
59		-	wantFocus(t, c, "R", 0)
60		-	wantActive(t, m, 1)
61		-	// Back with the opposite key.
62		-	c.applyAction(ActionFocusColumnLeft)
63		-	wantFocus(t, c, "M", 23)
64		-	wantActive(t, m, 1)
65		-	// The first column of a band: the monitor on the left.
	58	+	wantActive(t, m, 2)
	59	+	if c.cur().mon != m {
	60	+	t.Fatal("left monitor before workspace")
	61	+	}
	62	+	m.Focus(1)
66	63		m.Current().FocusID(24)
67	64		c.applyAction(ActionFocusColumnLeft)
68		-	wantFocus(t, c, "L", 0)
69		-	wantActive(t, m, 1)
70		-	// From the last occupied workspace: the monitor on the right, not the
71		-	// trailing empty workspace.
72		-	c.focusScreen = 1
	65	+	wantActive(t, m, 0)
	66	+	if c.cur().mon != m {
	67	+	t.Fatal("left monitor before workspace")
	68	+	}
73	69		m.Focus(2)
74	70		m.Current().FocusID(35)
75	71		c.applyAction(ActionFocusColumnRight)

@@ -93,8 +89,8 @@ func TestCascadeFocusColumnReachesTrailingWorkspaceWithoutMonitor(t *testing.T)
93	89		}
94	90
95	91		// One monitor on the left only. Right steps to the next workspace; left
96		-	// from its empty band leaves for that monitor, which comes first.
97		-	func TestCascadeStepRightThenLeftLeavesForMonitor(t *testing.T) {
	92	+	// from its empty band returns to the occupied workspace before that monitor.
	93	+	func TestCascadeStepRightThenLeftReturnsToWorkspace(t *testing.T) {
98	94		c := layoutCore(1, tile{"L", 0, 0, 900, 600}, tile{"M", 900, 0, 900, 600})
99	95		m := c.cur().mon
100	96		m.SetOverflow(OverflowCascade)

@@ -104,8 +100,8 @@ func TestCascadeStepRightThenLeftLeavesForMonitor(t *testing.T) {
104	100		c.applyAction(ActionFocusColumnRight)
105	101		wantActive(t, m, 1)
106	102		c.applyAction(ActionFocusColumnLeft)
107		-	wantFocus(t, c, "L", 0)
108		-	wantActive(t, m, 1)
	103	+	wantFocus(t, c, "M", 5)
	104	+	wantActive(t, m, 0)
109	105		}
110	106
111	107		// AC3: up/down cross bands and stop at the last, with no workspace change.

@@ -189,15 +185,17 @@ func TestCascadeFullscreenBandEdgeStepsWorkspace(t *testing.T) {
189	185		}
190	186
191	187		// A covering fullscreen tile follows the same order: the monitor on that
192		-	// side before the occupied workspace.
193		-	func TestCascadeFullscreenGoesToMonitorBeforeWorkspace(t *testing.T) {
	188	+	// side after the occupied workspace.
	189	+	func TestCascadeFullscreenGoesToWorkspaceBeforeMonitor(t *testing.T) {
194	190		c, m := axisCore(t, true, OverflowCascade, 3)
195	191		w := m.Current()
196	192		w.FocusID(23)
197	193		w.ToggleFullscreen()
198	194		c.applyAction(ActionFocusColumnRight)
199		-	wantFocus(t, c, "R", 0)
200		-	wantActive(t, m, 1)
	195	+	wantActive(t, m, 2)
	196	+	if c.cur().mon != m {
	197	+	t.Fatal("left monitor before workspace")
	198	+	}
201	199		if w.fullscreen != 23 {
202	200		t.Fatalf("fullscreen %d, want 23", w.fullscreen)
203	201		}

@@ -244,3 +242,36 @@ func TestCascadeLoneFloatAndEmptyWorkspaceStepWorkspace(t *testing.T) {
244	242		wantActive(t, m, tc.want)
245	243		}
246	244		}
	245	+
	246	+	// Column edges visit occupied workspaces before crossing outputs, in both directions.
	247	+	func TestColumnEdgeFocusWorkspaceBeforeScreen(t *testing.T) {
	248	+	for _, tc := range []struct {
	249	+	name string
	250	+	screen, start, next, neighbor int
	251	+	action Action
	252	+	}{
	253	+	{"left", 1, 1, 0, 0, ActionFocusColumnLeft},
	254	+	{"right", 0, 0, 1, 1, ActionFocusColumnRight},
	255	+	} {
	256	+	t.Run(tc.name, func(t *testing.T) {
	257	+	c := layoutCore(tc.screen, tile{"laptop", 0, 0, 1920, 1080}, tile{"4K", 1920, 0, 3840, 2160})
	258	+	m := c.cur().mon
	259	+	m.SetOverflow(OverflowCascade)
	260	+	for ws := range 2 {
	261	+	m.Focus(ws)
	262	+	m.AddWindow(WindowID(ws + 1))
	263	+	}
	264	+	m.Focus(tc.start)
	265	+	c.applyAction(tc.action)
	266	+	if c.focusScreen != tc.screen {
	267	+	t.Fatalf("screen %d, want %d before crossing workspace", c.focusScreen, tc.screen)
	268	+	}
	269	+	wantActive(t, m, tc.next)
	270	+	c.applyAction(tc.action)
	271	+	if c.focusScreen != tc.neighbor {
	272	+	t.Fatalf("screen %d, want neighbor %d", c.focusScreen, tc.neighbor)
	273	+	}
	274	+	wantActive(t, m, tc.next)
	275	+	})
	276	+	}
	277	+	}

 	}
 }
-// A monitor on that side wins over an occupied workspace, so the opposite
+// Occupied workspaces win over monitors; monitors still precede trailing empties.
-// key brings focus back; the workspace is reached only with no monitor.
+func TestCascadeFocusColumnGoesToWorkspaceBeforeMonitor(t *testing.T) {
-func TestCascadeFocusColumnGoesToMonitorBeforeWorkspace(t *testing.T) {
 	c, m := axisCore(t, true, OverflowCascade, 3)
 	m.Current().FocusID(23)
 	c.applyAction(ActionFocusColumnRight)
-	wantFocus(t, c, "R", 0)
+	wantActive(t, m, 2)
-	wantActive(t, m, 1)
+	if c.cur().mon != m {
-	// Back with the opposite key.
+		t.Fatal("left monitor before workspace")
-	c.applyAction(ActionFocusColumnLeft)
+	}
-	wantFocus(t, c, "M", 23)
+	m.Focus(1)
-	wantActive(t, m, 1)
-	// The first column of a band: the monitor on the left.
 	m.Current().FocusID(24)
 	c.applyAction(ActionFocusColumnLeft)
-	wantFocus(t, c, "L", 0)
+	wantActive(t, m, 0)
-	wantActive(t, m, 1)
+	if c.cur().mon != m {
-	// From the last occupied workspace: the monitor on the right, not the
+		t.Fatal("left monitor before workspace")
-	// trailing empty workspace.
+	}
-	c.focusScreen = 1
 	m.Focus(2)
 	m.Current().FocusID(35)
 	c.applyAction(ActionFocusColumnRight)
 }
 // One monitor on the left only. Right steps to the next workspace; left
-// from its empty band leaves for that monitor, which comes first.
+// from its empty band returns to the occupied workspace before that monitor.
-func TestCascadeStepRightThenLeftLeavesForMonitor(t *testing.T) {
+func TestCascadeStepRightThenLeftReturnsToWorkspace(t *testing.T) {
 	c := layoutCore(1, tile{"L", 0, 0, 900, 600}, tile{"M", 900, 0, 900, 600})
 	m := c.cur().mon
 	m.SetOverflow(OverflowCascade)
 	c.applyAction(ActionFocusColumnRight)
 	wantActive(t, m, 1)
 	c.applyAction(ActionFocusColumnLeft)
-	wantFocus(t, c, "L", 0)
+	wantFocus(t, c, "M", 5)
-	wantActive(t, m, 1)
+	wantActive(t, m, 0)
 }
 // AC3: up/down cross bands and stop at the last, with no workspace change.
 }
 // A covering fullscreen tile follows the same order: the monitor on that
-// side before the occupied workspace.
+// side after the occupied workspace.
-func TestCascadeFullscreenGoesToMonitorBeforeWorkspace(t *testing.T) {
+func TestCascadeFullscreenGoesToWorkspaceBeforeMonitor(t *testing.T) {
 	c, m := axisCore(t, true, OverflowCascade, 3)
 	w := m.Current()
 	w.FocusID(23)
 	w.ToggleFullscreen()
 	c.applyAction(ActionFocusColumnRight)
-	wantFocus(t, c, "R", 0)
+	wantActive(t, m, 2)
-	wantActive(t, m, 1)
+	if c.cur().mon != m {
+		t.Fatal("left monitor before workspace")
+	}
 	if w.fullscreen != 23 {
 		t.Fatalf("fullscreen %d, want 23", w.fullscreen)
 	}
 		wantActive(t, m, tc.want)
 	}
 }
+// Column edges visit occupied workspaces before crossing outputs, in both directions.
+func TestColumnEdgeFocusWorkspaceBeforeScreen(t *testing.T) {
+	for _, tc := range []struct {
+		name                          string
+		screen, start, next, neighbor int
+		action                        Action
+	}{
+		{"left", 1, 1, 0, 0, ActionFocusColumnLeft},
+		{"right", 0, 0, 1, 1, ActionFocusColumnRight},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			c := layoutCore(tc.screen, tile{"laptop", 0, 0, 1920, 1080}, tile{"4K", 1920, 0, 3840, 2160})
+			m := c.cur().mon
+			m.SetOverflow(OverflowCascade)
+			for ws := range 2 {
+				m.Focus(ws)
+				m.AddWindow(WindowID(ws + 1))
+			}
+			m.Focus(tc.start)
+			c.applyAction(tc.action)
+			if c.focusScreen != tc.screen {
+				t.Fatalf("screen %d, want %d before crossing workspace", c.focusScreen, tc.screen)
+			}
+			wantActive(t, m, tc.next)
+			c.applyAction(tc.action)
+			if c.focusScreen != tc.neighbor {
+				t.Fatalf("screen %d, want neighbor %d", c.focusScreen, tc.neighbor)
+			}
+			wantActive(t, m, tc.next)
+		})
+	}
+}