//! A terminal: its VT emulator, the OSC 133 cycle its shell marks, its //! text, its view as cells, and the Filter that recolours output to the //! theme. The core reaches it through src/term/term.zig's `ops`. const std = @import("std"); const plain = @import("plain"); const Key = plain.Key; const Term = plain.term; const screen_state = @import("screen_state.zig"); const ghostty_vt = @import("ghostty-vt"); const Ink = plain.term.Ink; const FilterPalette = plain.term.FilterPalette; const Filter = plain.term.Filter; const Painted = plain.term.Painted; const PaintedRow = plain.term.PaintedRow; const ImagesAt = plain.term.ImagesAt; const PromptCut = plain.term.PromptCut; pub const VtSlot = ghostty_vt.Terminal; /// A cell of an emulator's pages, as `getCell` reads it (src/term/echo.zig). pub const PageCell = ghostty_vt.PageList.Cell; /// Kitty graphics: a program's images are placements, as a kind's are. pub const images_enabled = true; pub const TerminalImages = if (images_enabled) @import("TerminalImages.zig") else void; pub const StreamSlot = ghostty_vt.Stream(MarkedHandler); /// The `aid` pardes's injected bash and fish marks carry (host_io.zig). pub const prompt_aid = "pardes"; /// ghostty's handler, plus where the shell is in its command cycle as /// its OSC 133 marks tell it: ghostty parses D's exit status and drops /// it, and /pane//pty/run waits on exactly that. Only marks carrying /// pardes's own `aid` move it, so fish's native marks, a nested shell's /// and a stray `133;D` in some file being printed all pass it by. pub const MarkedHandler = struct { inner: ghostty_vt.TerminalStream.Handler, phase: Term.Prompt.Phase = .none, /// Counts commands started (C at the input phase). started: u32 = 0, /// Counts prompts drawn (B), so a line the shell refused without /// running (a fish syntax error: no C, no D, a new prompt) shows. prompts: u32 = 0, /// D marks outside a running command: the shell handled a line /// without starting it (bash on a syntax error prints no C). declined: u32 = 0, /// The newest prompt continues an unfinished line (bash's PS2, marked /// `k=c`): the shell still holds the start of the command. continuation: bool = false, /// Where the newest command's output began (its C) and ended (its /// D) on the primary screen, pinned so scrolling keeps them. out_start: ?*ghostty_vt.Pin = null, out_end: ?*ghostty_vt.Pin = null, /// The running command's output was erased under it -- a clear, ED 3, /// a reset -- so the pins no longer span what it printed. ED 3 flags a /// pin on an erased history row `garbage` (ghostty 1.4), but `pinTop` /// re-pins the start at the screen's top, so the flag is gone with the /// old pin: this remembers it, as it does for a reset or a pin that /// could not be made. lost: bool = false, /// The newest command to end: which one, and its status if given. finished: ?Term.Prompt.Finished = null, const Action = ghostty_vt.TerminalStream.Action; /// Move one of the output pins to the cursor. Only the primary screen /// is pinned: a command's own full-screen display is not its output. fn pinCursor(self: *@This(), slot: *?*ghostty_vt.Pin, now: bool) void { const screen = self.inner.terminal.screens.get(.primary) orelse return; if (slot.*) |old| screen.pages.untrackPin(old); slot.* = null; if (!now or self.inner.terminal.screens.active_key != .primary) return; slot.* = screen.pages.trackPin(screen.cursor.page_pin.*) catch null; } pub fn vt(self: *@This(), comptime action: Action.Tag, value: Action.Value(action)) void { if (comptime action == .semantic_prompt) mark: { const aid = value.readOption(.aid) orelse break :mark; if (!std.mem.eql(u8, aid, prompt_aid)) break :mark; switch (value.action) { .fresh_line_new_prompt => { self.phase = .prompt; self.continuation = value.readOption(.prompt_kind) == .continuation; }, .end_prompt_start_input => { self.phase = .input; self.prompts +%= 1; }, // bash's DEBUG trap also fires on its own PROMPT_COMMAND, // outside the input phase; only a C that ends input counts .end_input_start_output => if (self.phase == .input) { self.phase = .running; self.started +%= 1; self.lost = false; self.pinCursor(&self.out_start, true); self.pinCursor(&self.out_end, false); }, .end_command => if (self.phase == .running) { self.phase = .none; self.finished = .{ .seq = self.started, .status = value.readOption(.exit_code) }; self.pinCursor(&self.out_end, true); } else { self.declined +%= 1; }, else => {}, } } if (comptime action == .erase_display_complete or action == .erase_display_scrollback or action == .erase_display_scroll_complete or action == .full_reset) { self.inner.vt(action, value); // A `clear` under a running command: its output is what it // prints from here, the screen's top, not lost. Only what the // scrollback later loses is (the pin goes `garbage`). if (self.phase == .running) self.pinTop(&self.out_start); return; } self.inner.vt(action, value); } /// Pins `slot` to the primary screen's top-left; lost when it cannot be. fn pinTop(self: *@This(), slot: *?*ghostty_vt.Pin) void { const screen = self.inner.terminal.screens.get(.primary) orelse return; if (slot.*) |old| screen.pages.untrackPin(old); slot.* = null; if (self.inner.terminal.screens.active_key != .primary) { self.lost = true; return; } const top = screen.pages.pin(.{ .active = .{} }) orelse { self.lost = true; return; }; slot.* = screen.pages.trackPin(top) catch null; if (slot.* == null) self.lost = true; } pub fn deinit(self: *@This()) void { self.inner.deinit(); } }; fn ptyReport(handler: *ghostty_vt.TerminalStream.Handler, data: []const u8) void { const state: *State = @alignCast(@fieldParentPtr("vt", handler.terminal)); const room = state.reply.len - state.reply_len; // A cut answer is worse than none: the program would read the start of // a sequence and wait, or misparse what follows. if (data.len > room) { state.reply_dropped +|= 1; return; } @memcpy(state.reply[state.reply_len..][0..data.len], data); state.reply_len += @intCast(data.len); } fn ptyDeviceAttrs(_: *ghostty_vt.TerminalStream.Handler) ghostty_vt.device_attributes.Attributes { return .{}; } /// CSI 14/16/18 t: the pane's size, and its cells' in pixels, which a /// program sizes its kitty graphics by (yazi asks 16 t). Unknown, not asked. fn ptySize(handler: *ghostty_vt.TerminalStream.Handler) ?ghostty_vt.size_report.Size { const t = handler.terminal; if (t.width_px == 0 or t.height_px == 0 or t.cols == 0 or t.rows == 0) return null; return .{ .rows = t.rows, .columns = t.cols, .cell_width = t.width_px / t.cols, .cell_height = t.height_px / t.rows }; } pub const State = struct { /// What the emulator and this struct are allocated with: the core's, /// but on a screen-state replica the C heap (`emulator_gpa`), outside /// its rollback epoch: written by deltas while a copy is held, no part /// of it is ever a copy's to save or put back. gpa: std.mem.Allocator, vt: VtSlot, stream: StreamSlot, /// The emulator's answers to its program (DSR, DA, kitty graphics, ...) /// from one read of its output, written to its pty after it. Room for /// a read's worth of kitty answers (yazi or `kitten icat` asking about /// a batch of images in one write); an answer that does not fit whole /// is dropped whole, never cut short (`reply_dropped` counts them). reply: [4096]u8 = undefined, reply_len: u16 = 0, reply_dropped: u32 = 0, /// The grid cell the program last heard the mouse at, so motion is /// reported once per cell. mouse_cell: ?ghostty_vt.Coordinate = null, /// The kitty graphics its program placed, as drawn (TerminalImages.zig). images: TerminalImages = if (images_enabled) .{} else {}, /// Counts the emulator's writes (output, a resize, its view scrolled): /// a new count is a new state for its replicas (screen_state.Track). changes: u32 = 0, /// A step read its rows (its history too): a replica replaying that /// step must hold them, so its authority sends the ones it does not /// before the step's unit (replica.Screens.fill). read: bool = false, /// The size a step gave it, on an authority with screen-state replicas: /// made after the step's unit (`resizeDeferred`), so that the rest of /// the step reads the grid it had, as its replicas' replays do, and the /// rows sent them for it (Screens.fill) are of that grid's numbering. resize_to: ?struct { cols: u16, rows: u16 } = null, /// The stream over the emulator, its answers to the program and its /// size reports routed here, PNG decoded: what `create` and a dump's /// load both do once the emulator is in place. fn wire(s: *State) void { s.stream = .init(.{ .handler = .{ .inner = s.vt.vtHandler() }, .allocator = s.gpa }); s.stream.handler.inner.effects.write_pty = ptyReport; s.stream.handler.inner.effects.device_attributes = ptyDeviceAttrs; s.stream.handler.inner.effects.size = ptySize; if (comptime images_enabled) TerminalImages.installPngDecoder(); } }; /// The emulator as its program has made it, for the replay digest (the /// core's Term.State.digest, src/walk.zig): the active screen's text, how /// much history is above it and, with `view`, where the view is, the /// cursor, the answers not yet written. Not its pages (their addresses are /// its own), nor the history's text (the screen's was all of it once, and /// a session's digest is taken every step), nor the kitty images, whose /// media is read off the host. pub fn digest(s: *const State, h: *std.hash.Wyhash, view: bool) void { const screen = s.vt.screens.active; const sb = screen.pages.scrollbar(); const cur = screen.cursor; const offset = if (view) sb.offset else 0; const facts = .{ sb.total, offset, sb.len, cur.x, cur.y, s.vt.modes.get(.cursor_visible), s.vt.screens.active_key, s.reply_dropped }; inline for (facts) |fact| h.update(std.mem.asBytes(&fact)); h.update(s.reply[0..s.reply_len]); var buf: [4096]u8 = undefined; var text: std.Io.Writer.Hashing(std.hash.Wyhash) = .initHasher(h.*, &buf); if (screen.pages.getBottomRight(.active)) |br| screen.dumpString(&text.writer, .{ .tl = screen.pages.getTopLeft(.active), .br = br, .unwrap = false }) catch unreachable; // a hashing writer never fails text.writer.flush() catch unreachable; // a hashing writer never fails h.* = text.hasher; } fn pinAt(s: *const State, slot: ?*ghostty_vt.Pin) ?Term.Parts.Coordinate { const pin = slot orelse return null; const screen = s.vt.screens.get(.primary) orelse return null; const at = (screen.pages.pointFromPin(.screen, pin.*) orelse return null).screen; return .{ .x = at.x, .y = at.y }; } fn coordinate(at: ?Term.Parts.Coordinate) ?ghostty_vt.Coordinate { const c = at orelse return null; return .{ .x = c.x, .y = c.y }; } /// What the dump keeps of it beside its emulator (the core's /// Term.State.dumpWrite writes it by name, as every dump is). pub fn parts(s: *const State) Term.Parts { const h = &s.stream.handler; return .{ .reply = s.reply[0..s.reply_len], .reply_dropped = s.reply_dropped, .mouse_cell = if (s.mouse_cell) |c| .{ .x = c.x, .y = c.y } else null, .petscii = if (comptime images_enabled) s.images.petscii else false, .view = s.vt.screens.active.pages.scrollbar().offset, .phase = h.phase, .started = h.started, .prompts = h.prompts, .declined = h.declined, .continuation = h.continuation, .lost = h.lost, .finished = h.finished, .out_start = pinAt(s, h.out_start), .out_end = pinAt(s, h.out_end), }; } /// Its emulator as the dump keeps it: ghostty's snapshot (both screens, /// their history, styles, links and kitty images). A sequence its program /// had begun and not ended is not kept: the snapshot is at the ground /// state. `slim`, a join's dump (dump.zig `dumpJoin`): its size alone, an /// emulator made afresh there, which its first delta replaces. pub fn snapshot(s: *const State, gpa: std.mem.Allocator, w: *std.Io.Writer, slim: bool) !void { if (slim) return w.writeAll(std.mem.asBytes(&[2]u16{ s.vt.cols, s.vt.rows })); try ghostty_vt.snapshot.encode(gpa, w, &s.vt, .{ .continuation = .ground }); } /// `snapshot`'s bytes and `parts` back into a new terminal, as `open` /// makes one. pub fn load(gpa: std.mem.Allocator, bytes: []const u8, saved: *const Term.Parts) !*State { const out = try gpa.create(State); errdefer gpa.destroy(out); var reader: std.Io.Reader = .fixed(bytes); if (reader.buffer.len == 4) { const size = std.mem.bytesToValue([2]u16, bytes[0..4]); out.* = .{ .gpa = gpa, .vt = try emulator(gpa, @max(1, size[0]), @max(1, size[1])), .stream = undefined }; } else { var decoded = try ghostty_vt.snapshot.decodeExact(gpa, terminalIo(), &reader, .{ .max_continuation_bytes = 0, .kitty_image_storage_limit = if (images_enabled) TerminalImages.storage_limit else 0, }); defer decoded.deinit(gpa); out.* = .{ .gpa = gpa, .vt = decoded.toOwned(), .stream = undefined }; } if (comptime images_enabled) inline for (.{ .primary, .alternate }) |which| { if (out.vt.screens.get(which)) |screen| screen.kitty_images.image_limits = .allWithTempDir(tempDir()); }; out.wire(); const reply = saved.reply[0..@min(saved.reply.len, out.reply.len)]; @memcpy(out.reply[0..reply.len], reply); out.reply_len = @intCast(reply.len); out.reply_dropped = saved.reply_dropped; out.mouse_cell = coordinate(saved.mouse_cell); out.images = if (images_enabled) .{ .petscii = saved.petscii } else {}; const h = &out.stream.handler; h.phase = saved.phase; h.started = saved.started; h.prompts = saved.prompts; h.declined = saved.declined; h.continuation = saved.continuation; h.lost = saved.lost; h.finished = saved.finished; if (out.vt.screens.get(.primary)) |screen| { inline for (.{ .{ "out_start", saved.out_start }, .{ "out_end", saved.out_end } }) |pair| if (coordinate(pair[1])) |at| { if (screen.pages.pin(.{ .screen = at })) |pin| @field(h, pair[0]) = screen.pages.trackPin(pin) catch null; }; } const screen = out.vt.screens.active; const bottom = screen.pages.scrollbar().offset; screen.scroll(.{ .delta_row = @as(isize, @intCast(saved.view)) - @as(isize, @intCast(bottom)) }); return out; } /// The allocator it was opened with, its own from then on. pub fn gpaOf(s: *const State) std.mem.Allocator { return s.gpa; } const GColor = ghostty_vt.color; // Projected colors below this contrast use the theme's more legible anchor. pub const min_contrast: f64 = 1.5; /// The theme's 256 colours as the filter maps onto them (ghostty's /// `generate256Color` over the theme's sixteen), made again only when the /// theme's are not the ones `cache` was made of. pub fn filterPalette(cache: *FilterPalette, ink: *const Ink) *const [256][3]u8 { const wanted: FilterPalette.Key = .{ .bg = ink.bg orelse ink.tag_bg, .fg = ink.fg orelse ink.tag_fg, .base = ink.base }; if (cache.key) |old| if (std.meta.eql(old, wanted)) return &cache.colors; var seed = GColor.default; for (ink.base, 0..) |rgb, i| seed[i] = asGhostRgb(rgb); const colors = GColor.generate256Color(seed, .empty, asGhostRgb(wanted.bg), asGhostRgb(wanted.fg), false); for (&cache.colors, colors) |*dst, src| dst.* = asTriple(src); cache.key = wanted; return &cache.colors; } pub fn asGhostRgb(rgb: [3]u8) GColor.RGB { return .{ .r = rgb[0], .g = rgb[1], .b = rgb[2] }; } /// Where a kitty client puts its temporary files: `$TMPDIR`, else /tmp /// (which ghostty accepts whatever this says). The environment block lives /// as long as the process and pardes never edits it (ChildEnv.exportVar). fn tempDir() []const u8 { const dir = std.c.getenv("TMPDIR") orelse return "/tmp"; const path = std.mem.span(dir); return if (path.len > 0 and path[0] == '/') path else "/tmp"; } pub fn terminalIo() std.Io { return std.Io.Threaded.global_single_threaded.io(); } /// 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, .cols = screen.pages.cols, }; } /// What pardes made of a terminal's stream that its emulator does not hold /// (the OSC 133 cycle, MarkedHandler), for a replica's delta: phase u8, /// started, prompts, declined u32, continuation and lost u8, a finished /// command's seq u32 and status i32 (all ones: none; i32 min: no status). // ponytail: the output pins stay the authority's (its 9P pty/run reads them). pub const marks_len = 1 + 4 * 3 + 2 + 4 + 4; pub fn marksOf(state: *const State, buf: *[marks_len]u8) []const u8 { const m = &state.stream.handler; var w: std.Io.Writer = .fixed(buf); w.writeByte(@backingInt(m.phase)) catch unreachable; inline for (.{ m.started, m.prompts, m.declined }) |n| w.writeInt(u32, n, .little) catch unreachable; w.writeAll(&.{ @intFromBool(m.continuation), @intFromBool(m.lost) }) catch unreachable; w.writeInt(u32, if (m.finished) |f| f.seq else std.math.maxInt(u32), .little) catch unreachable; w.writeInt(i32, if (m.finished) |f| f.status orelse std.math.minInt(i32) else 0, .little) catch unreachable; return w.buffered(); } /// A replica's terminal takes its authority's marks (`marksOf`). pub fn takeMarks(state: *State, bytes: []const u8) void { if (bytes.len != marks_len) return; const m = &state.stream.handler; m.phase = @fromBackingInt(@intCast(bytes[0])); m.started = std.mem.readInt(u32, bytes[1..5], .little); m.prompts = std.mem.readInt(u32, bytes[5..9], .little); m.declined = std.mem.readInt(u32, bytes[9..13], .little); m.continuation = bytes[13] != 0; m.lost = bytes[14] != 0; const seq = std.mem.readInt(u32, bytes[15..19], .little); const status = std.mem.readInt(i32, bytes[19..23], .little); m.finished = if (seq == std.math.maxInt(u32)) null else .{ .seq = seq, .status = if (status == std.math.minInt(i32)) null else status }; } // ---- its replicas: the screen state they are sent (screen_state.zig) ---- /// What `peer` is owed of it, a delta against what it was sent (with the /// marks of its prompt cycle), onto `out`; false when it has it already. pub fn encode(state: *State, enc: *screen_state.Encoder, tr: *screen_state.Track, peer: *screen_state.Peer, out: *std.Io.Writer) !bool { var marks: [marks_len]u8 = undefined; return screen_state.encode(enc, tr, peer, &state.vt, state.changes, marksOf(state, &marks), out); } /// Its rows `lo` to `hi` (absolute), as a replica holding them as holes /// is sent them. pub fn encodeRows(state: *State, enc: *screen_state.Encoder, tr: *screen_state.Track, lo: u64, hi: u64, out: *std.Io.Writer) !void { return screen_state.encodeRows(enc, tr, &state.vt, lo, hi, out); } /// What a session's authority keeps to encode its terminals for its /// peers, and what it keeps of one terminal for them: made and freed. pub fn encoder(gpa: std.mem.Allocator) !*screen_state.Encoder { const e = try gpa.create(screen_state.Encoder); e.* = .init(gpa); return e; } pub fn encoderFree(e: *screen_state.Encoder) void { const gpa = e.gpa; e.deinit(); gpa.destroy(e); } pub fn track(gpa: std.mem.Allocator) !*screen_state.Track { const t = try gpa.create(screen_state.Track); t.* = .init(gpa); return t; } /// A replica's side of one terminal: made, freed, where its active area /// begins, and the history rows `lo..hi` it does not hold. pub fn replica(gpa: std.mem.Allocator) !*screen_state.Replica { const r = try gpa.create(screen_state.Replica); r.* = .{}; return r; } pub fn replicaFree(r: *screen_state.Replica, gpa: std.mem.Allocator) void { r.deinit(gpa); gpa.destroy(r); } pub fn replicaTop(r: *const screen_state.Replica) u64 { return r.top; } pub fn missing(r: *const screen_state.Replica, lo: u64, hi: u64, out: *std.ArrayList([2]u64), gpa: std.mem.Allocator) !void { return r.missing(lo, hi, out, gpa); } /// What `track` kept of its versions, freed; `state` null when its pane is /// gone with the emulator. /// A peer's track of it let go, and freed (`state` null: it is gone). pub fn untrack(t: *screen_state.Track, gpa: std.mem.Allocator, state: ?*State) void { t.deinit(gpa, if (state) |s| &s.vt else null); gpa.destroy(t); } /// Whether a step read its rows since `clearRead` (`markRead`). pub fn wasRead(state: *const State) bool { return state.read; } pub fn clearRead(state: *State) void { state.read = false; } /// A replica's terminal takes its authority's delta (and the marks riding /// it); error.BaseMismatch when it is against a state not held here. pub fn apply(state: *State, rep: *screen_state.Replica, bytes: []const u8) !Term.Applied { const applied = try rep.apply(state.gpa, terminalIo(), &state.vt, bytes); takeMarks(state, applied.extra); return applied; } /// ...and rows it asked for. pub fn applyRows(state: *State, rep: *screen_state.Replica, bytes: []const u8) !void { return rep.applyRows(state.gpa, &state.vt, bytes); } /// The absolute rows its view shows on a replica. pub fn shown(state: *State, rep: *const screen_state.Replica) [2]u64 { return rep.shown(&state.vt); } /// Its screen as text, every row's cells and flags (the replica tests /// compare an authority's and a replica's). pub fn dumpScreen(state: *State, w: *std.Io.Writer) !void { return screen_state.dumpScreen(&state.vt, w); } /// Rows `lo` to `hi` shown blank on a replica until they come. pub fn blank(state: *State, rep: *const screen_state.Replica, lo: u64, hi: u64) void { rep.blank(&state.vt, lo, hi); } /// 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); } /// 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; } /// 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); } /// 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; } state.changes +%= 1; state.vt.resize(state.gpa, .{ .cols = cols, .rows = 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]; } /// The modes its program set that the core decides by (`Term.Modes`). pub fn modes(state: ?*const State) Term.Modes { const s = state orelse return .{}; const alternate = s.vt.screens.active_key == .alternate; const mouse_event = s.vt.flags.mouse_event != .none; return .{ .mouse = mouse_event, .all_motion = s.vt.flags.mouse_event == .any, // On the alternate screen, which has no scrollback, alternate // scroll (DECSET 1007, on unless turned off) asks for arrow keys. .wheel = mouse_event or (alternate and s.vt.modes.get(.mouse_alternate_scroll)), .focus = s.vt.modes.get(.focus_event), .bracketed_paste = s.vt.modes.get(.bracketed_paste), .alternate = alternate, }; } /// A paste as xterm makes one (ghostty's encoder): the control bytes a /// paste could smuggle a command in by (ESC, so no ESC[201~ can end /// 2004's brackets early, NUL, ^C and the rest of xterm's list) become /// spaces, then the text goes inside the brackets when the program set /// 2004, else with its newlines as Returns. `text` is rewritten in place. pub fn paste(state: ?*const State, text: []u8) [3][]const u8 { return ghostty_vt.input.encodePaste(text, .{ .bracketed = modes(state).bracketed_paste }); } /// One mouse event for the program, as xterm reports it (ctlseqs; ghostty's /// encoder): the tracking mode it set (1000 clicks, 1002 drags, 1003 all /// motion) decides whether it hears of it, the format it set (1006 SGR, /// 1015 urxvt, 1005 UTF-8, else X10) how, modifiers as shift+4, meta+8, /// ctrl+16. `col`,`row` are the 0-based grid cell; a drag that left the /// grid is reported clamped to its edge, motion only when the cell /// changed. Empty when the program does not hear of it. pub fn mouse(state: *State, buf: *[64]u8, action: Term.MouseAction, button: ?Term.MouseButton, mods: Term.MouseMods, col: i32, row: i32, any_pressed: bool) []const u8 { const input = ghostty_vt.input; var writer = std.Io.Writer.fixed(buf); var opts: input.MouseEncodeOptions = .{ .event = state.vt.flags.mouse_event, .format = state.vt.flags.mouse_format, .size = .{ .screen = .{ .width = state.vt.cols, .height = state.vt.rows }, .cell = .{ .width = 1, .height = 1 }, .padding = .{}, }, .any_button_pressed = any_pressed, .last_cell = &state.mouse_cell, }; // A release is always reported; the rest only over the grid, or held. if (action == .release) opts.any_button_pressed = true; input.encodeMouse(&writer, .{ .action = switch (action) { .press => .press, .release => .release, .motion => .motion, }, .button = if (button) |b| switch (b) { .left => .left, .middle => .middle, .right => .right, .wheel_up => .four, .wheel_down => .five, .wheel_left => .six, .wheel_right => .seven, } else null, .mods = .{ .shift = mods.shift, .alt = mods.alt, .ctrl = mods.ctrl }, .pos = .{ .x = @as(f32, @floatFromInt(col)) + 0.5, .y = @as(f32, @floatFromInt(row)) + 0.5 }, }, opts) catch return &.{}; // no report rather than half of one return writer.buffered(); } /// The bytes a wheel turn at grid cell `col`,`row` (0-based) sends the /// program: its mouse report while it tracks the mouse, else, on the /// alternate screen, an arrow key in the cursor keys' mode (none for a /// sideways turn). Null when the wheel is not the program's (`Modes.wheel`). pub fn wheel(state: *State, buf: *[64]u8, turn: Term.MouseButton, col: u16, row: u16, mods: Term.MouseMods) ?[]const u8 { const now = modes(state); if (!now.wheel) return null; const m = &state.vt.modes; if (!now.mouse) return switch (turn) { .wheel_up => if (m.get(.cursor_keys)) "\x1bOA" else "\x1b[A", .wheel_down => if (m.get(.cursor_keys)) "\x1bOB" else "\x1b[B", else => null, }; return mouse(state, buf, .press, turn, mods, col, row, false); } /// The whole scrollback as plain text, `gpa`-owned: what a terminal's body /// reads and `Save` writes out. Logical lines: rows the terminal wrapped /// are joined again (ghostty's wrap flags, as pty/run's output is), and /// the last line ends with a newline. pub fn scrollback(state: ?*State, gpa: std.mem.Allocator) ![]const u8 { var out: std.Io.Writer.Allocating = .init(gpa); errdefer out.deinit(); try writeBody(state, &out.writer); return out.toOwnedSlice(); } fn writeBody(maybe: ?*State, w: *std.Io.Writer) !void { const state = maybe orelse return; const screen = state.vt.screens.active; const br = screen.pages.getBottomRight(.screen) orelse return; var both: TeeWriter = .{ .a = w }; try screen.dumpString(&both.writer, .{ .tl = screen.pages.getTopLeft(.screen), .br = br, .unwrap = true }); if (both.count > 0 and both.final != '\n') try w.writeByte('\n'); } /// Passes bytes through, remembering how many and the last one. const TeeWriter = struct { a: *std.Io.Writer, count: usize = 0, final: u8 = 0, writer: std.Io.Writer = .{ .vtable = &.{ .drain = drain }, .buffer = &.{} }, fn drain(w: *std.Io.Writer, data: []const []const u8, splat: usize) std.Io.Writer.Error!usize { const t: *TeeWriter = @alignCast(@fieldParentPtr("writer", w)); var n: usize = 0; for (data[0 .. data.len - 1]) |bytes| { try t.a.writeAll(bytes); t.note(bytes); n += bytes.len; } const pattern = data[data.len - 1]; for (0..splat) |_| { try t.a.writeAll(pattern); t.note(pattern); n += pattern.len; } return n; } fn note(t: *TeeWriter, bytes: []const u8) void { if (bytes.len == 0) return; t.count += bytes.len; t.final = bytes[bytes.len - 1]; } }; /// How long `scrollback` would be, counted without keeping it: the length a /// terminal's body reads as, which its ctl line reports. pub fn scrollbackLen(state: ?*State) usize { var buf: [256]u8 = undefined; var counting: std.Io.Writer.Discarding = .init(&buf); writeBody(state, &counting.writer) catch unreachable; // a discarding writer never fails return @intCast(counting.fullCount()); } /// Its emulator and what it holds, freed; its kitty images' caches were /// `gpa`'s. pub fn close(state: *State, gpa: std.mem.Allocator) void { if (comptime images_enabled) state.images.deinit(gpa); state.stream.deinit(); const own = state.gpa; state.vt.deinit(own); own.destroy(state); } /// A terminal pane's emulator, `cols` by `rows`, as `open` makes one. fn emulator(gpa: std.mem.Allocator, cols: u16, rows: u16) !ghostty_vt.Terminal { return ghostty_vt.Terminal.init(terminalIo(), gpa, .{ .cols = cols, .rows = rows, .max_scrollback_bytes = 16 * 1024 * 1024, .kitty_image_storage_limit = if (images_enabled) TerminalImages.storage_limit else 0, // Every kitty medium, as ghostty and kitty take them: a file (t=f), // a temporary file it then deletes (t=t, in the temp directory and // named as one) and shared memory (t=s), beside direct data. libghostty // defaults to direct alone, which `kitten icat` and timg detect and // fall back from, base64 through the pty. What the program can read // it could send itself: it runs as the user, under pardes. .kitty_image_loading_limits = if (images_enabled) .allWithTempDir(tempDir()) else if (@FieldType(ghostty_vt.Terminal.Options, "kitty_image_loading_limits") == void) {} else .direct, }); } /// A new emulator, `cols` by `rows`, allocated with `gpa`, its own from /// then on (`State.gpa`). pub fn open(gpa: std.mem.Allocator, cols: u16, rows: u16) !*State { const state = try gpa.create(State); errdefer gpa.destroy(state); // Every other field its default, never what the heap had: a digest // reads them, and two replicas must agree (src/replica.zig). state.* = .{ .gpa = gpa, .vt = try emulator(gpa, cols, rows), .stream = undefined }; state.wire(); return state; } /// Where a restored terminal's history ends and its new shell begins. pub const restored_banner = "\x1b[0m\r\n\x1b[2m\u{2500}\u{2500} restored history \u{2500}\u{2500}\x1b[0m\r\n"; /// A terminal loaded from a dump, its shell not there, made ready for a /// new one: its program's screen modes reset (the old program is gone) and /// its history marked off from what the new shell prints. pub fn revive(state: *State) void { // The primary screen, keys, cursor and mouse as a shell starts with // them, the cursor where it was (a soft reset, or leaving a primary // screen for itself, would take it home). if (state.vt.screens.active_key == .alternate) ingest(state, "\x1b[?1049l"); ingest(state, "\x1b[?1l\x1b>\x1b[?25h\x1b[?7h\x1b[?1000l\x1b[?1002l\x1b[?1003l\x1b[?1006l\x1b[?2004l\x1b[= node.rows()) { left -= node.rows(); node = node.prev.?; } const pin = pages.trackPin(.{ .node = node, .y = @intCast(node.rows() - 1 - left) }) catch { failed.* = true; return .{}; }; return .{ .pin = pin, .offset = row - @as(i32, @intCast(bounded)) }; } fn pinnedRow(pages: ?*ghostty_vt.PageList, row: RowPin) i32 { const pin = row.pin orelse return row.offset; const alive = pages orelse return 0; if (pin.garbage) return 0; var after: usize = 0; var node = alive.pages.last; while (node) |item| : (node = item.prev) { if (item == pin.node) return @as(i32, @intCast(alive.total_rows - after - item.rows() + pin.y)) +| row.offset; after += item.rows(); } return 0; } /// 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, tracked: []const i32, rows: []i32, erased: []bool) Term.Told { if (tracked.len == 0) { ingest(state, bytes); return .{ .rows = rows[0..0], .erased = erased[0..0], .cleared = false, .alive = true, .failed = false }; } const screens = &state.vt.screens; const active = screens.active_key; const generation = screens.generation(active); const pages = &screens.active.pages; var failed = false; var room: [512]RowPin = undefined; const pins = if (tracked.len <= room.len) room[0..tracked.len] else state.gpa.alloc(RowPin, tracked.len) catch { ingest(state, bytes); @memcpy(rows[0..tracked.len], tracked); @memset(erased[0..tracked.len], false); return .{ .rows = rows[0..tracked.len], .erased = erased[0..tracked.len], .cleared = false, .alive = true, .failed = true }; }; defer if (tracked.len > room.len) state.gpa.free(pins); for (pins, tracked) |*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(active) == generation) pages else null; for (pins, rows[0..tracked.len], erased[0..tracked.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); } return .{ .rows = rows[0..tracked.len], .erased = erased[0..tracked.len], .cleared = cleared, .alive = alive != null, .failed = failed }; } /// Where the shell is in its command cycle (`Term.Prompt`); all zero /// without an emulator. pub fn prompt(state: ?*State) Term.Prompt { const s = state orelse return .{}; const marks = &s.stream.handler; const cursor = &s.vt.screens.active.cursor; // At a prompt's input: on the alternate screen too, where a program // killed there (htop, `sig KILL`) left the emulator and the shell then // drew its prompt, marks and all. A full-screen program draws no // prompt marks. const ready = cursor.semantic_content == .input; // Nothing typed on its line: no input left of the cursor and none // under it (text typed and then Ctrl-A'd starts at the cursor). // Nothing further right counts: that is where fish draws a right // prompt, and fish suggests nothing on an empty line. const empty = ready and empty: { const row = cursor.page_pin.cells(.all); for (row[0..@min(cursor.x + 1, row.len)]) |cell| if (cell.semantic_content == .input and !cell.isEmpty()) break :empty false; break :empty true; }; return .{ .phase = switch (marks.phase) { .none => .none, .prompt => .prompt, .input => .input, .running => .running, }, .started = marks.started, .prompts = marks.prompts, .declined = marks.declined, .continuation = marks.continuation, .finished = if (marks.finished) |f| .{ .seq = f.seq, .status = f.status } else null, .input_ready = ready, .input_empty = empty, .at_prompt = s.vt.cursorIsAtPrompt(), }; } /// What the newest finished command printed: the screen text between its /// C and D marks, read from at most `max_rows` rows above its end, so a /// command that printed the whole history costs no more than its tail. /// The shell exited in the middle of a command (its `exit 3`): no end mark /// will come, so the command's output ends where the cursor is. pub fn endOutputHere(state: *State) void { const marks = &state.stream.handler; if (marks.phase == .running and marks.out_end == null) marks.pinCursor(&marks.out_end, true); } pub fn commandOutput(state: ?*State, gpa: std.mem.Allocator, max_rows: usize) !Term.CommandOutput { // Unless there is text to read, whether the nothing it printed is the // whole of it. const whole = printed: { const s = state orelse break :printed true; const marks = &s.stream.handler; const start = marks.out_start orelse break :printed false; const end = marks.out_end orelse break :printed false; const screen = s.vt.screens.get(.primary) orelse break :printed false; if (end.garbage) break :printed false; var whole = !marks.lost and !start.garbage; // Nothing printed: the whole of it. if (start.eql(end.*)) break :printed whole; // D is where the next prompt begins: the output ends a cell before. // An end at the very top, or before the start, is output a redraw // moved (a prompt drawn over it in a window two rows high): how // much is not known, so it is not called whole. const last = end.leftWrap(1) orelse break :printed false; if (last.before(start.*)) break :printed false; var from = start.*; if (last.up(max_rows)) |floor| if (from.before(floor)) { from = floor; from.x = 0; whole = false; }; return .{ .text = try screen.selectionString(gpa, .{ .sel = ghostty_vt.Selection.init(from, last, false) }), .whole = whole, }; }; return .{ .text = try gpa.dupeSentinel(u8, "", 0), .whole = whole }; } /// One key for its program, as the program's keyboard protocol and modes /// ask for it, written to `out`. pub fn key(state: *State, k: Key, out: *std.Io.Writer) !void { const input = ghostty_vt.input; const function_keys = comptime keys: { var keys: [Key.f25 - Key.f1 + 1]input.Key = undefined; for (&keys, 1..) |*slot, n| slot.* = @field(input.Key, std.fmt.comptimePrint("f{d}", .{n})); break :keys keys; }; const physical: input.Key = switch (k.cp) { Key.enter => .enter, Key.backspace => .backspace, Key.tab => .tab, Key.escape => .escape, Key.up => .arrow_up, Key.down => .arrow_down, Key.left => .arrow_left, Key.right => .arrow_right, Key.home => .home, Key.end => .end, Key.page_up => .page_up, Key.page_down => .page_down, Key.delete => .delete, Key.insert => .insert, Key.print_screen => .print_screen, Key.scroll_lock => .scroll_lock, Key.pause => .pause, Key.menu => .context_menu, Key.f1...Key.f25 => function_keys[k.cp - Key.f1], else => if (k.cp < 128) input.Key.fromASCII(@intCast(k.cp)) orelse .unidentified else .unidentified, }; var utf8: [4]u8 = undefined; const text_cp = if (k.shift and k.cp >= 'a' and k.cp <= 'z') k.cp - 'a' + 'A' else k.cp; // A key with no text of its own types its code point only when that // is a character: the kitty keyboard protocol numbers function and // modifier keys in the private use area (F3 is U+E016), and a shell // was typed those as junk. const text = if (k.text.len > 0) k.text else if (k.cp >= 32 and k.cp < Key.up and k.cp != Key.backspace and !(k.cp >= 0xE000 and k.cp <= 0xF8FF)) utf8[0 .. std.unicode.utf8Encode(text_cp, &utf8) catch return] else ""; try input.encodeKey(out, .{ .key = physical, .mods = .{ .ctrl = k.ctrl, .alt = k.alt, .shift = k.shift }, .consumed_mods = .{ .shift = k.text.len > 0 and k.shift }, .utf8 = text, .unshifted_codepoint = if (k.cp >= 'A' and k.cp <= 'Z') k.cp - 'A' + 'a' else if (k.cp < Key.up) k.cp else 0, }, options: { var opts = input.KeyEncodeOptions.fromTerminal(&state.vt); // fromTerminal cannot know this one and says so, defaulting to // "option is not alt" — right for an app that lets macOS do the // unicode translation and hands the encoder the composed text. // Every pardes shell resolves the modifier itself and hands the // core the BASE key with the alt bit and no text at all (see // PardesView.keyDown, and app.mjs doing the same with the same // two bits), so by the time this runs alt already means alt. // Left at the default, a macOS build drops the ESC prefix on // the floor and forwards Alt-n to the child as a bare `n`. opts.macos_option_as_alt = .true; break :options opts; }); } /// How many cells left or right of the cursor a click on viewport row /// `row`, column `col` of the text shown (the prompt cut off) is, at the /// prompt the cursor is at: what moves the shell's cursor there. Null /// when the cursor is at no prompt, or the click is before the prompt. pub fn promptMoves(state: *State, row: i32, col: i32) ?Term.Moves { if (!state.vt.cursorIsAtPrompt() or row < 0) return null; const screen = state.vt.screens.active; var grid_col: i32 = @max(0, col); if (screen.pages.pin(.{ .viewport = .{ .x = 0, .y = @intCast(row) } })) |row_pin| { if (row_pin.rowAndCell().row.semantic_prompt != .none) switch (promptCut(row_pin)) { .cut => |cols| grid_col += @intCast(cols), .keep, .blank => {}, }; } const click_pin = screen.pages.pin(.{ .viewport = .{ .x = @intCast(grid_col), .y = @intCast(row) }, }) orelse return null; const cursor_pin = screen.cursor.page_pin.*; var prompts = cursor_pin.promptIterator(.left_up, null); const prompt_pin = prompts.next() orelse return null; if (click_pin.before(prompt_pin)) return null; const moves = screen.promptClickMove(click_pin); return .{ .left = moves.left, .right = moves.right }; } /// What LEAVING raw tty mode does to one prompt row, decided from its cells /// alone: OSC 133 prompt cells are hidden in normal mode, what was typed at /// them stays. fn promptCut(pin: ghostty_vt.Pin) PromptCut { const cells = pin.cells(.all); var cols: usize = 0; while (cols < cells.len and cells[cols].semantic_content == .prompt) cols += 1; // Flagged, but with no prompt cells at the FRONT: a right-side prompt, or // a repaint that has moved on. Nothing here is the prompt, so hide nothing. if (cols == 0) return .keep; // ...and all prompt, nothing typed yet: the row is chrome end to end. if (cols >= cells.len) return .blank; return .{ .cut = cols }; } /// How much of its row `row` (from the top of the history) the prompt it /// starts with is; null for a row no prompt starts (the core measures the /// cut columns in the row's text, Term.promptPrefix). pub fn promptCutAt(state: *State, row: i32) ?PromptCut { if (row < 0) return null; const pin = state.vt.screens.active.pages.pin(.{ .screen = .{ .x = 0, .y = @intCast(row) } }) orelse return null; if (pin.rowAndCell().row.semantic_prompt == .none) return null; return promptCut(pin); } /// What a predicted echo reads of cell `x`, `y` of its active area /// (src/echo.zig): null off it. pub fn echoCell(state: *const State, x: u16, y: u16) ?Term.EchoCell { if (y >= state.vt.rows) return null; const ci = state.vt.screens.active.pages.getCell(.{ .active = .{ .x = x, .y = y } }) orelse return null; return .{ .cp = ci.cell.codepoint(), .input = ci.cell.semantic_content == .input, .style = ci.cell.style_id }; } fn promptRow(pin: ghostty_vt.Pin, raw: []const u8) []const u8 { const cols = switch (promptCut(pin)) { .keep => return raw, .blank => return "", .cut => |n| n, }; const cells = pin.cells(.all); var at: usize = 0; var col: usize = 0; while (col < cols and at < raw.len) { const cell = &cells[col]; at = @min(raw.len, at + dumpedBytes(pin, cell)); // the tail cell of a wide glyph spells nothing of its own col += if (cell.wide == .wide) @as(usize, 2) else 1; } return std.mem.trimEnd(u8, raw[at..], " \t"); } fn dumpedBytes(pin: ghostty_vt.Pin, cell: *const ghostty_vt.Cell) usize { switch (cell.wide) { .spacer_head, .spacer_tail => return 0, .narrow, .wide => {}, } var n: usize = switch (cell.content_tag) { .codepoint, .codepoint_grapheme => std.unicode.utf8CodepointSequenceLength( cell.codepoint(), ) catch 1, // A cell carrying only a colour still spells one blank in the dump. else => 1, }; if (cell.content_tag == .codepoint_grapheme) { if (pin.grapheme(cell)) |extra| for (extra) |cp| { n += std.unicode.utf8CodepointSequenceLength(cp) catch 1; }; } return n; } /// Its rows `first` and the `count` after it (from the top of its /// history) as text, a prompt's own cells cut off the rows it starts: /// `arena`'s. An edit copy's rows as they were (src/ansi.zig). pub fn editRows(state: *State, arena: std.mem.Allocator, first: usize, count: usize) ![]const []const u8 { const screen = state.vt.screens.active; const tl = screen.pages.pin(.{ .screen = .{ .y = @intCast(first) } }) orelse return error.NoRow; const br = screen.pages.pin(.{ .screen = .{ .x = screen.pages.cols - 1, .y = @intCast(first + count - 1), } }) orelse return error.NoRow; var output: std.Io.Writer.Allocating = .init(arena); try screen.dumpString(&output.writer, .{ .tl = tl, .br = br, .unwrap = false }); const shell = try arena.alloc([]const u8, count); var raw = std.mem.splitScalar(u8, output.written(), '\n'); var pins = tl.rowIterator(.right_down, br); for (shell) |*row| { const text = raw.next() orelse ""; row.* = if (pins.next()) |pin| if (pin.rowAndCell().row.semantic_prompt != .none) promptRow(pin, text) else text else text; } return shell; } /// A step read its rows (its history too): a replica replaying the step /// must hold them (`State.read`). pub fn markRead(state: *State) void { state.read = true; } /// Its rows from the top of its history as text, a prompt's own cells cut /// off the rows it starts (what typed text stays), joined by '\n' in /// `text` with `rows` slices into it and one empty row after them, the /// cursor's: `alloc`'s, the emulator's dump `scratch`'s. pub fn textRows(state: *State, alloc: std.mem.Allocator, scratch: std.mem.Allocator) !Term.Rows { const full = try state.vt.screens.active.dumpStringAlloc(scratch, .{ .screen = .{} }); var pit = state.vt.screens.active.pages.rowIterator(.right_down, .{ .screen = .{} }, null); // split yields one more item than delimiters; the extra final slot is the // cursor row retained below. const n_rows = std.mem.count(u8, full, "\n") + 2; const lines = try alloc.alloc([]const u8, n_rows); errdefer alloc.free(lines); // Blanking a prompt row only ever SHORTENS it and the retained cursor row // adds one separator, so the dump's length plus one bounds the join. const text = try alloc.alloc(u8, full.len + 1); errdefer alloc.free(text); var at: usize = 0; var n: usize = 0; var it = std.mem.splitScalar(u8, full, '\n'); while (it.next()) |raw| { const kept = if (pit.next()) |pin| if (pin.rowAndCell().row.semantic_prompt != .none) promptRow(pin, raw) else raw else raw; if (n > 0) { text[at] = '\n'; at += 1; } @memcpy(text[at..][0..kept.len], kept); lines[n] = text[at..][0..kept.len]; at += kept.len; n += 1; } text[at] = '\n'; at += 1; lines[n] = text[at..][0..0]; n += 1; std.debug.assert(n == n_rows); return .{ .text_alloc = text, .text = text[0..at], .rows = lines }; } /// The rows its view shows as text, a prompt's own cells cut off the rows /// it starts when `cut` (as the core shows them outside raw mode): `arena`'s. pub fn viewport(state: *State, arena: std.mem.Allocator, cut: bool) ![]const []const u8 { const screen = state.vt.screens.active; var tl = screen.pages.getTopLeft(.viewport); tl.x = 0; const br = screen.pages.getBottomRight(.viewport) orelse return error.UnknownPoint; var rows_out: std.Io.Writer.Allocating = .init(arena); try screen.dumpString(&rows_out.writer, .{ .tl = tl, .br = br, .unwrap = false }); const raw = try rows_out.toOwnedSlice(); var prompts = screen.pages.rowIterator(.right_down, .{ .viewport = .{} }, null); const vp = try arena.alloc([]const u8, std.mem.count(u8, raw, "\n") + 1); var lines = std.mem.splitScalar(u8, raw, '\n'); var n: usize = 0; while (lines.next()) |ln| { vp[n] = if (cut) if (prompts.next()) |pin| if (pin.rowAndCell().row.semantic_prompt != .none) promptRow(pin, ln) else ln else ln else ln; n += 1; } std.debug.assert(n == vp.len); return vp; } /// Its view's rows as cells, for the core's paint (Term.paint, the core's /// src/ansi.zig): `rows.len` rows of `cols` cells into `cells`, each its /// style in the theme's colours (through the filter when `filtered`), the /// bytes it spells in the view's text and its width; each row whether a /// prompt starts it, and how much of it that is. pub fn paint(state: *State, ink: *const Ink, palette: *FilterPalette, filtered: bool, cols: u16, cells: []Painted, rows: []PaintedRow) void { var filter_storage: Filter = undefined; const filter: ?*Filter = if (filtered) blk: { filter_storage = filterOf(ink, palette, &state.vt); break :blk &filter_storage; } else null; // DECSCNM, read once: the filtered palette folds it in itself, the raw // path needs it per cell. const scnm = state.vt.modes.get(.reverse_colors); const pages = &state.vt.screens.active.pages; for (rows, 0..) |*row, vi| { row.* = .{ .prompt = null, .placeholder = false, .len = 0 }; const row_pin = pages.pin(.{ .viewport = .{ .y = @intCast(vi) } }) orelse continue; const flags = row_pin.rowAndCell().row; if (flags.semantic_prompt != .none) row.prompt = promptCut(row_pin); row.placeholder = flags.kitty_virtual_placeholder; const out = cells[vi * cols ..][0..cols]; var x: u16 = 0; while (x < cols) : (x += 1) { const ci = cellAt(pages, row_pin, x) orelse break; out[x] = .{ .style = cellStyle(ink, ci, filter, scnm), .bytes = @intCast(@min(dumpedBytes(row_pin, ci.cell), std.math.maxInt(u16))), .wide = switch (ci.cell.wide) { .narrow => .narrow, .wide => .wide, .spacer_tail => .spacer_tail, .spacer_head => .spacer_head, }, }; } row.len = x; } } /// The cell at column `x` of the row `row` pins, as `pages.getCell` reads /// it, without walking from the viewport's top down to the row again: that /// walk, once a cell, was most of a terminal's paint (once getCell was no /// longer inlined, a frame of a 120x40 shell took 75 µs more). fn cellAt(pages: *const ghostty_vt.PageList, row: ghostty_vt.Pin, x: u16) ?ghostty_vt.PageList.Cell { if (x >= pages.cols or x >= row.node.cols()) return null; const rac = row.node.page().getRowAndCell(x, row.y); return .{ .node = row.node, .row = rac.row, .cell = rac.cell, .row_idx = row.y, .col_idx = x }; } // A cell's underline styles are SGR's, in SGR's order (`off` its `none`): a // cast takes one to the other (cellStyle, and pager.zig's attribute). comptime { for (@typeInfo(@FieldType(plain.CellStyle, "ul")).@"enum".field_names, 0..) |name, i| if (@backingInt(@field(ghostty_vt.sgr.Attribute.Underline, if (std.mem.eql(u8, name, "off")) "none" else name)) != i) @compileError("a cell's underline styles are not SGR's"); } fn cellStyle(ink: *const Ink, ci: ghostty_vt.PageList.Cell, filtered: ?*Filter, scnm: bool) plain.CellStyle { const style = ci.style(); var cs: plain.CellStyle = .{ .fg = if (filtered) |colors| filterFg(colors, style) else ghostColor(ink, style.fg_color, scnm), .bg = if (filtered) |colors| filterBg(colors, style, ci.cell) else ghostColor(ink, style.bg_color, !scnm), .bold = style.flags.bold, .dim = style.flags.faint, .italic = style.flags.italic, .blink = style.flags.blink, .reverse = style.flags.inverse, .invisible = style.flags.invisible, .strikethrough = style.flags.strikethrough, .ul = @fromBackingInt(@intCast(@backingInt(style.flags.underline))), }; if (filtered == null) switch (ci.cell.content_tag) { .bg_color_palette => cs.bg = ink.palColor(ci.cell.content.color_palette.data), .bg_color_rgb => { const rgb = ci.cell.content.color_rgb; cs.bg = .{ .rgb = .{ rgb.r, rgb.g, rgb.b } }; }, else => {}, }; return cs; } pub fn asPardesColor(rgb: GColor.RGB) plain.Color { return .{ .rgb = .{ rgb.r, rgb.g, rgb.b } }; } fn asTriple(rgb: GColor.RGB) [3]u8 { return .{ rgb.r, rgb.g, rgb.b }; } /// A program's colours mapped to the theme (Term.Filter): for a terminal's /// cells (`vt`), or a +Pager's spans (`vt` null, the program's palette /// xterm's own). pub fn filterOf(ink: *const Ink, palette: *FilterPalette, vt: ?*const ghostty_vt.Terminal) Filter { var source = GColor.default; if (vt) |t| { for (&source, 0..) |*rgb, i| rgb.* = t.colorForXterm(.{ .palette = @intCast(i) }) orelse rgb.*; } var theme_bg = asGhostRgb(ink.bg orelse ink.tag_bg); var theme_fg = asGhostRgb(ink.fg orelse ink.tag_fg); var dynamic_bg = if (vt) |t| t.colorForXterm(.{ .dynamic = .background }) else null; var dynamic_fg = if (vt) |t| t.colorForXterm(.{ .dynamic = .foreground }) else null; if (vt != null and vt.?.modes.get(.reverse_colors)) { std.mem.swap(GColor.RGB, &theme_bg, &theme_fg); std.mem.swap(?GColor.RGB, &dynamic_bg, &dynamic_fg); } var self: Filter = .{ .target = filterPalette(palette, ink), .theme_bg = asTriple(theme_bg), .theme_fg = asTriple(theme_fg), .default_bg = asTriple(theme_bg), .fallback_fg = asTriple(theme_fg), .default_bg_luminance = luminanceOf(theme_bg), .fg_for_palette = undefined, .bg_for_palette = undefined, .fg_default = undefined, .bg_default = undefined, }; var default_bg = theme_bg; if (dynamic_bg) |rgb| default_bg = keyedRgb(&self, rgb); self.default_bg = asTriple(default_bg); self.default_bg_luminance = luminanceOf(default_bg); if (theme_bg.contrast(default_bg) > theme_fg.contrast(default_bg)) self.fallback_fg = asTriple(theme_bg); self.fg_default = asPardesColor(legible(&self, if (dynamic_fg) |rgb| keyedRgb(&self, rgb) else theme_fg)); self.bg_default = asPardesColor(default_bg); for (&source, 0..) |current, i| { const idx: u8 = @intCast(i); const mapped = paletteRgb(&self, idx, current); self.fg_for_palette[idx] = asPardesColor(legible(&self, mapped)); self.bg_for_palette[idx] = asPardesColor(mapped); } return self; } /// The filter a +Pager's spans are drawn through (Term.filter). pub fn pagerFilter(ink: *const Ink, palette: *FilterPalette) Filter { return filterOf(ink, palette, null); } fn filterFg(self: *Filter, style: ghostty_vt.Style) plain.Color { return switch (style.fg_color) { .none => self.fg_default, .palette => |idx| self.fg_for_palette[idx], .rgb => |rgb| asPardesColor(legible(self, keyedRgb(self, rgb))), }; } fn filterBg(self: *Filter, style: ghostty_vt.Style, cell: *const ghostty_vt.Cell) plain.Color { switch (cell.content_tag) { .bg_color_palette => return self.bg_for_palette[cell.content.color_palette.data], .bg_color_rgb => {}, else => switch (style.bg_color) { .none => return self.bg_default, .palette => |idx| return self.bg_for_palette[idx], .rgb => {}, }, } // Truecolour, from either the cell or its style. return asPardesColor(keyedRgb(self, style.bg(cell, &GColor.default).?)); } /// A +Pager span's colour (Term.page), as `filterFg` and `filterBg` map a /// cell's. pub fn spanColor(self: *Filter, color: plain.Color, is_bg: bool) plain.Color { return switch (color) { .default => color, .index => |idx| if (is_bg) self.bg_for_palette[idx] else self.fg_for_palette[idx], .rgb => |rgb| blk: { const keyed = keyedRgb(self, asGhostRgb(rgb)); break :blk asPardesColor(if (is_bg) keyed else legible(self, keyed)); }, }; } pub fn legible(self: *const Filter, rgb: GColor.RGB) GColor.RGB { if (contrastOf(luminanceOf(rgb), self.default_bg_luminance) >= min_contrast) return rgb; return asGhostRgb(self.fallback_fg); } pub fn paletteRgb(self: *Filter, idx: u8, current: GColor.RGB) GColor.RGB { if (current.eql(GColor.default[idx])) return asGhostRgb(self.target[idx]); return keyedRgb(self, current); } pub fn keyedRgb(self: *Filter, rgb: GColor.RGB) GColor.RGB { return asGhostRgb(self.target[nearestKey(self, rgb)]); } pub fn nearestKey(self: *Filter, rgb: GColor.RGB) u8 { const rgb24 = (@as(u32, rgb.r) << 16) | (@as(u32, rgb.g) << 8) | rgb.b; const slot: u8 = @truncate((rgb24 *% 0x9e3779b1) >> 24); if (self.cache_valid[slot] and asGhostRgb(self.cache_rgb[slot]).eql(rgb)) return self.cache_key[slot]; var best: u8 = 0; var best_distance: u32 = std.math.maxInt(u32); for (GColor.default, 0..) |candidate, i| { const distance = colorDistance(rgb, candidate); // Strict comparison makes duplicate-colour ties stable at the // lowest canonical xterm key. if (distance < best_distance) { best_distance = distance; best = @intCast(i); } } self.cache_rgb[slot] = asTriple(rgb); self.cache_key[slot] = best; self.cache_valid[slot] = true; return best; } const channel_luminance: [256]f64 = blk: { @setEvalBranchQuota(20000); var table: [256]f64 = undefined; for (&table, 0..) |*slot, c| { const normalized: f64 = @as(f64, @floatFromInt(c)) / 255; slot.* = if (normalized <= 0.03928) normalized / 12.92 else std.math.pow(f64, (normalized + 0.055) / 1.055, 2.4); } break :blk table; }; pub fn luminanceOf(rgb: GColor.RGB) f64 { return 0.2126 * channel_luminance[rgb.r] + 0.7152 * channel_luminance[rgb.g] + 0.0722 * channel_luminance[rgb.b]; } /// ghostty's `RGB.contrast` with both luminances already in hand. fn contrastOf(a_luminance: f64, b_luminance: f64) f64 { const lighter = @max(a_luminance, b_luminance); const darker = @min(a_luminance, b_luminance); return (lighter + 0.05) / (darker + 0.05); } fn colorDistance(a: GColor.RGB, b: GColor.RGB) u32 { const dr = @as(i32, a.r) - @as(i32, b.r); const dg = @as(i32, a.g) - @as(i32, b.g); const db = @as(i32, a.b) - @as(i32, b.b); return @intCast(dr * dr + dg * dg + db * db); } fn ghostColor(ink: *const Ink, color: ghostty_vt.Style.Color, is_bg: bool) plain.Color { return switch (color) { .none => blk: { const t = if (is_bg) ink.bg else ink.fg; break :blk if (t) |c| .{ .rgb = c } else .default; }, .palette => |idx| ink.palColor(idx), .rgb => |rgb| .{ .rgb = .{ rgb.r, rgb.g, rgb.b } }, }; } /// 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 { if (comptime !images_enabled) return null; return state.images.animation_due_ms; } /// The Petscii builtin on a terminal: its kitty graphics as glyph art, /// or back to pixels where the shell draws pixels. pub fn togglePetscii(state: *State) void { if (comptime !images_enabled) return; state.images.petscii = !state.images.petscii; } /// Whether the pane draws its kitty graphics as glyph art by choice; null /// for a pane with no emulator. pub fn petscii(maybe: ?*const State) ?bool { if (comptime !images_enabled) return null; const state = maybe orelse return null; return state.images.petscii; } /// Whether the screen showing holds any kitty graphics image. pub fn hasImages(maybe: ?*const State) bool { if (comptime !images_enabled) return false; const state = maybe orelse return false; return state.vt.screens.active.kitty_images.images.count() > 0; } /// Its kitty graphics over the body's rows, as placements appended to /// `out` (after the rows and their colours: placeholder cells are blanked /// in `frame`, `frame_cols` wide). `at.rows_of` maps its view's rows to /// the body's; a prompt row outside tty mode is cut or hidden, its columns /// not the grid's, and shows none. pub fn images(state: *State, gpa: std.mem.Allocator, at: ImagesAt, out: *std.ArrayList(plain.Placement), frame: []plain.Cell, frame_cols: u16) void { if (comptime !images_enabled) return; const screen = state.vt.screens.active; var rows_of: [1024]?u16 = undefined; const vp_rows = @min(at.rows_of.len, rows_of.len); var any_placeholder = false; for (rows_of[0..vp_rows], at.rows_of[0..vp_rows], 0..) |*slot, body_row, vi| { slot.* = null; const vr = body_row orelse continue; const row_pin = screen.pages.pin(.{ .viewport = .{ .y = @intCast(vi) } }) orelse continue; const flags = row_pin.rowAndCell().row; if (!at.tty_mode and flags.semantic_prompt != .none) continue; any_placeholder = any_placeholder or flags.kitty_virtual_placeholder; slot.* = vr; } // Nothing to draw, no placeholder to blank and nothing cached to let // go: the common case costs the rows' flags. if (!any_placeholder and screen.kitty_images.placements.count() == 0 and state.images.converted.count() == 0) return; state.images.draw(gpa, &state.vt, at, rows_of[0..vp_rows], out, frame, frame_cols); } test "the luminance table answers exactly what ghostty computes" { for (0..256) |i| { const c: u8 = @intCast(i); const grey: GColor.RGB = .{ .r = c, .g = c, .b = c }; try std.testing.expectEqual(grey.luminance(), luminanceOf(grey)); } // Channel weights are asymmetric, so a grey ramp alone would not catch a // transposed coefficient. The palette is what the tables enumerate. for (GColor.default) |candidate| { try std.testing.expectEqual(candidate.luminance(), luminanceOf(candidate)); for (GColor.default) |page| { try std.testing.expectEqual( candidate.contrast(page), contrastOf(luminanceOf(candidate), luminanceOf(page)), ); } } }