diff options
Diffstat (limited to 'src/term')
| -rw-r--r-- | src/term/echo.zig | 7 | ||||
| -rw-r--r-- | src/term/terminal.zig | 524 |
2 files changed, 114 insertions, 417 deletions
diff --git a/src/term/echo.zig b/src/term/echo.zig index 4f27a08f..d069fe36 100644 --- a/src/term/echo.zig +++ b/src/term/echo.zig @@ -236,7 +236,8 @@ pub const Echo = struct { fn predict(e: *Echo, pane: *Pane, kind: Kind, seq: u32) bool { const state = pane.terminal orelse return false; const vt = &state.vt; - if (vt.screens.active_key != .primary or !terminal.atBottom(pane) or !vt.modes.get(.cursor_visible)) return false; + const sb = vt.screens.active.pages.scrollbar(); + if (vt.screens.active_key != .primary or sb.offset + sb.len < sb.total or !vt.modes.get(.cursor_visible)) return false; const top = e.tops[e.pane]; const screen = vt.screens.active; const cur: Cursor = e.cursor orelse .{ .x = @intCast(screen.cursor.x), .row = top + screen.cursor.y, .seq = 0 }; @@ -642,7 +643,7 @@ const Rig = struct { const s = try c.render(arena.allocator()); const pane = c.panes[g.shell].?; const body = s.region(.body, g.shell).?.rect; - const y = body.y + terminal.gridCursor(pane).y; + const y = body.y + pardes.Term.grid(pane.terminal).cursor_y; const cell = s.at(body.x + x, y); return .{ .cp = cell.text[0], .ul = cell.style.ul != .off, .cursor = if (s.cursor) |cur| if (cur.y == y) cur.x - body.x else null else null }; } @@ -704,7 +705,7 @@ test "a password prompt shows nothing typed, and a full-screen program is not pr try g.prints(prompt ++ "sudo ls\r\n\x1b]133;C;aid=pardes\x07[sudo] password: "); var arena: std.heap.ArenaAllocator = .init(testing.allocator); defer arena.deinit(); - const x = terminal.gridCursor(g.r.core().panes[g.shell].?).x; + const x = pardes.Term.grid(g.r.core().panes[g.shell].?.terminal).cursor_x; const k = try g.key(.{ .cp = 'h', .text = "h" }); // Predicted, and not drawn: nothing has confirmed an echo here. try testing.expectEqual(@as(u32, 1), g.r.echo.stats.predicted); diff --git a/src/term/terminal.zig b/src/term/terminal.zig index 9472cfe1..50fca2d0 100644 --- a/src/term/terminal.zig +++ b/src/term/terminal.zig @@ -11,6 +11,7 @@ const tracy = @import("../tracy.zig"); const tagline = @import("../tagline.zig"); const Key = pardes.Key; const Pane = panes.Pane; +const Term = @import("../Term.zig"); const EditText = panes.EditText; const File = panes.File; @@ -510,55 +511,21 @@ pub fn terminalIo() std.Io { return std.Io.Threaded.global_single_threaded.io(); } -/// The three numbers ghostty's scrollbar reports; all zero without an emulator. -pub const Scrollbar = struct { total: usize = 0, offset: usize = 0, len: usize = 0 }; - -pub fn scrollbar(pane: *const Pane) Scrollbar { - const state = pane.terminal orelse return .{}; - const sb = state.vt.screens.active.pages.scrollbar(); - return .{ .total = sb.total, .offset = sb.offset, .len = sb.len }; -} - -/// The emulator's viewport offset, in SHELL rows: the top of what it shows. -pub fn gridOffset(pane: *const Pane) i32 { - return @intCast(scrollbar(pane).offset); -} - -/// Where the emulator itself puts the cursor, in active-area cells — the origin -/// without one, which is where an empty pane's cursor belongs anyway. -pub const GridCursor = struct { x: u16 = 0, y: u16 = 0 }; - -pub fn gridCursor(pane: *const Pane) GridCursor { - const state = pane.terminal orelse return .{}; - const cur = state.vt.screens.active.cursor; - return .{ .x = @intCast(cur.x), .y = @intCast(cur.y) }; -} - -pub fn visibleCursor(pane: *const Pane) ?GridCursor { - const state = pane.terminal orelse return null; - if (!state.vt.modes.get(.cursor_visible)) return null; - const cur = state.vt.screens.active.cursor; - const sb = scrollbar(pane); - const row = sb.total - sb.len + cur.y; - if (row < sb.offset + pane.pan or row - sb.offset >= sb.len) return null; - return .{ .x = @intCast(cur.x), .y = @intCast(row - sb.offset - pane.pan) }; -} - -/// The rows terminal `pane`'s top is passed over by in a view whose rect -/// `r` is shorter than it, one that does not size it (Pardes.sizes): as -/// many as keep its cursor's row in sight, as tmux pans a bigger window in -/// a smaller client. 0 in the view that sizes it, and in one tall enough. -pub fn panFor(p: *const Pardes, pane: *const Pane, r: pardes.Rect) u16 { - if (pane.sized_by == p.live or pane.collapsed or !pane.isTerminal()) return 0; - const shown = r.h -| pane.tag_rows; - if (shown == 0 or shown >= pane.rows) return 0; - const state = pane.terminal orelse return 0; - const sb = scrollbar(pane); - // The cursor's row in the viewport; past its end (scrolled back), its - // last row. - const row = sb.total - sb.len + state.vt.screens.active.cursor.y; - const at: usize = if (row < sb.offset) 0 else @min(row - sb.offset, pane.rows - 1); - return @intCast(@min(pane.rows - shown, (at + 1) -| shown)); +/// Where the view and the cursor are (`Term.Grid`); all zero without an +/// emulator. +pub fn grid(state: ?*const State) Term.Grid { + const s = state orelse return .{}; + const screen = s.vt.screens.active; + const sb = screen.pages.scrollbar(); + return .{ + .total = sb.total, + .offset = sb.offset, + .len = sb.len, + .cursor_x = @intCast(screen.cursor.x), + .cursor_y = @intCast(screen.cursor.y), + .cursor_visible = s.vt.modes.get(.cursor_visible), + .view = if (screen.pages.viewport == .active) null else sb.offset, + }; } /// What pardes made of a terminal's stream that its emulator does not hold @@ -596,72 +563,30 @@ pub fn takeMarks(state: *State, bytes: []const u8) void { const authorityOnly = pardes.tape.authorityOnly; -/// A speculation that moves a terminal's view: a screen-state replica's -/// may (its rollback puts the view back, replica.zig `views`, and a delta -/// sets it), any other stops (`authorityOnly`). -fn viewOnly(comptime why: []const u8) bool { - if (!pardes.tape.speculating()) return false; - if (pardes.tape.screenState()) { - pardes.tape.touchTerminal(); - return false; - } - pardes.tape.poison(why); - return true; -} - -/// Where a terminal's view is: its top row counted from the top of its -/// history, or null following its output (a replica's rollback copy, -/// which holds no emulator, keeps it so). -pub fn viewOf(pane: *const Pane) ?usize { - const state = pane.terminal orelse return null; - const pages = &state.vt.screens.active.pages; - if (pages.viewport == .active) return null; - return pages.scrollbar().offset; -} - -pub fn viewTo(pane: *Pane, at: ?usize) void { - const state = pane.terminal orelse return; +/// Its view to row `at` of its history (from the top), or onto its output. +pub fn viewTo(state: *State, at: ?usize) void { state.vt.screens.active.scroll(if (at) |row| .{ .row = row } else .active); } -/// Move the emulator's viewport by `delta` shell rows (negative scrolls back). -pub fn scrollGrid(pane: *Pane, delta: i32) void { - if (viewOnly("scroll a terminal")) return; - const state = pane.terminal orelse return; +/// Its view moved by `delta` rows (negative scrolls back). +pub fn scroll(state: *State, delta: i32) void { state.vt.screens.active.scroll(.{ .delta_row = delta }); state.changes +%= 1; } -/// Is the viewport already showing the last row of output? -pub fn atBottom(pane: *const Pane) bool { - const sb = scrollbar(pane); - return sb.offset + sb.len >= sb.total; -} - -/// Snap the viewport back onto live output. -pub fn followOutput(pane: *Pane) void { - if (viewOnly("follow a terminal")) return; - const state = pane.terminal orelse return; +/// Its view back onto the output. +pub fn follow(state: *State) void { const moved = state.vt.screens.active.pages.viewport != .active; state.vt.screens.active.scroll(.active); state.changes +%= @intFromBool(moved); } -/// Reflow the grid. A failed reflow keeps the grid it had rather than dropping -/// a scrollback; the next resize retries with the same numbers. -pub fn resizeGrid(pane: *Pane, cols: u16, rows: u16) void { - if (authorityOnly("resize a terminal")) return; - const state = pane.terminal orelse return; - if (cols != pane.cols) for (0..pane.sel.len) |button| { - pane.clearPointerSelection(button); - pane.sel[button].state = .none; - }; - // A replica's emulator is sized by its authority: the next delta says. - if (pardes.tape.screenReplica()) return; - // ...and the authority's once the step's unit is out (a client typing - // at another size than the last typist's read history rows its replay - // held as holes, and the rows came renumbered, 2026-10-30). - if (pardes.tape.screenAuthority()) { +/// Its grid reflowed to `cols` by `rows`, now or, `later`, when +/// `resizeDeferred` is called. A failed reflow keeps the grid it had +/// rather than dropping a scrollback; the next resize retries with the +/// same numbers. +pub fn resize(state: *State, cols: u16, rows: u16, later: bool) void { + if (later) { state.resize_to = .{ .cols = cols, .rows = rows }; return; } @@ -669,15 +594,30 @@ pub fn resizeGrid(pane: *Pane, cols: u16, rows: u16) void { state.vt.resize(state.gpa, .{ .cols = cols, .rows = rows }) catch {}; } -/// The sizes steps gave terminals (`resizeGrid`), made: between units, on an -/// authority with screen-state replicas (replica.Peers.unit). -pub fn resizeDeferred(p: *Pardes) void { - for (p.panes) |slot| if (slot) |pane| if (pane.terminal) |state| if (state.resize_to) |size| { - state.resize_to = null; - state.changes +%= 1; - p.shell_rows.markStale(pane); - state.vt.resize(state.gpa, .{ .cols = size.cols, .rows = size.rows }) catch {}; - }; +/// The size `resize` left for later, made; whether there was one. +pub fn resizeDeferred(state: *State) bool { + const size = state.resize_to orelse return false; + state.resize_to = null; + state.changes +%= 1; + state.vt.resize(state.gpa, .{ .cols = size.cols, .rows = size.rows }) catch {}; + return true; +} + +/// The emulator's size in pixels follows the core's cells: kitty graphics +/// placements are sized by it, and CSI 14/16 t report it. +pub fn cellPixels(state: *State, w: u32, h: u32) void { + if (comptime !images_enabled) return; + const vt = &state.vt; + vt.width_px = @as(u32, vt.cols) * w; + vt.height_px = @as(u32, vt.rows) * h; +} + +/// What it answered its program (a cursor report, its attributes) since +/// the last call, to be written to its pty behind whatever is queued +/// there; valid until it is fed again. +pub fn replies(state: *State) []const u8 { + defer state.reply_len = 0; + return state.reply[0..state.reply_len]; } /// DECSET 2004: the program wants its pastes bracketed. @@ -908,48 +848,9 @@ fn ingest(state: *State, bytes: []const u8) void { state.changes +%= 1; } -/// What a pane says when a position kept over its terminal's rows could -/// not follow the output (no memory for its pin), so it was reset. -const positions_lost = "terminal edit position reset: out of memory"; - -/// Record and parse one live pty read, invalidate its motion surface, and -/// follow it only when the body (possibly parked under a tag edit) is raw. -pub fn feedOutput(p: *Pardes, pane: *Pane, bytes: []const u8) void { - // There are no pty reads at all without an emulator to parse them into. - if (pane.terminal == null) return; - if (authorityOnly("a terminal's output")) return; - const has_positions = pane.ovl != null or pane.body.cur_pinned or pane.body.vsel.active or - pane.body.nsel > 0 or pane.body.last_edit != null or pane.look_at != null or - pane.body.ed_undo_len > 0 or pane.body.ed_redo_len > 0 or pointerRowCount(pane) > 0; - // A replica's emulator is what the authority's deltas make it; what - // pardes keeps over it moves as the authority's ingest told it. - if (pardes.tape.screenReplica()) { - if (has_positions and ingestWithPositions(pane, bytes)) if (panes.paneIdOf(p, pane)) |id| p.setMessage(id, positions_lost); - return; - } - // Sticky bottom, as every other terminal does it: output drags the - // viewport down only when the viewport was already on the last row, so - // a reader scrolled back into the scrollback stays where they scrolled. - const at_bottom = atBottom(pane); - syncPixels(p, pane); - if (!has_positions) { - ingest(pane.terminal.?, bytes); - } else if (ingestWithPositions(pane, bytes)) if (panes.paneIdOf(p, pane)) |id| p.setMessage(id, positions_lost); - p.shell_rows.markStale(pane); - if (pane.body.mode == .tty and at_bottom) followOutput(pane); -} - const RowPin = struct { pin: ?*ghostty_vt.Pin = null, offset: i32 = 0 }; -const PositionPin = struct { - target: *i32, - row: RowPin, - overlay: ?*EditBuffer, - edit_row: ?i32 = null, -}; -fn trackRow(maybe_pages: ?*ghostty_vt.PageList, row: i32, failed: *bool) RowPin { - // A screen-state replica's: told by the tape, not its emulator. - const pages = maybe_pages orelse return .{ .offset = row }; +fn trackRow(pages: *ghostty_vt.PageList, row: i32, failed: *bool) RowPin { if (row < 0) return .{ .offset = row }; const bounded: usize = @min(@as(usize, @intCast(row)), pages.total_rows - 1); var left = pages.total_rows - 1 - bounded; @@ -979,236 +880,43 @@ fn pinnedRow(pages: ?*ghostty_vt.PageList, row: RowPin) i32 { return 0; } -fn trackPosition(pages: ?*ghostty_vt.PageList, target: *i32, overlay: ?*EditBuffer, failed: *bool) PositionPin { - var grid = target.*; - if (overlay) |edit| { - const lines: i32 = @intCast(modal.lineCount(edit.text)); - if (grid >= edit.row and grid < edit.row +| lines) - return .{ .target = target, .row = .{}, .overlay = edit, .edit_row = grid - edit.row }; - if (grid > edit.row) grid = grid -| lines +| edit.rows; +/// One read of its program's output. `track` are rows (absolute, from the +/// top of the history) the core keeps positions on; each is told in +/// `rows` where it is after the read and in `erased` whether the program +/// erased it (a negative row passes through untouched). With nothing +/// tracked the read is parsed and nothing more. +pub fn feed(state: *State, bytes: []const u8, track: []const i32, rows: []i32, erased: []bool) Term.Told { + if (track.len == 0) { + ingest(state, bytes); + return .{ .rows = rows[0..0], .erased = erased[0..0], .cleared = false, .alive = true, .failed = false }; } - return .{ .target = target, .row = trackRow(pages, grid, failed), .overlay = overlay }; -} - -fn pointerRowCount(pane: *const Pane) usize { - var count: usize = 0; - for (pane.sel) |gesture| if (pane.pointerSelection(gesture)) |rows| { - count += rows.len; - }; - return count; -} - -/// What an ingest told the positions over it (`ingestWithPositions`): each -/// tracked row where it is after it (the spans' starts and ends, the -/// positions, the pointer rows, in that order) and whether the program -/// erased it, whether the screen was cleared, whether its pages lived and -/// whether a pin could not be made. Taped: a screen-state replica, which -/// ingests nothing, is told the authority's. -pub const Told = struct { rows: []const i32, erased: []const bool, cleared: bool, alive: bool, failed: bool }; - -fn told(t: Told) Told { - return t; -} - -/// `ingest`, with every position kept over the rows (the edit copy, the -/// cursors and selections, their undo, the pointer's rows) moved as the -/// rows move. True when one could not be kept (no memory for its pin). -fn ingestWithPositions(pane: *Pane, bytes: []const u8) bool { - const screens = &pane.terminal.?.vt.screens; + const screens = &state.vt.screens; const key = screens.active_key; const generation = screens.generation(key); - const replica = pardes.tape.screenReplica(); - const pages: ?*ghostty_vt.PageList = if (replica) null else &screens.active.pages; - const Group = struct { overlay: ?*EditBuffer, cursor: *i32, selection: *panes.Text.CharSel }; - var groups: [history_max * 2 + 1]Group = undefined; - groups[0] = .{ - .overlay = if (pane.ovl) |*overlay| overlay else null, - .cursor = &pane.body.cur_row, - .selection = &pane.body.vsel, - }; - var ngroups: usize = 1; - for ([_][]Snapshot{ pane.body.ed_undo[0..pane.body.ed_undo_len], pane.body.ed_redo[0..pane.body.ed_redo_len] }) |history| { - for (history) |*snapshot| { - groups[ngroups] = .{ - .overlay = if (snapshot.ovl) |*overlay| overlay else null, - .cursor = &snapshot.cur_row, - .selection = &snapshot.vsel, - }; - ngroups += 1; - } - } - const Span = struct { overlay: *EditBuffer, start: RowPin, end: RowPin }; - var spans: [groups.len]Span = undefined; - var nspans: usize = 0; - var positions: [groups.len * 2 + panes.Text.max_selections * 2 + 4]PositionPin = undefined; - var npositions: usize = 0; + const pages = &screens.active.pages; var failed = false; - for (groups[0..ngroups]) |group| { - if (group.overlay) |overlay| { - spans[nspans] = .{ - .overlay = overlay, - .start = trackRow(pages, overlay.row, &failed), - .end = trackRow(pages, overlay.row +| (overlay.rows - 1), &failed), - }; - nspans += 1; - } - positions[npositions] = trackPosition(pages, group.cursor, group.overlay, &failed); - npositions += 1; - if (group.selection.active) { - positions[npositions] = trackPosition(pages, &group.selection.row, group.overlay, &failed); - npositions += 1; - } - } - const overlay = groups[0].overlay; - // Where the live pane's own selections sit in `positions`: one whose - // row the program erased goes (below), as the edited copy does. - const vsel_at: ?usize = if (pane.body.vsel.active) 1 else null; - const sels_at = npositions; - var extra: [panes.Text.max_selections * 2 + 2]*i32 = undefined; - var nextra: usize = 0; - for (pane.body.sels[0..pane.body.nsel]) |*selection| { - extra[nextra] = &selection.row; - extra[nextra + 1] = &selection.arow; - nextra += 2; - } - if (pane.body.last_edit) |*at| { - extra[nextra] = &at.row; - nextra += 1; - } - if (pane.look_at) |*at| { - extra[nextra] = &at.row; - nextra += 1; - } - for (extra[0..nextra]) |target| { - positions[npositions] = trackPosition(pages, target, overlay, &failed); - npositions += 1; - } - const pointer_positions = pane.gpa.alloc(PositionPin, pointerRowCount(pane)) catch null; - defer if (pointer_positions) |pins| pane.gpa.free(pins); - if (pointer_positions) |pins| { - var index: usize = 0; - for (pane.sel) |gesture| if (pane.pointerSelection(gesture)) |rows| { - for (rows) |*row| { - pins[index] = trackPosition(pages, &row.row, if (row.raw_terminal) null else overlay, &failed); - index += 1; - } - }; - } else failed = true; - var cleared = false; - var alive: ?*ghostty_vt.PageList = null; - if (!replica) { - // Whether the program cleared the screen (ED 2, a switch of - // screens); pardes reads the flag nowhere else. - pane.terminal.?.vt.flags.dirty.clear = false; - ingest(pane.terminal.?, bytes); - cleared = pane.terminal.?.vt.flags.dirty.clear; - // RIS can destroy the alternate screen and every pin it owned. - alive = if (screens.generation(key) == generation) pages else null; - } - const pointers: []PositionPin = pointer_positions orelse &.{}; - const n = 2 * nspans + npositions + pointers.len; - // On the stack, as the local path never allocated here but for the - // pointer's rows. - var rows_buf: [512]i32 = undefined; - var erased_buf: [512]bool = undefined; - const rows_after = if (n <= rows_buf.len) rows_buf[0..n] else pane.gpa.alloc(i32, n) catch return true; - defer if (n > rows_buf.len) pane.gpa.free(rows_after); - const erased_after = if (n <= erased_buf.len) erased_buf[0..n] else pane.gpa.alloc(bool, n) catch return true; - defer if (n > erased_buf.len) pane.gpa.free(erased_after); - @memset(rows_after, 0); - @memset(erased_after, false); - if (!replica) { - var k: usize = 0; - for (spans[0..nspans]) |span| for ([_]RowPin{ span.start, span.end }) |rp| { - rows_after[k] = pinnedRow(alive, rp); - erased_after[k] = alive != null and rp.pin != null and rp.pin.?.garbage; - k += 1; - }; - for ([_][]PositionPin{ positions[0..npositions], pointers }) |batch| for (batch) |position| { - rows_after[k] = pinnedRow(alive, position.row); - erased_after[k] = alive != null and position.row.pin != null and position.row.pin.?.garbage; - k += 1; - }; - } - const after = pardes.tape.value(.positions, told, .{Told{ .rows = rows_after, .erased = erased_after, .cleared = cleared, .alive = alive != null, .failed = failed }}); - if (after.rows.len != n or after.erased.len != n) return false; // a replica its authority's states apart (diverged) - failed = after.failed; - const at_position = 2 * nspans; - const at_pointer = at_position + npositions; - var moved = false; - var pointer_rows_lost = !after.alive or pointer_positions == null; - for (0..pointers.len) |i| if (after.erased[at_pointer + i]) { - pointer_rows_lost = true; + var room: [512]RowPin = undefined; + const pins = if (track.len <= room.len) room[0..track.len] else state.gpa.alloc(RowPin, track.len) catch { + ingest(state, bytes); + @memcpy(rows[0..track.len], track); + @memset(erased[0..track.len], false); + return .{ .rows = rows[0..track.len], .erased = erased[0..track.len], .cleared = false, .alive = true, .failed = true }; }; - // The program cleared the screen, or the rows the live copy stood on are - // gone (pruned, a reset): the copy goes with them, as what the program - // drew next. Kept, ghostty would move its rows to the top of what is - // left, over the program's new text. - var copy_lost = after.cleared or !after.alive; - for (spans[0..nspans], 0..) |span, i| { - if (span.overlay == overlay and after.erased[2 * i]) copy_lost = true; - const start = after.rows[2 * i]; - const rows = @max(1, after.rows[2 * i + 1] -| start +| 1); - moved = moved or start != span.overlay.row or rows != span.overlay.rows; - span.overlay.row = start; - span.overlay.rows = rows; - if (alive) |owner| { - if (span.start.pin) |pin| owner.untrackPin(pin); - if (span.end.pin) |pin| owner.untrackPin(pin); - } + defer if (track.len > room.len) state.gpa.free(pins); + for (pins, track) |*pin, row| pin.* = trackRow(pages, row, &failed); + // Whether the program cleared the screen (ED 2, a switch of screens); + // pardes reads the flag nowhere else. + state.vt.flags.dirty.clear = false; + ingest(state, bytes); + const cleared = state.vt.flags.dirty.clear; + // RIS can destroy the alternate screen and every pin it owned. + const alive: ?*ghostty_vt.PageList = if (screens.generation(key) == generation) pages else null; + for (pins, rows[0..track.len], erased[0..track.len]) |pin, *row, *gone| { + row.* = pinnedRow(alive, pin); + gone.* = alive != null and pin.pin != null and pin.pin.?.garbage; + if (alive) |owner| if (pin.pin) |held| owner.untrackPin(held); } - // The rule above for the copy holds for the selections: one whose row - // is gone (ED 3 erased its history row, which ghostty flags `garbage`) - // goes too, rather than being clamped to the top. - const erased = after.erased[at_position..]; - const vsel_lost = if (vsel_at) |i| - erased[i] or (copy_lost and positions[i].edit_row != null) - else - false; - var sels_keep: [panes.Text.max_selections]bool = undefined; - for (0..pane.body.nsel) |i| sels_keep[i] = !(erased[sels_at + 2 * i] or erased[sels_at + 2 * i + 1]); - for ([_][]PositionPin{ positions[0..npositions], pointers }, [_]usize{ at_position, at_pointer }) |batch, first| for (batch, first..) |position, k| { - var row = after.rows[k]; - if (position.overlay) |edit| { - if (position.edit_row) |relative| { - row = edit.row +| relative; - } else if (row > edit.row) { - row = if (row < edit.row +| edit.rows) - edit.row - else - row -| edit.rows +| @as(i32, @intCast(modal.lineCount(edit.text))); - } - } - moved = moved or row != position.target.*; - position.target.* = row; - if (alive) |owner| if (position.row.pin) |pin| owner.untrackPin(pin); - }; - if (pointer_rows_lost) for (0..pane.sel.len) |button| { - pane.clearPointerSelection(button); - pane.sel[button].state = .none; - }; - if (vsel_lost) { - pane.body.vsel.active = false; - moved = true; - } - if (pane.body.nsel > 0) { - var kept: u16 = 0; - for (0..pane.body.nsel) |i| if (sels_keep[i]) { - pane.body.sels[kept] = pane.body.sels[i]; - kept += 1; - }; - if (kept != pane.body.nsel) { - moved = true; - if (kept == 0) pane.body.dropSels() else pane.body.nsel = kept; - } - } - if (copy_lost) if (pane.ovl) |copy| { - pane.gpa.free(copy.text); - pane.ovl = null; - moved = true; - }; - if (moved) pane.nsel_snap = 0; // Saved regex-preview offsets name the old flat text. - return failed; + return .{ .rows = rows[0..track.len], .erased = erased[0..track.len], .cleared = cleared, .alive = alive != null, .failed = failed }; } /// A full-screen program has the emulator on its alternate screen. @@ -1416,7 +1124,7 @@ pub fn enterTty(p: *Pardes, id: usize) void { } pane.body.mode = .tty; - followOutput(pane); // entering raw mode is a request for the live shell + pane.followOutput(); // entering raw mode is a request for the live shell pane.body.vsel.active = false; pane.body.nsel = 0; // The raw renderer follows the live cursor. A captured mouse selection @@ -1800,7 +1508,7 @@ const BodyWalk = struct { fn init(pane: *Pane) BodyWalk { const off = pane.scroll(); - const goff = gridOffset(pane); + const goff: i32 = @intCast(grid(pane.terminal).offset); return .{ .pane = pane, .goff = goff, @@ -2003,7 +1711,7 @@ pub fn recolorAnsi(p: *Pardes, s: *Surface, pane: *Pane, r: pardes.Rect, tx: u16 // path needs it per cell. const scnm = pane.terminal.?.vt.modes.get(.reverse_colors); const pages = &pane.terminal.?.vt.screens.active.pages; - const vp_rows: i32 = @intCast(scrollbar(pane).len); + const vp_rows: i32 = @intCast(grid(pane.terminal).len); // Which buffer lines the user has not actually changed, so a row swallowed // by a growing buffer keeps the colour it still stands over. var anchors: ?EditAnchors = null; @@ -2385,16 +2093,6 @@ pub fn undoStep(p: *Pardes, pane: *Pane, back: bool) error{OutOfMemory}!void { pane.ensureCursorVisible(); } -/// The emulator's size in pixels follows the shell's cells: kitty graphics -/// placements are sized by it, and CSI 14/16 t report it. -fn syncPixels(p: *const Pardes, pane: *Pane) void { - if (comptime !images_enabled) return; - const state = pane.terminal orelse return; - const vt = &state.vt; - vt.width_px = @as(u32, vt.cols) * p.view().cell_pixels.w; - vt.height_px = @as(u32, vt.rows) * p.view().cell_pixels.h; -} - /// When the pane's next kitty animation frame is due (ms on the core's /// clock), as its last drawn frame left it; null when nothing plays. pub fn due(state: *const State) ?u64 { @@ -2431,10 +2129,10 @@ pub fn drawImages(p: *Pardes, s: *Surface, pane: *Pane, id: usize, tx: u16, tw: if (comptime !images_enabled) return; const state = pane.terminal orelse return; const screen = state.vt.screens.active; - syncPixels(p, pane); + cellPixels(state, p.view().cell_pixels.w, p.view().cell_pixels.h); // A body taller than this draws its images on the rows that fit. var rows_of: [1024]?u16 = undefined; - const vp_rows: usize = @min(scrollbar(pane).len, rows_of.len); + const vp_rows: usize = @min(grid(state).len, rows_of.len); @memset(rows_of[0..vp_rows], null); var any_placeholder = false; var walk: BodyWalk = .init(pane); @@ -2522,7 +2220,7 @@ test "a terminal made fresh has no size waiting: one never resized keeps its gri @memset(ptr[0..len], 0xAA); return ptr; } - fn resize(ctx: *anyopaque, buf: []u8, a: std.mem.Alignment, n: usize, ra: usize) bool { + fn grow(ctx: *anyopaque, buf: []u8, a: std.mem.Alignment, n: usize, ra: usize) bool { const self: *@This() = @ptrCast(@alignCast(ctx)); return self.child.rawResize(buf, a, n, ra); } @@ -2534,7 +2232,7 @@ test "a terminal made fresh has no size waiting: one never resized keeps its gri const self: *@This() = @ptrCast(@alignCast(ctx)); self.child.rawFree(buf, a, ra); } - const vtable: std.mem.Allocator.VTable = .{ .alloc = alloc, .resize = resize, .remap = remap, .free = free }; + const vtable: std.mem.Allocator.VTable = .{ .alloc = alloc, .resize = grow, .remap = remap, .free = free }; }; var filling: Filling = .{ .child = std.testing.allocator }; const gpa: std.mem.Allocator = .{ .ptr = &filling, .vtable = &Filling.vtable }; @@ -2555,16 +2253,14 @@ test "document construction allocates only the pane and has inert terminal defau try std.testing.expectEqual(@as(usize, 0), failing.resize_index); try std.testing.expect(!failing.has_induced_failure); try std.testing.expectEqual(@as(usize, @sizeOf(Pane)), failing.allocated_bytes); - try std.testing.expectEqual(GridCursor{}, gridCursor(pane)); - try std.testing.expectEqual(Scrollbar{}, scrollbar(pane)); + try std.testing.expectEqual(Term.Grid{}, grid(pane.terminal)); try std.testing.expect(!bracketedPaste(pane)); try std.testing.expect(!reportsMouse(pane)); try std.testing.expect(!promptInputReady(pane)); - scrollGrid(pane, 100); - followOutput(pane); - resizeGrid(pane, 80, 24); - try std.testing.expectEqual(GridCursor{}, gridCursor(pane)); - try std.testing.expectEqual(Scrollbar{}, scrollbar(pane)); + pane.scrollBy(100); + pane.followOutput(); + pane.resizeGrid(80, 24); + try std.testing.expectEqual(Term.Grid{}, grid(pane.terminal)); try std.testing.expectEqualStrings("", try screenTextAlloc(pane, allocator)); try std.testing.expect(!failing.has_induced_failure); } @@ -2581,14 +2277,14 @@ test "terminal state keeps parser fragments and sends emulator replies through i if (effect == .write) return error.PrematureTerminalReply; } p.update(.{ .output = .{ .pane = 0, .bytes = "6n" } }); - var replies: usize = 0; + var answers: usize = 0; while (p.nextEffect()) |effect| { if (effect != .write) continue; try std.testing.expectEqual(@as(u8, 0), effect.write.pane); try std.testing.expectEqualStrings("\x1b[1;1R", effect.write.bytes.slice()); - replies += 1; + answers += 1; } - try std.testing.expectEqual(@as(usize, 1), replies); + try std.testing.expectEqual(@as(usize, 1), answers); try std.testing.expectEqual(@as(u16, 0), state.reply_len); } @@ -2598,12 +2294,12 @@ test "a terminal's dump restores the cells it drew, its history and where its vi defer p.deinit(); while (p.nextEffect()) |_| {} const pane = p.panes[0].?; - feedOutput(p, pane, "\x1b[31mred\x1b[0m\r\ncafé\r\n"); + pane.feedOutput(p, "\x1b[31mred\x1b[0m\r\ncafé\r\n"); for (0..30) |i| { var line: [16]u8 = undefined; - feedOutput(p, pane, std.fmt.bufPrint(&line, "line {d}\r\n", .{i}) catch unreachable); + pane.feedOutput(p, std.fmt.bufPrint(&line, "line {d}\r\n", .{i}) catch unreachable); } - scrollGrid(pane, -5); + scroll(pane.terminal.?, -5); const bytes = try pardes.walk.save(State, gpa, pane.terminal.?); defer gpa.free(bytes); var arena: std.heap.ArenaAllocator = .init(gpa); @@ -2627,7 +2323,7 @@ test "a restored command pane comes back finished, its command not run again" { while (p.nextEffect()) |_| {} const cmd = p.freeSlot().?; _ = try panes.newCommand(p, cmd, "/tmp", "make test"); - feedOutput(p, p.panes[cmd].?, "ok\r\n"); + p.panes[cmd].?.feedOutput(p, "ok\r\n"); p.update(.{ .exited = .{ .pane = @intCast(cmd), .status = 2 } }); try pardes.dump.dumpState(p); const restored = try pardes.dump.initFromDump(gpa, .{ .tty_only = true, .cols = 60, .rows = 16 }, p.dump_out.?); @@ -2656,7 +2352,7 @@ test "a restored terminal keeps its history above a marker and gets a shell wher defer p.deinit(); while (p.nextEffect()) |_| {} const pane = p.panes[0].?; - feedOutput(p, pane, "old output\r\n$ ls\r\n"); + pane.feedOutput(p, "old output\r\n$ ls\r\n"); try pane.setOwnedCwd("/tmp"); pane.shell = try gpa.dupe(u8, "bash"); // `Term bash`: it comes back as bash try pardes.dump.dumpState(p); @@ -2684,19 +2380,19 @@ test "a position that cannot follow the output for want of memory is said on the const p = try Pardes.init(failing.allocator(), .{ .tty_only = true, .cols = 80, .rows = 24 }); defer p.deinit(); const pane = p.panes[0].?; - feedOutput(p, pane, "one\r\ntwo\r\n"); + pane.feedOutput(p, "one\r\ntwo\r\n"); // More positions than the emulator's pins have room for: following them // through the output needs memory, and there is none. try std.testing.expect(pane.body.reserveSels()); for (pane.body.sels[0..8], 0..) |*range, i| range.* = .{ .row = @intCast(i), .col = 0, .arow = @intCast(i), .acol = 1 }; pane.body.nsel = 8; failing.fail_index = failing.alloc_index; - feedOutput(p, pane, "three\r\n"); + pane.feedOutput(p, "three\r\n"); failing.fail_index = std.math.maxInt(usize); try std.testing.expect(failing.has_induced_failure); - try std.testing.expectEqualStrings(positions_lost, pane.msg[0..pane.msg_len]); + try std.testing.expectEqualStrings(panes.positions_lost, pane.msg[0..pane.msg_len]); const logged = p.messages.at(p.messages.len -| 1) orelse return error.NothingLogged; - try std.testing.expectEqualStrings(positions_lost, logged.slice()); + try std.testing.expectEqualStrings(panes.positions_lost, logged.slice()); } test "raw terminal output needs no position tracking allocations" { @@ -2705,11 +2401,11 @@ test "raw terminal output needs no position tracking allocations" { defer p.deinit(); const pane = p.panes[0].?; pane.body.mode = .tty; - feedOutput(p, pane, "warm"); + pane.feedOutput(p, "warm"); const allocations = failing.alloc_index; failing.fail_index = allocations; const pins = pane.terminal.?.vt.screens.active.pages.countTrackedPins(); - feedOutput(p, pane, " output"); + pane.feedOutput(p, " output"); try std.testing.expectEqual(allocations, failing.alloc_index); try std.testing.expect(!failing.has_induced_failure); try std.testing.expectEqual(pins, pane.terminal.?.vt.screens.active.pages.countTrackedPins()); |
