fix(layer): on-demand focus ends on any output's window focus change or a bind

commit: ee631b3356d645e0624b54aa8ccd78fdf082eeb7
author: brice · 26d ago · 2026-09-26 06:04 UTC
committer: brice · 26d ago · 2026-09-26 06:05 UTC
parent: 16be8cb
signature: GPG VerifiedCD88F9E564E0102646FB6077A1A07C7C7C3E349D · arch-gpg Verified for the committer email

2 files · +29 -14

M internal/core/core.go +19 -14


@@ -5,6 +5,7 @@ import (
5	5		"errors"
6	6		"fmt"
7	7		"github.com/bnema/nefertty/internal/ports"
	8	+	"maps"
8	9		"slices"
9	10		"strconv"
10	11		"strings"

@@ -82,14 +83,12 @@ type Core struct {
82	83		popups map[WindowID]*popupState
83	84		popupOrder []WindowID
84	85		// layerFocus is the on-demand layer surface the user clicked; it keeps
85		-	// the keyboard while it stays mapped on-demand and the window focus
86		-	// (layerOver) does not change: any click elsewhere, bind, activation or
87		-	// new window takes the keyboard back.
	86	+	// the keyboard while it stays mapped on-demand and no window focus
	87	+	// changes on any output (layerOver, taken at the click): any click
	88	+	// elsewhere, bind, activation or new window takes the keyboard back. The
	89	+	// pointer moving to another output does not.
88	90		layerFocus WindowID
89		-	layerOver WindowID
90		-	// layerScreen is the output focused at the click: the pointer moving to
91		-	// another output does not end the layer's focus.
92		-	layerScreen *screen
	91	+	layerOver map[*screen]WindowID
93	92		}
94	93
95	94		func keyName(s string) string {

@@ -309,6 +308,15 @@ func (c *Core) visible(id WindowID) bool {
309	308		// interactivity and the highest ID on any output, else the focused window of
310	309		// the focused output. An on-demand layer takes focus only when clicked, until
311	310		// a window is clicked. When the layer unmaps, focus returns to the window.
	311	+	// windowFocus is the focused window of each output.
	312	+	func (c Core) windowFocus() map[screen]WindowID {
	313	+	m := make(map[*screen]WindowID, len(c.screens))
	314	+	for _, sc := range c.screens {
	315	+	m[sc], _ = sc.mon.Focused()
	316	+	}
	317	+	return m
	318	+	}
	319	+
312	320		func (c *Core) keyboardFocus() WindowID {
313	321		var layer WindowID
314	322		for _, sc := range c.screens {

@@ -325,11 +333,8 @@ func (c *Core) keyboardFocus() WindowID {
325	333		if g := c.grabFocus(); g != 0 {
326	334		return g
327	335		}
328		-	if c.layerFocus != 0 {
329		-	over, _ := c.layerScreen.mon.Focused()
330		-	if !c.onDemand(c.layerFocus) \|\| !slices.Contains(c.screens, c.layerScreen) \|\| over != c.layerOver {
331		-	c.layerFocus, c.layerScreen = 0, nil
332		-	}
	336	+	if c.layerFocus != 0 && (!c.onDemand(c.layerFocus) \|\| !maps.Equal(c.layerOver, c.windowFocus())) {
	337	+	c.layerFocus, c.layerOver = 0, nil
333	338		}
334	339		if c.layerFocus != 0 {
335	340		return c.layerFocus

@@ -753,8 +758,7 @@ func (c *Core) Run(ctx context.Context) error {
753	758		// A click on an on-demand layer gives it the keyboard.
754	759		if v.Pressed && c.onDemand(id) && c.layerFocus != id {
755	760		c.layerFocus = id
756		-	c.layerScreen = c.cur()
757		-	c.layerOver, _ = c.layerScreen.mon.Focused()
	761	+	c.layerOver = c.windowFocus()
758	762		if err := c.publish(ctx); err != nil {
759	763		return nil
760	764		}

@@ -832,6 +836,7 @@ func (c *Core) Run(ctx context.Context) error {
832	836		continue
833	837		}
834	838		before := c.cur().mon.Current()
	839	+	c.layerFocus = 0 // a bind acts on the windows
835	840		effect := c.applyAction(action)
836	841		if effect.Quit {
837	842		return ErrQuit

 	"errors"
 	"fmt"
 	"github.com/bnema/nefertty/internal/ports"
+	"maps"
 	"slices"
 	"strconv"
 	"strings"
 	popups     map[WindowID]*popupState
 	popupOrder []WindowID
 	// layerFocus is the on-demand layer surface the user clicked; it keeps
-	// the keyboard while it stays mapped on-demand and the window focus
+	// the keyboard while it stays mapped on-demand and no window focus
-	// (layerOver) does not change: any click elsewhere, bind, activation or
+	// changes on any output (layerOver, taken at the click): any click
-	// new window takes the keyboard back.
+	// elsewhere, bind, activation or new window takes the keyboard back. The
+	// pointer moving to another output does not.
 	layerFocus WindowID
-	layerOver  WindowID
+	layerOver  map[*screen]WindowID
-	// layerScreen is the output focused at the click: the pointer moving to
-	// another output does not end the layer's focus.
-	layerScreen *screen
 }
 func keyName(s string) string {
 // interactivity and the highest ID on any output, else the focused window of
 // the focused output. An on-demand layer takes focus only when clicked, until
 // a window is clicked. When the layer unmaps, focus returns to the window.
+// windowFocus is the focused window of each output.
+func (c *Core) windowFocus() map[*screen]WindowID {
+	m := make(map[*screen]WindowID, len(c.screens))
+	for _, sc := range c.screens {
+		m[sc], _ = sc.mon.Focused()
+	}
+	return m
+}
 func (c *Core) keyboardFocus() WindowID {
 	var layer WindowID
 	for _, sc := range c.screens {
 	if g := c.grabFocus(); g != 0 {
 		return g
 	}
-	if c.layerFocus != 0 {
+	if c.layerFocus != 0 && (!c.onDemand(c.layerFocus) || !maps.Equal(c.layerOver, c.windowFocus())) {
-		over, _ := c.layerScreen.mon.Focused()
+		c.layerFocus, c.layerOver = 0, nil
-		if !c.onDemand(c.layerFocus) || !slices.Contains(c.screens, c.layerScreen) || over != c.layerOver {
-			c.layerFocus, c.layerScreen = 0, nil
-		}
 	}
 	if c.layerFocus != 0 {
 		return c.layerFocus
 					// A click on an on-demand layer gives it the keyboard.
 					if v.Pressed && c.onDemand(id) && c.layerFocus != id {
 						c.layerFocus = id
-						c.layerScreen = c.cur()
+						c.layerOver = c.windowFocus()
-						c.layerOver, _ = c.layerScreen.mon.Focused()
 						if err := c.publish(ctx); err != nil {
 							return nil
 						}
 						continue
 					}
 					before := c.cur().mon.Current()
+					c.layerFocus = 0 // a bind acts on the windows
 					effect := c.applyAction(action)
 					if effect.Quit {
 						return ErrQuit

M internal/core/layer_input_test.go +10 -0


@@ -258,4 +258,14 @@ func TestLayerFocusAcrossOutputs(t *testing.T) {
258	258		if v := next(t, commands, anyOf[ports.ForwardKey]); v.ID != 6 {
259	259		t.Fatalf("key to %d, want the bar", v.ID)
260	260		}
	261	+	input <- ports.KeyEvent{Keysym: "a"}
	262	+	next(t, commands, anyOf[ports.ForwardKey])
	263	+
	264	+	// A window mapped on OUT-2 (focused there) takes the keyboard back.
	265	+	client <- ports.WindowMapped{ID: 2}
	266	+	next(t, commands, func(v ports.FocusWindow) bool { return v.ID == 2 })
	267	+	input <- ports.KeyEvent{Keysym: "b", Pressed: true}
	268	+	if v := next(t, commands, anyOf[ports.ForwardKey]); v.ID != 2 {
	269	+	t.Fatalf("key to %d, want the new window", v.ID)
	270	+	}
261	271		}


@@ -258,4 +258,14 @@ func TestLayerFocusAcrossOutputs(t *testing.T) {
258	if v := next(t, commands, anyOf[ports.ForwardKey]); v.ID != 6 {	258		if v := next(t, commands, anyOf[ports.ForwardKey]); v.ID != 6 {
259	t.Fatalf("key to %d, want the bar", v.ID)	259		t.Fatalf("key to %d, want the bar", v.ID)
260	}	260		}
		261	+	input <- ports.KeyEvent{Keysym: "a"}
		262	+	next(t, commands, anyOf[ports.ForwardKey])
		263	+
		264	+	// A window mapped on OUT-2 (focused there) takes the keyboard back.
		265	+	client <- ports.WindowMapped{ID: 2}
		266	+	next(t, commands, func(v ports.FocusWindow) bool { return v.ID == 2 })
		267	+	input <- ports.KeyEvent{Keysym: "b", Pressed: true}
		268	+	if v := next(t, commands, anyOf[ports.ForwardKey]); v.ID != 2 {
		269	+	t.Fatalf("key to %d, want the new window", v.ID)
		270	+	}
261	}	271		}