Carry the press-time keyboard modifiers through the whole mouse gesture

A click is reported on the button press, but the press never set the
event's modifier, so a modified click (alt/shift/ctrl+click) reached
handlers stripped of its modifier, indistinguishable from a plain
click. An earlier fix for this ("Carry the keyboard modifier on mouse
click events") was lost while rebasing onto master's mouse gesture
handling (#5854) — and that work also changes what the right shape is:
it isn't enough for the modifier to ride the press alone.

Drag events and the release are delivered to the view that owns the
gesture, and bindings match modifiers exactly. If the press carried alt
but the drags carried plain ModMotion, an alt-press that no binding
consumed would start matching unmodified drag bindings mid-gesture
(drag-select), and the release of a modified gesture would look like a
plain one. So snapshot the modifiers at press time and stamp them on
every event of the gesture: the press, each drag event (combined with
ModMotion), and the release; modifier changes while the button is held
don't alter the gesture. TestMouseReleaseDoesNotKeepPressModifiers
asserted the opposite for the release and is inverted accordingly.

As before, this means a modified click that nothing binds is a no-op
rather than silently acting as a plain click.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

pkg/gocui/tcell_driver.go

@@ -202,6 +202,7 @@ const (
 
 var (
 	lastMouseKey tcell.ButtonMask = tcell.ButtonNone
+	lastMouseMod tcell.ModMask    = tcell.ModNone
 	dragState                     = NOT_DRAGGING
 	lastX                         = 0
 	lastY                         = 0
@@ -370,6 +371,15 @@ func gocuiEventFromTcellEvent(tev tcell.Event) GocuiEvent {
 		if button != tcell.ButtonNone && lastMouseKey == tcell.ButtonNone {
 			newButtonPress = true
 			lastMouseKey = button
+			// The keyboard modifiers held at press time apply to the whole
+			// gesture: the press (a click is reported on the press, so this is
+			// what makes modified clicks bindable), every drag event, and the
+			// release. Snapshotting them here keeps the gesture atomic: a
+			// modified press can't produce drag/release events that match an
+			// unmodified binding, and pressing or releasing a modifier while
+			// the button is held doesn't change the gesture midway.
+			lastMouseMod = tev.Modifiers()
+			mouseMod = Modifier(lastMouseMod)
 			switch button {
 			case tcell.ButtonPrimary:
 				mouseKey = MouseLeft
@@ -395,7 +405,8 @@ func gocuiEventFromTcellEvent(tev tcell.Event) GocuiEvent {
 				case tcell.ButtonMiddle:
 				default:
 				}
-				mouseMod = ModNone
+				mouseMod = Modifier(lastMouseMod)
+				lastMouseMod = tcell.ModNone
 				lastMouseKey = tcell.ButtonNone
 			}
 		default:
@@ -426,10 +437,10 @@ func gocuiEventFromTcellEvent(tev tcell.Event) GocuiEvent {
 				// reaches drag bindings instead of being delivered with the
 				// default MouseRelease key.
 				dragState = DRAGGING
-				mouseMod = ModMotion
+				mouseMod = Modifier(lastMouseMod) | ModMotion
 				mouseKey = MouseLeft
 			case DRAGGING:
-				mouseMod = ModMotion
+				mouseMod = Modifier(lastMouseMod) | ModMotion
 				mouseKey = MouseLeft
 			}
 		}

pkg/gocui/tcell_driver_test.go

@@ -36,21 +36,55 @@ func TestMouseReleaseAfterDragIsMouseEvent(t *testing.T) {
 	assert.Equal(t, MouseRelease, releaseEvent.Key.KeyName())
 }
 
-func TestMouseReleaseDoesNotKeepPressModifiers(t *testing.T) {
+func TestWholeGestureCarriesPressModifiers(t *testing.T) {
 	t.Cleanup(resetMouseState)
 	resetMouseState()
 
-	gocuiEventFromTcellEvent(tcell.NewEventMouse(1, 2, tcell.ButtonPrimary, tcell.ModAlt))
-	gocuiEventFromTcellEvent(tcell.NewEventMouse(1, 3, tcell.ButtonPrimary, tcell.ModAlt))
+	pressEvent := gocuiEventFromTcellEvent(tcell.NewEventMouse(1, 2, tcell.ButtonPrimary, tcell.ModAlt))
+	dragEvent := gocuiEventFromTcellEvent(tcell.NewEventMouse(1, 3, tcell.ButtonPrimary, tcell.ModAlt))
 	releaseEvent := gocuiEventFromTcellEvent(tcell.NewEventMouse(1, 3, tcell.ButtonNone, tcell.ModAlt))
 
+	assert.Equal(t, eventMouse, pressEvent.Type)
+	assert.Equal(t, MouseLeft, pressEvent.Key.KeyName())
+	assert.Equal(t, ModAlt, pressEvent.Key.Mod())
+	assert.Equal(t, eventMouse, dragEvent.Type)
+	assert.Equal(t, MouseLeft, dragEvent.Key.KeyName())
+	assert.Equal(t, ModAlt|ModMotion, dragEvent.Key.Mod())
 	assert.Equal(t, eventMouse, releaseEvent.Type)
 	assert.Equal(t, MouseRelease, releaseEvent.Key.KeyName())
+	assert.Equal(t, ModAlt, releaseEvent.Key.Mod())
+}
+
+func TestModifierChangesWhileButtonHeldAreIgnored(t *testing.T) {
+	t.Cleanup(resetMouseState)
+	resetMouseState()
+
+	gocuiEventFromTcellEvent(tcell.NewEventMouse(1, 2, tcell.ButtonPrimary, tcell.ModNone))
+	dragEvent := gocuiEventFromTcellEvent(tcell.NewEventMouse(1, 3, tcell.ButtonPrimary, tcell.ModAlt))
+	releaseEvent := gocuiEventFromTcellEvent(tcell.NewEventMouse(1, 3, tcell.ButtonNone, tcell.ModAlt))
+
+	assert.Equal(t, ModMotion, dragEvent.Key.Mod())
 	assert.Equal(t, ModNone, releaseEvent.Key.Mod())
 }
 
+func TestModifiedClickWithoutDragCarriesModifierOnPressAndRelease(t *testing.T) {
+	t.Cleanup(resetMouseState)
+	resetMouseState()
+
+	pressEvent := gocuiEventFromTcellEvent(tcell.NewEventMouse(1, 2, tcell.ButtonPrimary, tcell.ModShift))
+	releaseEvent := gocuiEventFromTcellEvent(tcell.NewEventMouse(1, 2, tcell.ButtonNone, tcell.ModShift))
+
+	assert.Equal(t, eventMouse, pressEvent.Type)
+	assert.Equal(t, MouseLeft, pressEvent.Key.KeyName())
+	assert.Equal(t, ModShift, pressEvent.Key.Mod())
+	assert.Equal(t, eventMouse, releaseEvent.Type)
+	assert.Equal(t, MouseRelease, releaseEvent.Key.KeyName())
+	assert.Equal(t, ModShift, releaseEvent.Key.Mod())
+}
+
 func resetMouseState() {
 	lastMouseKey = tcell.ButtonNone
+	lastMouseMod = tcell.ModNone
 	dragState = NOT_DRAGGING
 	lastX = 0
 	lastY = 0