7abe61a71f
- ContentView 观测 onChange(geo.size)/onAppear → controller.containerResized - containerResized: 点尺寸 × displayScale ÷ cell 像素 = 目标 cols×rows，去重 + debounce(200ms) → refresh-client -C WxH → tmux 重排回 %layout-change → 更新 pane frame - cell 像素来自 raw 终端/pane surface metrics(InMemoryTerminalViewport.cellWidthPixels)； surface resize 回调只 noteCellPixels 不驱动 tmux（防反馈环，单向数据流） - 验证：容器 1032x1280@2x cell16x35→129x73，tmux 根 rect 精确采纳，2 pane 复用不重建 Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
336 lines
15 KiB
Swift
336 lines
15 KiB
Swift
import Foundation
|
||
import GhosttyTerminal
|
||
import TXCore
|
||
|
||
/// 一个 pane 的独立终端面：session + surface state + 输出闸门。
|
||
@MainActor
|
||
final class TmuxPaneSurface: ObservableObject, Identifiable {
|
||
let id: TmuxPaneID
|
||
let state: TerminalViewState
|
||
let session: InMemoryTerminalSession
|
||
let gate: OutputGate
|
||
/// 来自 layout rect 的字符格子（cols×rows），供渲染 frame 与断言参考。
|
||
var grid: (cols: Int, rows: Int)
|
||
/// 初始 `capture-pane` 应答到达前丢弃该 pane 的 %output（避免与快照重复）；tmux 单线程串行保证正确。
|
||
var awaitingCapture = true
|
||
|
||
init(id: TmuxPaneID, cols: Int, rows: Int,
|
||
onInput: @escaping @Sendable (Data) -> Void,
|
||
onMetrics: @escaping @Sendable (Int, Int) -> Void) {
|
||
self.id = id
|
||
self.grid = (cols, rows)
|
||
let session = InMemoryTerminalSession(
|
||
write: { data in onInput(data) }, // 输入直接绑到本 pane → send-keys -t %self
|
||
// tmux 模式：surface resize 只回报 cell 像素供换算，绝不反向驱动 tmux（防反馈环）。
|
||
resize: { vp in onMetrics(Int(vp.cellWidthPixels), Int(vp.cellHeightPixels)) }
|
||
)
|
||
let state = TerminalViewState()
|
||
state.configuration = TerminalSurfaceOptions(backend: .inMemory(session))
|
||
self.session = session
|
||
self.state = state
|
||
self.gate = OutputGate(session: session)
|
||
}
|
||
}
|
||
|
||
/// 一个 tmux window：持有多 pane surface + 布局树（渲染用可见树 / diff 用完整树）。
|
||
@MainActor
|
||
final class TmuxWindow: ObservableObject, Identifiable {
|
||
let id: TmuxWindowID
|
||
@Published var title: String
|
||
@Published var panes: [TmuxPaneID: TmuxPaneSurface] = [:]
|
||
/// 渲染用：zoom 时只含被 zoom 的 pane。
|
||
@Published var visibleLayout: TmuxLayout?
|
||
/// pane 集合 diff 用：完整树。
|
||
var fullLayout: TmuxLayout?
|
||
@Published var activePane: TmuxPaneID?
|
||
|
||
init(id: TmuxWindowID, title: String) { self.id = id; self.title = title }
|
||
}
|
||
|
||
/// tmux control-mode 网关：消费 `%`-协议流，把 window 映射为原生 tab、window 内多 pane 映射为分屏。
|
||
/// 尺寸走"路线 b"：app 按全屏格子发 `refresh-client -C WxH` 让 tmux 布局，pane surface 尺寸严格取
|
||
/// layout rect（%output 按 tmux pane 宽高排版，二者一致才不换行/清屏错乱）。
|
||
@MainActor
|
||
final class TmuxController: ObservableObject {
|
||
@Published private(set) var windows: [TmuxWindow] = []
|
||
@Published var activeWindowID: TmuxWindowID?
|
||
|
||
private let parser = TmuxControlParser()
|
||
private var windowByID: [TmuxWindowID: TmuxWindow] = [:]
|
||
private var surfaceByPane: [TmuxPaneID: TmuxPaneSurface] = [:] // %output O(1) 按 pane 路由
|
||
private var paneToWindow: [TmuxPaneID: TmuxWindowID] = [:]
|
||
private let sendRaw: @Sendable (Data) -> Void
|
||
var onExit: (() -> Void)?
|
||
|
||
private var clientCols = 80, clientRows = 24
|
||
private var cellWpx = 0, cellHpx = 0 // cell 设备像素（换算容器点尺寸→格子）
|
||
private var lastSentCols = 0, lastSentRows = 0
|
||
private var resizeDebounce: Task<Void, Never>?
|
||
|
||
// control-mode 命令应答 FIFO 匹配。
|
||
private var attachAcked = false
|
||
private enum PendingKind { case ignore, listWindows, capturePane(TmuxPaneID) }
|
||
private var pending: [PendingKind] = []
|
||
|
||
init(sendRaw: @escaping @Sendable (Data) -> Void) {
|
||
self.sendRaw = sendRaw
|
||
}
|
||
|
||
/// 由 model 在 attach 前告知全屏格子（tmux 据此 refresh-client -C 布局）。
|
||
func setClientSize(cols: Int, rows: Int) { clientCols = max(1, cols); clientRows = max(1, rows) }
|
||
|
||
/// cell 设备像素（来自 raw 终端或 pane surface metrics）。
|
||
func setCellPixels(w: Int, h: Int) { if w > 0 { cellWpx = w }; if h > 0 { cellHpx = h } }
|
||
/// pane surface metrics 回报（仅刷新 cell 缓存，绝不反向驱动 tmux）。
|
||
func noteCellPixels(w: Int, h: Int) { setCellPixels(w: w, h: h) }
|
||
|
||
/// 容器尺寸变化（iPadOS 拖拽窗口/旋转/分屏）：换算总格子 → 去重 + debounce → refresh-client -C。
|
||
/// 单向数据流：尺寸只来自"容器点尺寸 × displayScale ÷ cell 像素"，绝不来自 surface resize 回调（防反馈环）。
|
||
func containerResized(widthPt: CGFloat, heightPt: CGFloat, scale: CGFloat) {
|
||
guard cellWpx > 0, cellHpx > 0, widthPt > 0, heightPt > 0, scale > 0 else { return }
|
||
let cols = max(1, Int(widthPt * scale / CGFloat(cellWpx)))
|
||
let rows = max(1, Int(heightPt * scale / CGFloat(cellHpx)))
|
||
guard cols != lastSentCols || rows != lastSentRows else { return }
|
||
lastSentCols = cols; lastSentRows = rows
|
||
clientCols = cols; clientRows = rows
|
||
NSLog("TMUXDBG containerResized pt=\(Int(widthPt))x\(Int(heightPt)) scale=\(scale) cell=\(cellWpx)x\(cellHpx) -> \(cols)x\(rows)")
|
||
resizeDebounce?.cancel()
|
||
resizeDebounce = Task { [weak self] in
|
||
try? await Task.sleep(nanoseconds: 200_000_000) // 合并拖拽期间的连续变化
|
||
guard !Task.isCancelled, let self, self.attachAcked else { return }
|
||
NSLog("TMUXDBG refresh-client -C \(cols)x\(rows)")
|
||
self.sendCommand("refresh-client -C \(cols)x\(rows)") // tmux 重排 → 回 %layout-change → 更新 frame
|
||
}
|
||
}
|
||
|
||
var activeWindow: TmuxWindow? {
|
||
guard let id = activeWindowID else { return windows.first }
|
||
return windowByID[id]
|
||
}
|
||
|
||
/// 送入 control-mode 字节流。
|
||
func feed(_ data: Data) {
|
||
for event in parser.feed(data) { apply(event) }
|
||
}
|
||
|
||
// MARK: - 事件处理
|
||
|
||
private func apply(_ event: TmuxEvent) {
|
||
switch event {
|
||
case .windowAdd(let w):
|
||
_ = ensureWindow(w) // 布局稍后经 %layout-change 到来
|
||
case .windowClose(let w), .unlinkedWindowClose(let w):
|
||
removeWindow(w)
|
||
case .windowRenamed(let w, let name):
|
||
windowByID[w]?.title = name
|
||
case .layoutChange(let w, let layout, let visible):
|
||
applyLayout(window: w, full: layout, visible: visible ?? layout)
|
||
case .windowPaneChanged(let w, let pane):
|
||
paneToWindow[pane] = w
|
||
windowByID[w]?.activePane = pane // 幂等：仅记录，不反向发 select-pane
|
||
case .output(let pane, let data):
|
||
routeOutput(pane, data)
|
||
case .extendedOutput(let pane, _, let data):
|
||
routeOutput(pane, data)
|
||
case .sessionWindowChanged(_, let w):
|
||
if windowByID[w] != nil { activeWindowID = w }
|
||
case .commandResponse(let response):
|
||
handleCommandResponse(response)
|
||
case .exit:
|
||
onExit?()
|
||
default:
|
||
break
|
||
}
|
||
}
|
||
|
||
private func routeOutput(_ pane: TmuxPaneID, _ data: Data) {
|
||
guard let s = surfaceByPane[pane] else { return }
|
||
if s.awaitingCapture { return } // capture 快照前的输出丢弃（快照已含）
|
||
s.gate.deliver(data)
|
||
}
|
||
|
||
/// 解析 layout → reconcile pane surface（增/删/留），设置渲染用可见树。
|
||
private func applyLayout(window w: TmuxWindowID, full: String, visible: String) {
|
||
let win = ensureWindow(w)
|
||
guard let fullTree = try? TmuxLayout.parse(full) else { return }
|
||
let visTree = (try? TmuxLayout.parse(visible)) ?? fullTree
|
||
let newPanes = Set(fullTree.paneIDs)
|
||
|
||
// 删除：不在新完整树里的 pane。
|
||
for p in Array(win.panes.keys) where !newPanes.contains(p) {
|
||
win.panes[p] = nil; surfaceByPane[p] = nil; paneToWindow[p] = nil
|
||
}
|
||
// 新增：为完整树里的所有 pane 建 surface（保内容跨 zoom）；grid 取可见树 rect（渲染尺寸）。
|
||
walkLeaves(fullTree.root) { pane, rect in
|
||
ensurePane(pane, window: w, cols: rect.width, rows: rect.height)
|
||
}
|
||
walkLeaves(visTree.root) { pane, rect in
|
||
surfaceByPane[pane]?.grid = (rect.width, rect.height)
|
||
}
|
||
win.fullLayout = fullTree
|
||
win.visibleLayout = visTree // 单次发布 → SwiftUI 单帧更新，无闪烁
|
||
let rr = fullTree.root.rect
|
||
NSLog("TMUXDBG layout win=@\(w.raw) root=\(rr.width)x\(rr.height) panes=\(fullTree.paneIDs.count)")
|
||
if win.activePane == nil || !newPanes.contains(win.activePane!) {
|
||
win.activePane = fullTree.paneIDs.first
|
||
}
|
||
}
|
||
|
||
private func walkLeaves(_ node: TmuxLayout.Node, _ visit: (TmuxPaneID, TmuxLayout.Rect) -> Void) {
|
||
switch node {
|
||
case .leaf(let p, let r): visit(p, r)
|
||
case .horizontal(let cs, _), .vertical(let cs, _): cs.forEach { walkLeaves($0, visit) }
|
||
}
|
||
}
|
||
|
||
private func ensurePane(_ p: TmuxPaneID, window w: TmuxWindowID, cols: Int, rows: Int) {
|
||
paneToWindow[p] = w
|
||
guard let win = windowByID[w] else { return }
|
||
if let existing = surfaceByPane[p] { existing.grid = (cols, rows); return } // 复用，不重建
|
||
let surface = TmuxPaneSurface(
|
||
id: p, cols: cols, rows: rows,
|
||
onInput: { [weak self] data in self?.sendKeys(pane: p, data: data) },
|
||
onMetrics: { [weak self] w, h in Task { @MainActor in self?.noteCellPixels(w: w, h: h) } }
|
||
)
|
||
surfaceByPane[p] = surface
|
||
win.panes[p] = surface
|
||
// 抓初始屏（capture %end 后放行 %output）。
|
||
pending.append(.capturePane(p))
|
||
sendCommand("capture-pane -t %\(p.raw) -p -e -J")
|
||
}
|
||
|
||
/// control-mode 命令应答。第一个应答是 attach 隐式块 → 设尺寸 + 枚举 windows；之后按 FIFO 匹配。
|
||
private func handleCommandResponse(_ r: TmuxCommandResponse) {
|
||
if !attachAcked {
|
||
attachAcked = true
|
||
// 先设客户端尺寸（tmux 据此布局），再枚举——枚举到的 layout 已是我方尺寸，避免先渲一帧再重排的闪跳。
|
||
sendCommand("refresh-client -C \(clientCols)x\(clientRows)")
|
||
pending.append(.ignore)
|
||
sendCommand("list-windows -F \"#{window_id}\t#{window_name}\t#{window_active}\t#{window_layout}\t#{window_visible_layout}\"")
|
||
pending.append(.listWindows)
|
||
return
|
||
}
|
||
guard !pending.isEmpty else { return }
|
||
switch pending.removeFirst() {
|
||
case .ignore:
|
||
break
|
||
case .listWindows:
|
||
for line in r.lines {
|
||
let parts = line.split(separator: "\t", omittingEmptySubsequences: false)
|
||
guard parts.count >= 5, let w = TmuxWindowID.parse(parts[0]) else { continue }
|
||
let win = ensureWindow(w)
|
||
win.title = String(parts[1])
|
||
if parts[2] == "1" { activeWindowID = w }
|
||
applyLayout(window: w, full: String(parts[3]), visible: String(parts[4]))
|
||
}
|
||
case .capturePane(let p):
|
||
let snapshot = r.lines.joined(separator: "\r\n")
|
||
if let s = surfaceByPane[p] {
|
||
if !snapshot.isEmpty {
|
||
// 归位后铺快照（不尾随换行，避免滚屏）。
|
||
s.gate.deliver(Data(("\u{1b}[H" + snapshot).utf8))
|
||
}
|
||
s.awaitingCapture = false // 放行后续 %output
|
||
}
|
||
}
|
||
}
|
||
|
||
@discardableResult
|
||
private func ensureWindow(_ w: TmuxWindowID) -> TmuxWindow {
|
||
if let existing = windowByID[w] { return existing }
|
||
let win = TmuxWindow(id: w, title: "窗口 \(w.raw)")
|
||
windowByID[w] = win
|
||
windows.append(win)
|
||
windows.sort { $0.id.raw < $1.id.raw }
|
||
if activeWindowID == nil { activeWindowID = w }
|
||
return win
|
||
}
|
||
|
||
private func removeWindow(_ w: TmuxWindowID) {
|
||
if let win = windowByID[w] {
|
||
for p in win.panes.keys { surfaceByPane[p] = nil }
|
||
}
|
||
windowByID[w] = nil
|
||
windows.removeAll { $0.id == w }
|
||
paneToWindow = paneToWindow.filter { $0.value != w }
|
||
if activeWindowID == w { activeWindowID = windows.first?.id }
|
||
}
|
||
|
||
// MARK: - 命令 / 输入
|
||
|
||
func sendCommand(_ command: String) {
|
||
sendRaw(Data((command + "\n").utf8))
|
||
}
|
||
|
||
/// 某 pane 的 surface 收到用户输入 → send-keys -H 到该 pane（可能在非主线程被调，hop 到主线程）。
|
||
private nonisolated func sendKeys(pane p: TmuxPaneID, data: Data) {
|
||
let hex = data.map { String(format: "%02x", $0) }.joined(separator: " ")
|
||
Task { @MainActor in self.sendCommand("send-keys -t %\(p.raw) -H \(hex)") }
|
||
}
|
||
|
||
/// 点击 pane → 本地立即置活动 + 通知 tmux（%window-pane-changed 回来幂等应用）。
|
||
func selectPane(_ p: TmuxPaneID, in w: TmuxWindowID) {
|
||
windowByID[w]?.activePane = p
|
||
sendCommand("select-pane -t %\(p.raw)")
|
||
}
|
||
|
||
func selectWindow(_ w: TmuxWindowID) {
|
||
activeWindowID = w
|
||
sendCommand("select-window -t @\(w.raw)")
|
||
}
|
||
|
||
func newWindow() { sendCommand("new-window") }
|
||
func killWindow(_ w: TmuxWindowID) { sendCommand("kill-window -t @\(w.raw)") }
|
||
|
||
/// 某 pane 的 surface 就绪 → 放行其缓冲输出。
|
||
func markPaneReady(_ p: TmuxPaneID) { surfaceByPane[p]?.gate.markReady() }
|
||
}
|
||
|
||
/// 传输字节分流器：检测 `tmux -CC` 进入 DCS 前 → 原始终端；进入后 → tmux 网关。
|
||
/// 在传输后台线程调用；原始字节走线程安全的 rawGate，网关字节经闭包 hop 到主线程。
|
||
final class TmuxRouter: @unchecked Sendable {
|
||
private let lock = NSLock()
|
||
private let rawGate: OutputGate
|
||
private let enterGateway: @Sendable ([UInt8]) -> Void
|
||
private let gatewayBytes: @Sendable ([UInt8]) -> Void
|
||
private var carry: [UInt8] = []
|
||
private var inGateway = false
|
||
|
||
init(rawGate: OutputGate,
|
||
enterGateway: @escaping @Sendable ([UInt8]) -> Void,
|
||
gatewayBytes: @escaping @Sendable ([UInt8]) -> Void) {
|
||
self.rawGate = rawGate
|
||
self.enterGateway = enterGateway
|
||
self.gatewayBytes = gatewayBytes
|
||
}
|
||
|
||
func feed(_ data: Data) {
|
||
lock.lock(); defer { lock.unlock() }
|
||
if inGateway {
|
||
gatewayBytes(Array(data))
|
||
return
|
||
}
|
||
let buf = carry + Array(data)
|
||
if let idx = TmuxControlSequence.find(TmuxControlSequence.enter, in: buf) {
|
||
let before = Array(buf[0 ..< idx])
|
||
let after = Array(buf[(idx + TmuxControlSequence.enter.count)...])
|
||
if !before.isEmpty { rawGate.deliver(Data(before)) }
|
||
inGateway = true
|
||
carry = []
|
||
enterGateway(after)
|
||
} else {
|
||
// 仅当结尾是哨兵部分前缀时滞留，避免延迟正常输出。
|
||
let k = TmuxControlSequence.partialTrailingMatchLength(TmuxControlSequence.enter, in: buf)
|
||
if buf.count > k {
|
||
rawGate.deliver(Data(buf[0 ..< (buf.count - k)]))
|
||
}
|
||
carry = k > 0 ? Array(buf.suffix(k)) : []
|
||
}
|
||
}
|
||
|
||
/// tmux 退出 → 回原始模式。
|
||
func reset() {
|
||
lock.lock(); inGateway = false; carry = []; lock.unlock()
|
||
}
|
||
}
|