fix: hover focus no longer steals from newly created split panes

New pane creation sets a motion-based focus lock (newPaneFocusLock)
that blocks hover-follows-mouse until the user intentionally moves
the mouse. This replaces the time-based suppression that could
expire before GTK layout completes, allowing synthetic enter events
from widget rearrangement to steal focus from the new pane.

- HoverHandler: add ConnectMotion callback for real movement detection
- PaneView: add SetOnMouseMotion to wire motion → lock clear
- WorkspaceView: newPaneFocusLock (atomic.Bool) set on new pane,
  cleared on first real mouse motion

commit: d3d4981fa0f92924c5718d1cc05197276a0244e5
author: brice · 8mo ago · 2026-02-07 11:39 UTC
parent: 3eb245f
signature: GPG VerifiedCD88F9E564E0102646FB6077A1A07C7C7C3E349D · arch-gpg Verified for the committer email

4 files · +77 -7

M CHANGELOG.md +1 -0


@@ -23,6 +23,7 @@ All notable changes to this project will be documented in this file.
23	23
24	24		### Fixed
25	25
	26	+	- Hover focus stealing from new split panes: New pane creation now locks hover focus until the user intentionally moves the mouse, replacing the 300ms time-based suppression that could expire before GTK layout completes. Synthetic enter events from widget rearrangement no longer steal focus from freshly created panes.
26	27		- Stacked pane title desync on navigation: Titles in the stacked title bar now sync immediately on `LoadCommitted` and when switching panes, preventing stale titles after background navigation.
27	28		- Session marker file accumulation: `writeShutdownMarker` now removes the matching startup marker (embedding its timestamp for classification), and a new `sweepPairedMarkers` sweep in background cleanup removes old marker trios past the configured age.
28	29		- Retry delay exceeding max: `retryDelayForAttempt` now clamps the final delay (base + jitter) to `retryMaxDelay` so backoff never overshoots the hard cap.


@@ -23,6 +23,7 @@ All notable changes to this project will be documented in this file.
23		23
24	### Fixed	24		### Fixed
25		25
		26	+	- Hover focus stealing from new split panes: New pane creation now locks hover focus until the user intentionally moves the mouse, replacing the 300ms time-based suppression that could expire before GTK layout completes. Synthetic enter events from widget rearrangement no longer steal focus from freshly created panes.
26	- Stacked pane title desync on navigation: Titles in the stacked title bar now sync immediately on `LoadCommitted` and when switching panes, preventing stale titles after background navigation.	27		- Stacked pane title desync on navigation: Titles in the stacked title bar now sync immediately on `LoadCommitted` and when switching panes, preventing stale titles after background navigation.
27	- Session marker file accumulation: `writeShutdownMarker` now removes the matching startup marker (embedding its timestamp for classification), and a new `sweepPairedMarkers` sweep in background cleanup removes old marker trios past the configured age.	28		- Session marker file accumulation: `writeShutdownMarker` now removes the matching startup marker (embedding its timestamp for classification), and a new `sweepPairedMarkers` sweep in background cleanup removes old marker trios past the configured age.
28	- Retry delay exceeding max: `retryDelayForAttempt` now clamps the final delay (base + jitter) to `retryMaxDelay` so backoff never overshoots the hard cap.	29		- Retry delay exceeding max: `retryDelayForAttempt` now clamps the final delay (base + jitter) to `retryMaxDelay` so backoff never overshoots the hard cap.

M internal/ui/component/pane_view.go +25 -4


@@ -29,9 +29,10 @@ type PaneView struct {
29	29		paneID entity.PaneID
30	30		isActive bool
31	31
32		-	onFocusIn func(paneID entity.PaneID)
33		-	onFocusOut func(paneID entity.PaneID)
34		-	onHover func(paneID entity.PaneID)
	32	+	onFocusIn func(paneID entity.PaneID)
	33	+	onFocusOut func(paneID entity.PaneID)
	34	+	onHover func(paneID entity.PaneID)
	35	+	onMouseMotion func()
35	36
36	37		hoverHandler *input.HoverHandler
37	38

@@ -218,6 +219,15 @@ func (pv *PaneView) SetOnHover(fn func(paneID entity.PaneID)) {
218	219		pv.onHover = fn
219	220		}
220	221
	222	+	// SetOnMouseMotion sets a callback fired on intentional mouse movement within the pane.
	223	+	// Used to detect real user interaction vs synthetic GTK enter events from widget rearrangement.
	224	+	func (pv *PaneView) SetOnMouseMotion(fn func()) {
	225	+	pv.mu.Lock()
	226	+	defer pv.mu.Unlock()
	227	+
	228	+	pv.onMouseMotion = fn
	229	+	}
	230	+
221	231		// AttachHoverHandler creates and attaches a hover handler for focus-follows-mouse behavior.
222	232		func (pv *PaneView) AttachHoverHandler(ctx context.Context) {
223	233		pv.mu.Lock()

@@ -226,7 +236,7 @@ func (pv *PaneView) AttachHoverHandler(ctx context.Context) {
226	236		// Create hover handler
227	237		pv.hoverHandler = input.NewHoverHandler(ctx, pv.paneID)
228	238
229		-	// Wire up callback
	239	+	// Wire up hover enter callback
230	240		pv.hoverHandler.SetOnEnter(func(paneID entity.PaneID) {
231	241		pv.mu.RLock()
232	242		callback := pv.onHover

@@ -237,6 +247,17 @@ func (pv *PaneView) AttachHoverHandler(ctx context.Context) {
237	247		}
238	248		})
239	249
	250	+	// Wire up mouse motion callback (intentional movement detection)
	251	+	pv.hoverHandler.SetOnMotion(func() {
	252	+	pv.mu.RLock()
	253	+	callback := pv.onMouseMotion
	254	+	pv.mu.RUnlock()
	255	+
	256	+	if callback != nil {
	257	+	callback()
	258	+	}
	259	+	})
	260	+
240	261		// Attach to overlay widget
241	262		gtkWidget := pv.overlay.GtkWidget()
242	263		if gtkWidget != nil {

 	paneID        entity.PaneID
 	isActive      bool
-	onFocusIn  func(paneID entity.PaneID)
+	onFocusIn     func(paneID entity.PaneID)
-	onFocusOut func(paneID entity.PaneID)
+	onFocusOut    func(paneID entity.PaneID)
-	onHover    func(paneID entity.PaneID)
+	onHover       func(paneID entity.PaneID)
+	onMouseMotion func()
 	hoverHandler *input.HoverHandler
 	pv.onHover = fn
 }
+// SetOnMouseMotion sets a callback fired on intentional mouse movement within the pane.
+// Used to detect real user interaction vs synthetic GTK enter events from widget rearrangement.
+func (pv *PaneView) SetOnMouseMotion(fn func()) {
+	pv.mu.Lock()
+	defer pv.mu.Unlock()
+	pv.onMouseMotion = fn
+}
 // AttachHoverHandler creates and attaches a hover handler for focus-follows-mouse behavior.
 func (pv *PaneView) AttachHoverHandler(ctx context.Context) {
 	pv.mu.Lock()
 	// Create hover handler
 	pv.hoverHandler = input.NewHoverHandler(ctx, pv.paneID)
-	// Wire up callback
+	// Wire up hover enter callback
 	pv.hoverHandler.SetOnEnter(func(paneID entity.PaneID) {
 		pv.mu.RLock()
 		callback := pv.onHover
 		}
 	})
+	// Wire up mouse motion callback (intentional movement detection)
+	pv.hoverHandler.SetOnMotion(func() {
+		pv.mu.RLock()
+		callback := pv.onMouseMotion
+		pv.mu.RUnlock()
+		if callback != nil {
+			callback()
+		}
+	})
 	// Attach to overlay widget
 	gtkWidget := pv.overlay.GtkWidget()
 	if gtkWidget != nil {

M internal/ui/component/workspace_view.go +26 -1


@@ -6,6 +6,7 @@ import (
6	6		"errors"
7	7		"fmt"
8	8		"sync"
	9	+	"sync/atomic"
9	10		"time"
10	11
11	12		"github.com/bnema/dumber/internal/domain/entity"

@@ -56,6 +57,14 @@ type WorkspaceView struct {
56	57		// Prevents hover focus from overriding keyboard-initiated focus changes
57	58		hoverSuppressedUntil time.Time
58	59
	60	+	// newPaneFocusLock suppresses hover focus after a new pane is created.
	61	+	// Rule: new pane creation always wins focus. Hover focus is blocked
	62	+	// until the user intentionally moves the mouse (motion event), at which
	63	+	// point normal hover-follows-mouse behavior resumes. This prevents
	64	+	// GTK's synthetic enter events (fired on widget rearrangement) from
	65	+	// stealing focus away from a freshly created pane.
	66	+	newPaneFocusLock atomic.Bool
	67	+
59	68		// Auto-open omnibox on new pane creation
60	69		autoOpenOnNewPane bool
61	70

@@ -93,6 +102,13 @@ func (a paneViewFactoryAdapter) CreatePaneView(node entity.PaneNode) layout.Wi
93	102		}
94	103		})
95	104
	105	+	// Clear new-pane focus lock on intentional mouse motion.
	106	+	// This allows hover-follows-mouse to resume after the user moves the
	107	+	// mouse, while keeping focus on the new pane until that happens.
	108	+	pv.SetOnMouseMotion(func() {
	109	+	a.wv.newPaneFocusLock.Store(false)
	110	+	})
	111	+
96	112		// Set up hover callback for focus-follows-mouse
97	113		pv.SetOnHover(func(paneID entity.PaneID) {
98	114		// Skip if hover is suppressed (keyboard navigation just happened)

@@ -100,6 +116,12 @@ func (a paneViewFactoryAdapter) CreatePaneView(node entity.PaneNode) layout.Wi
100	116		return
101	117		}
102	118
	119	+	// Skip if new pane was just created — focus stays on new pane
	120	+	// until the user intentionally moves the mouse (see SetOnMouseMotion).
	121	+	if a.wv.newPaneFocusLock.Load() {
	122	+	return
	123	+	}
	124	+
103	125		// Skip if this pane is already active
104	126		if a.wv.GetActivePaneID() == paneID {
105	127		return

@@ -566,7 +588,10 @@ func (wv *WorkspaceView) SetAutoOpenOnNewPane(enabled bool) {
566	588		// NotifyNewPaneCreated handles new pane creation events.
567	589		// Suppresses hover focus to keep focus on the new pane, and optionally shows omnibox.
568	590		func (wv *WorkspaceView) NotifyNewPaneCreated(ctx context.Context) {
569		-	// Suppress hover focus so mouse position doesn't steal focus from new pane
	591	+	// Lock hover focus until the user intentionally moves the mouse.
	592	+	// New pane creation always wins focus; hover-follows-mouse resumes
	593	+	// only after real mouse motion (cleared by PaneView.SetOnMouseMotion).
	594	+	wv.newPaneFocusLock.Store(true)
570	595		wv.SuppressHover(KeyboardFocusSuppressDuration)
571	596		wv.CancelAllPendingHovers()
572	597

 	"errors"
 	"fmt"
 	"sync"
+	"sync/atomic"
 	"time"
 	"github.com/bnema/dumber/internal/domain/entity"
 	// Prevents hover focus from overriding keyboard-initiated focus changes
 	hoverSuppressedUntil time.Time
+	// newPaneFocusLock suppresses hover focus after a new pane is created.
+	// Rule: new pane creation always wins focus. Hover focus is blocked
+	// until the user intentionally moves the mouse (motion event), at which
+	// point normal hover-follows-mouse behavior resumes. This prevents
+	// GTK's synthetic enter events (fired on widget rearrangement) from
+	// stealing focus away from a freshly created pane.
+	newPaneFocusLock atomic.Bool
 	// Auto-open omnibox on new pane creation
 	autoOpenOnNewPane bool
 		}
 	})
+	// Clear new-pane focus lock on intentional mouse motion.
+	// This allows hover-follows-mouse to resume after the user moves the
+	// mouse, while keeping focus on the new pane until that happens.
+	pv.SetOnMouseMotion(func() {
+		a.wv.newPaneFocusLock.Store(false)
+	})
 	// Set up hover callback for focus-follows-mouse
 	pv.SetOnHover(func(paneID entity.PaneID) {
 		// Skip if hover is suppressed (keyboard navigation just happened)
 			return
 		}
+		// Skip if new pane was just created — focus stays on new pane
+		// until the user intentionally moves the mouse (see SetOnMouseMotion).
+		if a.wv.newPaneFocusLock.Load() {
+			return
+		}
 		// Skip if this pane is already active
 		if a.wv.GetActivePaneID() == paneID {
 			return
 // NotifyNewPaneCreated handles new pane creation events.
 // Suppresses hover focus to keep focus on the new pane, and optionally shows omnibox.
 func (wv *WorkspaceView) NotifyNewPaneCreated(ctx context.Context) {
-	// Suppress hover focus so mouse position doesn't steal focus from new pane
+	// Lock hover focus until the user intentionally moves the mouse.
+	// New pane creation always wins focus; hover-follows-mouse resumes
+	// only after real mouse motion (cleared by PaneView.SetOnMouseMotion).
+	wv.newPaneFocusLock.Store(true)
 	wv.SuppressHover(KeyboardFocusSuppressDuration)
 	wv.CancelAllPendingHovers()

M internal/ui/input/hover.go +25 -2


@@ -18,16 +18,21 @@ const (
18	18		// HoverCallback is called when a pane should receive focus from hover.
19	19		type HoverCallback func(paneID entity.PaneID)
20	20
	21	+	// MotionCallback is called when intentional mouse movement is detected.
	22	+	type MotionCallback func()
	23	+
21	24		// HoverHandler handles mouse hover events for focus-follows-mouse behavior.
22	25		// It uses a debounce timer to avoid rapid focus switches.
23	26		type HoverHandler struct {
24	27		motionCtrl *gtk.EventControllerMotion
25	28		paneID entity.PaneID
26	29		onEnter HoverCallback
	30	+	onMotion MotionCallback
27	31
28	32		// Callback retention: must stay reachable by Go GC.
29		-	enterCb func(gtk.EventControllerMotion, float64, float64)
30		-	leaveCb func(gtk.EventControllerMotion)
	33	+	enterCb func(gtk.EventControllerMotion, float64, float64)
	34	+	leaveCb func(gtk.EventControllerMotion)
	35	+	motionCb func(gtk.EventControllerMotion, float64, float64)
31	36
32	37		timer *time.Timer
33	38		timerMu sync.Mutex

@@ -52,6 +57,13 @@ func (h *HoverHandler) SetOnEnter(fn HoverCallback) {
52	57		h.onEnter = fn
53	58		}
54	59
	60	+	// SetOnMotion sets the callback for intentional mouse movement.
	61	+	// This fires on actual mouse motion within the pane, not on synthetic
	62	+	// enter/leave events from GTK widget rearrangement.
	63	+	func (h *HoverHandler) SetOnMotion(fn MotionCallback) {
	64	+	h.onMotion = fn
	65	+	}
	66	+
55	67		// AttachTo attaches the hover handler to a GTK widget.
56	68		func (h HoverHandler) AttachTo(widget gtk.Widget) {
57	69		log := logging.FromContext(h.ctx)

@@ -79,6 +91,16 @@ func (h HoverHandler) AttachTo(widget gtk.Widget) {
79	91		}
80	92		h.motionCtrl.ConnectLeave(&h.leaveCb)
81	93
	94	+	// Connect motion handler to detect intentional mouse movement.
	95	+	// Unlike enter/leave, motion only fires when the cursor physically moves
	96	+	// inside the widget — not on synthetic events from widget rearrangement.
	97	+	h.motionCb = func(_ gtk.EventControllerMotion, _ float64, _ float64) {
	98	+	if h.onMotion != nil {
	99	+	h.onMotion()
	100	+	}
	101	+	}
	102	+	h.motionCtrl.ConnectMotion(&h.motionCb)
	103	+
82	104		// Add controller to widget
83	105		widget.AddController(&h.motionCtrl.EventController)
84	106

@@ -143,4 +165,5 @@ func (h *HoverHandler) Detach() {
143	165		h.motionCtrl = nil
144	166		h.enterCb = nil
145	167		h.leaveCb = nil
	168	+	h.motionCb = nil
146	169		}

 // HoverCallback is called when a pane should receive focus from hover.
 type HoverCallback func(paneID entity.PaneID)
+// MotionCallback is called when intentional mouse movement is detected.
+type MotionCallback func()
 // HoverHandler handles mouse hover events for focus-follows-mouse behavior.
 // It uses a debounce timer to avoid rapid focus switches.
 type HoverHandler struct {
 	motionCtrl *gtk.EventControllerMotion
 	paneID     entity.PaneID
 	onEnter    HoverCallback
+	onMotion   MotionCallback
 	// Callback retention: must stay reachable by Go GC.
-	enterCb func(gtk.EventControllerMotion, float64, float64)
+	enterCb  func(gtk.EventControllerMotion, float64, float64)
-	leaveCb func(gtk.EventControllerMotion)
+	leaveCb  func(gtk.EventControllerMotion)
+	motionCb func(gtk.EventControllerMotion, float64, float64)
 	timer    *time.Timer
 	timerMu  sync.Mutex
 	h.onEnter = fn
 }
+// SetOnMotion sets the callback for intentional mouse movement.
+// This fires on actual mouse motion within the pane, not on synthetic
+// enter/leave events from GTK widget rearrangement.
+func (h *HoverHandler) SetOnMotion(fn MotionCallback) {
+	h.onMotion = fn
+}
 // AttachTo attaches the hover handler to a GTK widget.
 func (h *HoverHandler) AttachTo(widget *gtk.Widget) {
 	log := logging.FromContext(h.ctx)
 	}
 	h.motionCtrl.ConnectLeave(&h.leaveCb)
+	// Connect motion handler to detect intentional mouse movement.
+	// Unlike enter/leave, motion only fires when the cursor physically moves
+	// inside the widget — not on synthetic events from widget rearrangement.
+	h.motionCb = func(_ gtk.EventControllerMotion, _ float64, _ float64) {
+		if h.onMotion != nil {
+			h.onMotion()
+		}
+	}
+	h.motionCtrl.ConnectMotion(&h.motionCb)
 	// Add controller to widget
 	widget.AddController(&h.motionCtrl.EventController)
 	h.motionCtrl = nil
 	h.enterCb = nil
 	h.leaveCb = nil
+	h.motionCb = nil
 }