Mouse motion row and focus reporting fixes (#590)

* Report current focus state immediately when DECSET 1004 is enabled

xterm reports the current focus state as soon as an application enables
focus reporting; without it, applications that enable 1004 while the
terminal is already focused assume they are unfocused until the first
real focus change (e.g. Claude Code's Enter handling stays inert until
the user clicks away and back).

Terminal now tracks the host view's focus (setTerminalFocus updates it
regardless of reporting mode) and DECSET 1004 replies with CSI I / CSI O
for the tracked state right away.

* Mac: report viewport rows in mouse motion events, drop stray print

sendMotion was passed the buffer-absolute row (hit.grid.row includes
yDisp) while press/release/drag paths already convert to screen rows;
once any scrollback exists, hover-tracking applications receive rows
far outside the viewport and their hit-testing never matches.

Also removes a leftover debug print in the SGR-pixel mouse encoder
that fires on every event.

Author: naifalziadna

Sources/SwiftTerm/Mac/MacTerminalView.swift

@@ -2682,7 +2682,14 @@ open class TerminalView: NSView, NSTextInputClient, NSUserInterfaceValidations,
 
         if terminal.mouseMode.sendMotionEvent() {
             let flags = encodeMouseEvent(with: event, overwriteRelease: true)
-            terminal.sendMotion(buttonFlags: flags, x: hit.grid.col, y: hit.grid.row, pixelX: hit.pixels.col, pixelY: hit.pixels.row)
+            // Report the viewport row, not the buffer-absolute row: with
+            // scrollback present the absolute row is far outside the screen
+            // and applications tracking hover (e.g. TUIs with clickable rows)
+            // never match their hit targets. Press/release/drag already
+            // subtract yDisp via their own screenRow computations.
+            let displayBuffer = terminal.displayBuffer
+            let screenRow = max (0, min (displayBuffer.rows - 1, hit.grid.row - displayBuffer.yDisp))
+            terminal.sendMotion(buttonFlags: flags, x: hit.grid.col, y: screenRow, pixelX: hit.pixels.col, pixelY: hit.pixels.row)
         }
     }
 

Sources/SwiftTerm/Terminal.swift

@@ -569,13 +569,23 @@ open class Terminal {
         }
     }
 
+    /// Tracks the host view's focus so that enabling focus reporting (DECSET
+    /// 1004) can immediately tell the application the current state, the way
+    /// xterm does. Defaults to focused.
+    var reportedFocusState: Bool = true
+
     /// Invoke this command when the terminal receives and loses focus
     public func setTerminalFocus(_ focused: Bool) {
+        reportedFocusState = focused
         if sendFocus {
-            let data: [UInt8] = cc.CSI + [focused ? 0x49 : 0x4f]
-            tdel?.send(source: self, data: data[0...])
+            sendFocusReport()
         }
     }
+
+    func sendFocusReport() {
+        let data: [UInt8] = cc.CSI + [reportedFocusState ? 0x49 : 0x4f]
+        tdel?.send(source: self, data: data[0...])
+    }
 
     ///
     /// Represents the mouse operation mode that the terminal is currently using and higher level
@@ -4406,6 +4416,10 @@ open class Terminal {
                    // focusin: ^[[I
                    // focusout: ^[[O
                 sendFocus = true
+                // Report the current state right away (xterm behavior), so
+                // the application does not assume it is unfocused until the
+                // first real focus change.
+                sendFocusReport()
             case 1005:
                 // utf8 ext mode mouse
                 mouseProtocol = .utf8
@@ -5735,7 +5749,6 @@ open class Terminal {
             let isRelease = (buttonFlags & 3) == 3 && (buttonFlags & 32) == 0
             let bflags : Int = isRelease ? (buttonFlags & ~3) : buttonFlags
             let m = isRelease ? "m" : "M"
-            print ("\(pixelX);\(pixelY)")
             sendResponse(cc.CSI, "<\(bflags);\(pixelX);\(pixelY)\(m)")
 
         case .urxvt:

Tests/SwiftTermTests/FocusReportTests.swift

@@ -0,0 +1,61 @@
+//
+//  FocusReportTests.swift
+//
+//  DECSET 1004 focus reporting: enabling reports the current focus state
+//  immediately (xterm behavior), then focus changes report as they happen.
+//
+import Foundation
+import Testing
+
+@testable import SwiftTerm
+
+final class FocusReportTests: TerminalDelegate {
+    var sent: [UInt8] = []
+
+    func send(source: Terminal, data: ArraySlice<UInt8>) {
+        sent.append(contentsOf: data)
+    }
+
+    var sentString: String {
+        String(decoding: sent, as: UTF8.self)
+    }
+
+    func makeTerminal() -> Terminal {
+        Terminal(delegate: self, options: TerminalOptions(cols: 80, rows: 25))
+    }
+
+    @Test func enablingFocusReportingSendsCurrentState() {
+        let terminal = makeTerminal()
+        terminal.feed(text: "\u{1b}[?1004h")
+        #expect(sentString == "\u{1b}[I", "enable while focused reports focus-in immediately")
+
+        sent.removeAll()
+        terminal.setTerminalFocus(false)
+        #expect(sentString == "\u{1b}[O")
+
+        sent.removeAll()
+        terminal.setTerminalFocus(true)
+        #expect(sentString == "\u{1b}[I")
+    }
+
+    @Test func enablingWhileUnfocusedReportsFocusOut() {
+        let terminal = makeTerminal()
+        terminal.setTerminalFocus(false)
+        sent.removeAll()
+        terminal.feed(text: "\u{1b}[?1004h")
+        #expect(sentString == "\u{1b}[O", "enable while unfocused reports focus-out immediately")
+    }
+
+    @Test func focusChangesAreSilentWhenReportingDisabled() {
+        let terminal = makeTerminal()
+        terminal.setTerminalFocus(false)
+        terminal.setTerminalFocus(true)
+        #expect(sent.isEmpty)
+
+        terminal.feed(text: "\u{1b}[?1004h")
+        sent.removeAll()
+        terminal.feed(text: "\u{1b}[?1004l")
+        terminal.setTerminalFocus(false)
+        #expect(sent.isEmpty, "no reports after DECRST 1004")
+    }
+}