nook: focus a split pane by clicking it

Dispatch left-button presses to routeMouse, the mouse twin of the alt+w focus
chords: a click inside a pane focuses it and carries the active buffer along.
It acts only on a left press while a split is live with no overlay floating;
wheel, drag, and clicks outside the editor region fall through. The screen-to-
region mapping is the inverse of View(): treeWidth() is extracted from
editorRegion so the tree's column count has a single definition, and
editorOrigin() adds the divider column and tab-bar row. A click on the divider
gap or the focused pane is a no-op. Tests cover per-pane selection, a tree
click ignored, single-pane inert, and a wheel event ignored.

Split panes is now navigable from both keyboard and mouse.

Author: truffle-dev

cmd/nook/main.go

@@ -1200,6 +1200,9 @@ func (m model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 	case tea.KeyMsg:
 		return m.routeKey(msg)
 
+	case tea.MouseMsg:
+		return m.routeMouse(msg)
+
 	case filesLoadedMsg:
 		m.files = msg.files
 		items := make([]picker.Item, len(msg.files))
@@ -4057,6 +4060,33 @@ func (m model) closePane() (tea.Model, tea.Cmd) {
 	return m, nil
 }
 
+// routeMouse focuses the pane under a left click. It is the mouse twin of the
+// alt+w h/j/k/l/w chords: a click is the most direct way to say "work here".
+// Only a left-button press is acted on, and only when a split is live and no
+// overlay is floating; everything else (wheel, drag, clicks in the tree or tab
+// bar or on the divider gap) falls through untouched so existing behaviour and
+// future mouse uses stay open.
+func (m model) routeMouse(msg tea.MouseMsg) (tea.Model, tea.Cmd) {
+	if msg.Button != tea.MouseButtonLeft || msg.Action != tea.MouseActionPress {
+		return m, nil
+	}
+	if m.overlay != overlayNone || m.split == nil || m.split.Count() < 2 {
+		return m, nil
+	}
+	ox, oy := m.editorOrigin()
+	rx, ry := msg.X-ox, msg.Y-oy
+	w, h := m.editorRegion()
+	if rx < 0 || ry < 0 || rx >= w || ry >= h {
+		return m, nil // click landed in the tree, tab bar, or right pane
+	}
+	pid, ok := m.split.PaneAt(rx, ry, w, h)
+	if !ok || pid == m.split.Focused() {
+		return m, nil // the divider gap, or the already-focused pane
+	}
+	m.split.Focus(pid)
+	return m.syncFocusedPane(true)
+}
+
 // focusDir moves split focus to the nearest pane in direction d (alt+w h/j/k/l)
 // and re-syncs the editor onto it. With no live split the chord is a no-op.
 func (m model) focusDir(d splitlayout.Direction) (tea.Model, tea.Cmd) {
@@ -4875,17 +4905,41 @@ func (m model) shouldShowWelcome() bool {
 // single pane it IS the pane. Must mirror resize() exactly: tree on the left
 // when visible, right pane on the right when active, and a minimum-20 editor
 // floor that shrinks the tree when necessary.
-func (m model) editorRegion() (int, int) {
-	treeW := 0
-	if m.showTree {
-		treeW = m.width / 5
-		if treeW < 22 {
-			treeW = 22
-		}
-		if treeW > 40 {
-			treeW = 40
-		}
+// treeWidth is the column count the file tree occupies, or 0 when it is
+// hidden. editorRegion and editorOrigin both go through here so the editor's
+// width and its on-screen left edge can never disagree about where the tree
+// ends.
+func (m model) treeWidth() int {
+	if !m.showTree {
+		return 0
+	}
+	treeW := m.width / 5
+	if treeW < 22 {
+		treeW = 22
 	}
+	if treeW > 40 {
+		treeW = 40
+	}
+	return treeW
+}
+
+// editorOrigin is the screen coordinate of the editor region's top-left cell:
+// past the tree and its divider on the left, and below the tab bar on top.
+// It is the inverse of the View() composition, used to turn a mouse click into
+// a point inside the editor region.
+func (m model) editorOrigin() (x, y int) {
+	x = m.treeWidth()
+	if x > 0 {
+		x++ // the one-cell divider drawn between the tree and the editor
+	}
+	if m.bufs.Count() > 0 {
+		y = 1 // the tab bar sits above the body whenever a buffer is open
+	}
+	return x, y
+}
+
+func (m model) editorRegion() (int, int) {
+	treeW := m.treeWidth()
 	leftW := m.width - treeW
 	if treeW > 0 {
 		leftW--

cmd/nook/main_splitpane_test.go

@@ -467,3 +467,104 @@ func TestWindowLeaderResizeNoSplitIsNoOp(t *testing.T) {
 		t.Errorf("resize chord created a split: count = %d", m.split.Count())
 	}
 }
+
+// clickAt presses the left mouse button at screen coordinate (x, y).
+func clickAt(m model, x, y int) model {
+	u, _ := m.Update(tea.MouseMsg{X: x, Y: y, Button: tea.MouseButtonLeft, Action: tea.MouseActionPress})
+	return u.(model)
+}
+
+// paneCenter returns a screen point inside pane pid's rectangle, mapping the
+// region-local rect back through the editor origin the way View() lays it out.
+func paneCenter(m model, pid splitlayout.PaneID) (int, int) {
+	w, h := m.editorRegion()
+	r := m.split.Rects(w, h)[pid]
+	ox, oy := m.editorOrigin()
+	return ox + r.X + r.W/2, oy + r.Y + r.H/2
+}
+
+// TestMouseClickFocusesPaneUnderCursor is the headline of slice 3c: clicking
+// inside a pane makes it the focused pane and drags the active buffer with it,
+// the mouse twin of alt+w w. A columns split puts two panes side by side; a
+// click in each must select that pane.
+func TestMouseClickFocusesPaneUnderCursor(t *testing.T) {
+	m := openTwo(t)
+	m = altW(m)
+	m = runeKey(m, 'v') // columns split; focus lands on the new (right) pane
+	ids := m.split.Panes()
+	if len(ids) != 2 {
+		t.Fatalf("want 2 panes, got %d", len(ids))
+	}
+	left, right := ids[0], ids[1]
+
+	// Click the left pane: focus moves there and the active buffer follows.
+	lx, ly := paneCenter(m, left)
+	m = clickAt(m, lx, ly)
+	if m.split.Focused() != left {
+		t.Fatalf("click in left pane focused %v, want %v", m.split.Focused(), left)
+	}
+	if m.bufs.ActiveIndex() != m.paneBuf[left] {
+		t.Errorf("focus==active broken after click: active=%d, pane binds %d",
+			m.bufs.ActiveIndex(), m.paneBuf[left])
+	}
+
+	// Click the right pane: focus moves back.
+	rx, ry := paneCenter(m, right)
+	m = clickAt(m, rx, ry)
+	if m.split.Focused() != right {
+		t.Errorf("click in right pane focused %v, want %v", m.split.Focused(), right)
+	}
+}
+
+// TestMouseClickInTreeIgnored guards the origin math: a click to the left of
+// the editor region (in the file tree) must not change split focus.
+func TestMouseClickInTreeIgnored(t *testing.T) {
+	m := openTwo(t)
+	m.showTree = true
+	m = m.resize()
+	m = altW(m)
+	m = runeKey(m, 'v')
+	before := m.split.Focused()
+
+	// x=0 is inside the tree column, left of the editor origin.
+	m = clickAt(m, 0, 5)
+	if m.split.Focused() != before {
+		t.Error("a click in the file tree moved split focus")
+	}
+}
+
+// TestMouseClickNoSplitIsNoOp confirms a click is inert with one pane: nothing
+// to refocus, no panic, no split created.
+func TestMouseClickNoSplitIsNoOp(t *testing.T) {
+	m := openTwo(t) // two buffers, no split
+	before := m.bufs.ActiveIndex()
+	m = clickAt(m, 40, 10)
+	if m.split.Count() != 1 {
+		t.Errorf("a click created a split: count = %d", m.split.Count())
+	}
+	if m.bufs.ActiveIndex() != before {
+		t.Errorf("a click with no split changed the active buffer: %d -> %d",
+			before, m.bufs.ActiveIndex())
+	}
+}
+
+// TestMouseWheelIgnored guards that non-left-press events (here a wheel-up)
+// never reroute focus: only a deliberate left click selects a pane.
+func TestMouseWheelIgnored(t *testing.T) {
+	m := openTwo(t)
+	m = altW(m)
+	m = runeKey(m, 'v')
+	before := m.split.Focused()
+	ids := m.split.Panes()
+	other := ids[0]
+	if other == before {
+		other = ids[1]
+	}
+	// Aim the wheel event at the non-focused pane; it must still be ignored.
+	x, y := paneCenter(m, other)
+	u, _ := m.Update(tea.MouseMsg{X: x, Y: y, Button: tea.MouseButtonWheelUp, Action: tea.MouseActionPress})
+	m = u.(model)
+	if m.split.Focused() != before {
+		t.Error("a mouse wheel event moved split focus")
+	}
+}

docs/nook/design/01-split-panes-host-wiring.md

@@ -194,13 +194,30 @@ pane to zero width (clamp proof); the chord is a no-op with one pane.
 The mouse split was deferred to keep this slice complete and green. Keyboard
 resize is the interactive capstone; mouse needs its own screen-coordinate map.
 
-#### Slice 3c — mouse focus — NEXT
-
-- Mouse is already enabled (`tea.WithMouseCellMotion()` at `main.go`).
-- Click → map screen coords (tree-width left offset, header rows) to an editor
-  region point → `split.PaneAt` → `Focus` → `syncFocusedPane`.
-- Tests: a click in each pane's rectangle selects that pane; a click in the
-  tree or header is ignored.
+#### Slice 3c — mouse focus — LANDED
+
+Done. A left-button press is dispatched to `routeMouse`, the mouse twin of the
+alt+w focus chords. It acts only on `MouseButtonLeft` + `MouseActionPress`,
+only when a split is live and no overlay floats; wheel, drag, and clicks
+outside the editor region fall through untouched so future mouse uses stay
+open. The screen→region mapping is the inverse of `View()`'s composition,
+factored into two helpers so it can never drift from the layout:
+
+- `treeWidth()` — extracted from `editorRegion` so the tree's column count has
+  one definition that both width and origin read.
+- `editorOrigin()` — the editor region's top-left screen cell: `treeWidth()`
+  plus one divider column on the left, plus one tab-bar row on top when a
+  buffer is open.
+
+`routeMouse` subtracts the origin from the click, bounds-checks against the
+region, then `split.PaneAt` → `Focus` → `syncFocusedPane` (keeping
+focus==active). A click on the divider gap or the already-focused pane is a
+no-op. Tests (`main_splitpane_test.go`): a click in each pane selects it and
+drags the active buffer; a click in the file tree is ignored; a click with no
+split is inert; a wheel event never reroutes focus.
+
+**Split panes is now complete from both keyboard and mouse.** Remaining work
+is Slice 4 reconciliation polish, a separate concern.
 
 ### Slice 4 — reconciliation polish