summaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
authorGabriel Schneider <[email protected]>2026-11-17 03:25:13 -0300
committerGabriel Schneider <[email protected]>2026-11-17 12:15:01 -0300
commita3509e4df5efc94b0deee3b06dd72f85b0d96647 (patch)
tree86be50532fe55f9232c7ba59c3e5007895f7f85e /src
parent98f84f99e79cccc2344aff2efe10823540d0c7b7 (diff)
downloadpardes-a3509e4df5efc94b0deee3b06dd72f85b0d96647.tar.gz
pardes-a3509e4df5efc94b0deee3b06dd72f85b0d96647.zip
Term: the draw group as plain data (docs/next-terminal.md, Phase 1): the terminal paints its view into a plain cell buffer and the core lays it over the body's rows; Term.paint gives each of its view's rows (Term.PaintedRow: the prompt cut a shell's marks make of it, its kitty placeholders, how many cells it has) and each cell (Term.Painted: its style in the theme's colours, through the filter when the pane has it on, the bytes it spells, its width) for a theme handed in as Term.Ink; src/ansi.zig, new, is the core's half of what was terminal.zig's recolorAnsi, moved: the body walk, the edit copy's anchors (EditAnchors, its rows from Term.editRows) and the grapheme-to-cell alignment, now reading the buffer instead of the emulator's pages, and drawImages' body walk (Term.images takes the rows it maps and appends placements to the frame's list, blanking placeholder cells in its cells, as TerminalImages.draw did through Pardes); the filter stays the terminal's (it wraps ghostty's generate256Color), its record plain (Term.Filter, Term.FilterPalette in src/plain/term.zig, [3]u8 for ghostty's RGB), so a +Pager's spans are drawn through Term.filter and Term.spanColor, and palColor is Ink.palColor; config.tty_filter_min_contrast goes to the filter it bounds; Term.Grid gains the grid's cols; the filter tests reach the plain record's fields through asGhostRgb, asserting what they did; perf --terminal-mib (tail-style line off, ReleaseFast, instructions:u, 3 runs each, ±30k): 8 MiB 4,347.9M -> 3,949.8M (4.51M -> 4.09M a batch), 32 MiB 14,729.1M -> 13,294.4M (3.82M -> 3.45M a batch), the copy costs nothing that shows and the frame got cheaper; core-test 985/985, kitty-test 45/45, pane-test 151/152 (1 skipped), behaviour-test 268/272 (the four addon ABI 3.0 tests the base fails), replicas checked/wrong 0
Diffstat (limited to 'src')
-rw-r--r--src/File.zig12
-rw-r--r--src/Term.zig39
-rw-r--r--src/ansi.zig305
-rw-r--r--src/body_layer.zig5
-rw-r--r--src/config.zig3
-rw-r--r--src/plain/plain.zig2
-rw-r--r--src/plain/term.zig110
-rw-r--r--src/term/TerminalImages.zig39
-rw-r--r--src/term/terminal.zig763
9 files changed, 729 insertions, 549 deletions
diff --git a/src/File.zig b/src/File.zig
index 64614191..d4032171 100644
--- a/src/File.zig
+++ b/src/File.zig
@@ -13,6 +13,7 @@ const filesystem = @import("fs.zig");
const syntax = @import("syntax.zig");
const diff = @import("diff.zig");
const tracy = @import("tracy.zig");
+const ansi = @import("ansi.zig");
const limits = @import("memory.zig").limits;
const locations = @import("locations.zig");
const Colors = @import("colors.zig");
@@ -1831,9 +1832,10 @@ pub fn recolorSyntax(p: *Pardes, s: *Surface, pane: *Pane, f: *State, r: pardes.
// A row whose first byte names a hue (syntax.ground_add, _del): its
// grounds, the theme's, worked out once a frame and only for one.
var grounds: ?Colors.Grounds = null;
+ const ink = ansi.inkOf(p.theme());
var filtered_storage: pardes.Term.Filter = undefined;
const filtered: ?*pardes.Term.Filter = if (pane.tty_filter and spans.len > 0) blk: {
- filtered_storage = .init(p, null);
+ filtered_storage = pardes.Term.filter(&ink, &p.tty_filter_palette);
break :blk &filtered_storage;
} else null;
// indexed start, same as bodyText — an empty tail simply paints nothing
@@ -1957,11 +1959,11 @@ pub fn recolorSyntax(p: *Pardes, s: *Surface, pane: *Pane, f: *State, r: pardes.
// palette colour through the theme's sixteen and
// truecolor as it is.
if (filtered) |colors| {
- if (st.fg != .default) cell.style.fg = colors.spanColor(st.fg, false);
- if (st.bg != .default) cell.style.bg = colors.spanColor(st.bg, true);
+ if (st.fg != .default) cell.style.fg = pardes.Term.spanColor(colors, st.fg, false);
+ if (st.bg != .default) cell.style.bg = pardes.Term.spanColor(colors, st.bg, true);
} else {
- if (st.fg != .default) cell.style.fg = if (st.fg == .index) pardes.Term.palColor(p, st.fg.index) else st.fg;
- if (st.bg != .default) cell.style.bg = if (st.bg == .index) pardes.Term.palColor(p, st.bg.index) else st.bg;
+ if (st.fg != .default) cell.style.fg = if (st.fg == .index) ink.palColor(st.fg.index) else st.fg;
+ if (st.bg != .default) cell.style.bg = if (st.bg == .index) ink.palColor(st.bg.index) else st.bg;
}
cell.style.bold = cell.style.bold or st.bold;
cell.style.dim = st.dim;
diff --git a/src/Term.zig b/src/Term.zig
index a21c3d97..ee178adc 100644
--- a/src/Term.zig
+++ b/src/Term.zig
@@ -6,6 +6,7 @@
//! this is the one file outside it that names a file inside it (and so
//! the one place Phase 1 turns into the module's registration).
const std = @import("std");
+const plain = @import("plain");
const terminal = @import("term/terminal.zig");
const pager = @import("term/pager.zig");
const echo = @import("term/echo.zig");
@@ -74,6 +75,8 @@ pub const Grid = struct {
/// The view's top row while it is scrolled to one, null while it
/// follows the output.
view: ?usize = null,
+ /// Its grid's width (a pane's may differ while a resize is deferred).
+ cols: u16 = 0,
};
/// What a `feed` told the rows the core keeps positions on: each tracked
@@ -215,31 +218,35 @@ pub const Span = pager.Span;
// ---- draw ----
//
-// ponytail: not yet narrowed to plain data (docs/next-terminal.md's draw
-// row): these still take the core's Pardes, Surface and Pane, read the
-// pane's edit copy and write the surface's cells and placements
-// themselves. Phase 1 needs them as a cell hand-over (`paint`) and a
-// placement list (`images`) first.
+// Plain data both ways: the core hands the theme's colours (`Ink`) and a
+// buffer, and is given its view's cells (`Painted`, `PaintedRow`) and its
+// images as placements; which of the body's rows they stand under is the
+// core's (src/ansi.zig).
-/// Its program's colours over the body's rows, through the theme's
+/// Its view's rows as cells in the theme's colours, through the theme's
/// filter when the pane has it on.
-pub const recolor = terminal.recolorAnsi;
+pub const paint = terminal.paint;
/// Its kitty graphics over the body's rows, as placements.
-pub const images = terminal.drawImages;
+pub const images = terminal.images;
+/// Its rows `first` and the `count` after it as text, prompts cut off (the
+/// edit copy's rows, as they were).
+pub const editRows = terminal.editRows;
/// The Petscii builtin on it: its kitty graphics as glyph art, or back to
/// pixels; null for none.
pub const petscii = terminal.petscii;
pub const togglePetscii = terminal.togglePetscii;
/// Whether the screen showing holds any kitty graphics image.
pub const hasImages = terminal.hasImages;
-/// A program's colours mapped to the theme (Filter): a terminal's cells
-/// or a +Pager's spans (`spanColor`).
-pub const Filter = terminal.FilteredColors;
-/// The theme's 256 colours as the filter maps onto them, kept while the
-/// theme is the same (`Pardes.tty_filter_palette`).
-pub const FilterPalette = terminal.FilterPalette;
-/// A palette index as the theme draws it: its own sixteen, else the index.
-pub const palColor = terminal.palColor;
+/// The filter a +Pager's spans are drawn through, and a span's colour
+/// through it.
+pub const filter = terminal.pagerFilter;
+pub const spanColor = terminal.spanColor;
+pub const Ink = plain.term.Ink;
+pub const FilterPalette = plain.term.FilterPalette;
+pub const Filter = plain.term.Filter;
+pub const Painted = plain.term.Painted;
+pub const PaintedRow = plain.term.PaintedRow;
+pub const ImagesAt = plain.term.ImagesAt;
// ---- its replicas ----
diff --git a/src/ansi.zig b/src/ansi.zig
new file mode 100644
index 00000000..3a3f9d85
--- /dev/null
+++ b/src/ansi.zig
@@ -0,0 +1,305 @@
+//! A program's colours on a pane's body: a terminal's cells over the rows
+//! the body shows (its paint, handed over as plain cells: Term.paint), and
+//! its kitty images over them (Term.images). The terminal gives its view's
+//! cells in the theme's colours; which of them stand under which of the
+//! body's rows, the edit copy's among them, is worked out here.
+const std = @import("std");
+const pardes = @import("pardes.zig");
+const panes = @import("panes.zig");
+const modal = @import("modal.zig");
+const tracy = @import("tracy.zig");
+const Term = @import("Term.zig");
+const Pardes = pardes.Pardes;
+const Pane = panes.Pane;
+const Surface = pardes.Surface;
+const BodyWalk = @import("body_layer.zig").BodyWalk;
+const EditBuffer = panes.Text.EditBuffer;
+
+/// The theme's colours as a terminal's paint takes them.
+pub fn inkOf(theme: *const pardes.Theme) Term.Ink {
+ return .{
+ .fg = theme.fg,
+ .bg = theme.bg,
+ .tag_fg = theme.tag_fg,
+ .tag_bg = theme.tag_bg,
+ .palette = theme.palette,
+ .base = theme.palette orelse .{
+ theme.bg orelse theme.tag_bg,
+ theme.kw,
+ theme.str,
+ theme.num,
+ theme.box,
+ theme.sel_bg,
+ theme.comment,
+ theme.fg orelse theme.tag_fg,
+ theme.lineno,
+ theme.kw,
+ theme.str,
+ theme.num,
+ theme.scroll_thumb,
+ theme.sel_fg,
+ theme.tag_fg,
+ theme.fg orelse theme.tag_fg,
+ },
+ };
+}
+
+/// Its program's colours over the body's rows, through the theme's filter
+/// when the pane has it on.
+pub fn recolor(p: *Pardes, s: *Surface, pane: *Pane, r: pardes.Rect, tx: u16, tw: u16, body_h: u16, body: []const u8) void {
+ const state = pane.terminal orelse return;
+ const body_y = p.bodyTop(pane, r);
+ const g = Term.grid(state);
+ const cols = g.cols;
+ const arena = p.scratch.allocator();
+ const cells = arena.alloc(Term.Painted, g.len * @as(usize, cols)) catch return;
+ const rows = arena.alloc(Term.PaintedRow, g.len) catch return;
+ {
+ const tz_paint = tracy.zone(@src(), "termPaint");
+ defer tz_paint.end();
+ const ink = inkOf(p.theme());
+ Term.paint(state, &ink, &p.tty_filter_palette, pane.tty_filter, cols, cells, rows);
+ }
+ const filtered = pane.tty_filter;
+ const vp_rows: i32 = @intCast(g.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;
+ var walk: BodyWalk = .init(pane);
+ var lines = std.mem.splitScalar(u8, body, '\n');
+ var vr: u16 = 0;
+ while (walk.next()) |row| : (vr += 1) {
+ if (vr >= body_h) break;
+ // Before any early exit below, or the lines fall out of step with rows.
+ const text = lines.next() orelse "";
+ const anchor: Anchor = switch (row) {
+ .edit => |e| blk: {
+ if (anchors == null) anchors = .init(p, pane, pane.ovl.?);
+ var an = anchors.?.shellRow(e.idx) orelse continue;
+ an.row -= walk.goff;
+ break :blk an;
+ },
+ .grid => |v| .{ .row = v },
+ };
+ const vi = anchor.row;
+ if (vi < 0 or vi >= vp_rows) continue;
+ const prow = rows[@intCast(vi)];
+ const grid_row = cells[@as(usize, @intCast(vi)) * cols ..][0..prow.len];
+ const cut: u16 = if (pane.body.mode == .tty) 0 else cut: {
+ const prompt = prow.prompt orelse break :cut 0;
+ break :cut switch (prompt) {
+ .keep => 0,
+ // Blanked end to end: the row shows nothing of the grid, so
+ // projecting the prompt's own colours onto it would be a lie.
+ .blank => continue,
+ .cut => |n| std.math.cast(u16, n) orelse continue,
+ };
+ };
+ if (cut > 0 and text.len == 0) continue;
+ var at: usize = 0;
+ var sc: u16 = 0;
+ var gc: u16 = cut;
+ var sb: usize = 0;
+ const mine_from = @min(anchor.prefix, text.len);
+ const mine_to = text.len - @min(anchor.suffix, text.len);
+ var crossed = false;
+ while (at < text.len and sc < tw) {
+ const stop = modal.nextGrapheme(text, at);
+ if (stop <= at) break;
+ const span: u16 = if (sc + 1 < tw and s.at(tx + sc + 1, body_y + vr).len == 0) 2 else 1;
+ if (at >= mine_from and at < mine_to) {
+ sc += span;
+ at = stop;
+ continue;
+ }
+ if (at >= mine_to and !crossed) {
+ crossed = true;
+ const upto = anchor.shell_len - @min(anchor.suffix, anchor.shell_len);
+ while (sb < upto) {
+ if (gc >= grid_row.len) break;
+ sb += grid_row[gc].bytes;
+ gc = std.math.add(u16, gc, 1) catch break;
+ }
+ }
+ const want = stop - at;
+ // Consume every cell that contributed to this grapheme. A cluster
+ // ghostty split across several cells is still ONE printed glyph.
+ var covered: usize = 0;
+ var style: ?pardes.CellStyle = null;
+ while (covered < want) {
+ if (gc >= grid_row.len) break;
+ const c = &grid_row[gc];
+ if (style == null and c.wide != .spacer_tail and c.wide != .spacer_head)
+ style = c.style;
+ covered += c.bytes;
+ gc = std.math.add(u16, gc, 1) catch break;
+ // A spacer contributes no bytes; without this the loop would
+ // spin on a row that ends in one.
+ if (covered == 0 and gc >= pane.cols) break;
+ }
+ while (gc < grid_row.len and grid_row[gc].wide == .spacer_tail)
+ gc = std.math.add(u16, gc, 1) catch break;
+ if (style) |st| for (0..span) |k| {
+ const cell = s.at(tx + sc + @as(u16, @intCast(k)), body_y + vr);
+ if (cell.default and !filtered) continue;
+ cell.default = false;
+ cell.style = st;
+ };
+ sb += covered;
+ sc += span;
+ at = stop;
+ }
+ var tail: ?pardes.CellStyle = null;
+ if (anchor.whole() or anchor.suffix > 0) {
+ while (sc < tw) {
+ if (gc >= grid_row.len) break;
+ const c = &grid_row[gc];
+ gc = std.math.add(u16, gc, 1) catch break;
+ if (c.wide == .spacer_tail) continue;
+ const cell = s.at(tx + sc, body_y + vr);
+ sc += 1;
+ tail = c.style;
+ if (cell.default and !filtered) continue;
+ cell.default = false;
+ cell.style = c.style;
+ }
+ if (tail) |style| while (sc < tw) : (sc += 1) {
+ const cell = s.at(tx + sc, body_y + vr);
+ if (cell.default and !filtered) continue;
+ cell.default = false;
+ cell.style = style;
+ };
+ }
+ }
+}
+
+/// Its kitty images over the body's rows, as placements (after the rows
+/// and their colours: placeholder cells are blanked by it).
+pub fn images(p: *Pardes, s: *Surface, pane: *Pane, id: usize, tx: u16, tw: u16, body_y: u16, body_h: u16) void {
+ const state = pane.terminal orelse return;
+ Term.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(Term.grid(state).len, rows_of.len);
+ @memset(rows_of[0..vp_rows], null);
+ var walk: BodyWalk = .init(pane);
+ var vr: u16 = 0;
+ while (walk.next()) |row| : (vr += 1) {
+ if (vr >= body_h) break;
+ const vi = switch (row) {
+ .grid => |v| v,
+ .edit => continue,
+ };
+ if (vi < 0 or vi >= vp_rows) continue;
+ rows_of[@intCast(vi)] = vr;
+ }
+ Term.images(state, p.gpa, .{
+ .pane = @intCast(id),
+ .serial = pane.serial,
+ .tx = tx,
+ .body_y = body_y,
+ .cols = @min(tw, pane.cols),
+ .rows_of = rows_of[0..vp_rows],
+ .tty_mode = pane.body.mode == .tty,
+ .now_ms = p.clock.stepped_ns / std.time.ns_per_ms,
+ .cell_w = @max(1, p.view().cell_pixels.w),
+ .cell_h = @max(1, p.view().cell_pixels.h),
+ }, &p.surface.placements, s.cells, s.cols);
+}
+
+// Match surviving edit-buffer rows to their original terminal styles.
+const EditAnchors = struct {
+ /// the buffer's own text, walked in order: a line the VIEWPORT skipped still
+ /// consumes the row it came from, so the lines below it stay aligned
+ text: []const u8 = &.{},
+ at: usize = 0,
+ shell: []const []const u8 = &.{},
+ /// the covered span, absolute grid rows, as `[first, end)`
+ first: usize = 0,
+ end: usize = 0,
+ lines: usize = 0,
+ /// the line `at` names, and the first row still unclaimed
+ idx: usize = 0,
+ cursor: usize = 0,
+ budget: usize = 0,
+ active: bool = false,
+
+ fn init(p: *Pardes, pane: *Pane, o: EditBuffer) EditAnchors {
+ if (o.rows <= 0 or o.row < 0) return .{};
+ const first: usize = @intCast(o.row);
+ const total = Term.grid(pane.terminal).total;
+ if (first >= total) return .{};
+ const covered: usize = @intCast(o.rows);
+ const count = @min(covered, total - first);
+ const shell = Term.editRows(pane.terminal.?, p.scratch.allocator(), first, count) catch return .{};
+ const lines = std.mem.count(u8, o.text, "\n") + 1;
+ return .{
+ .text = o.text,
+ .shell = shell,
+ .first = first,
+ .end = first + count,
+ .lines = lines,
+ .cursor = first,
+ .budget = covered + 4 * lines,
+ .active = true,
+ };
+ }
+ fn shellRow(a: *EditAnchors, idx: usize) ?Anchor {
+ if (!a.active or idx >= a.lines) return null;
+ var found: ?Anchor = null;
+ while (a.idx <= idx) : (a.idx += 1) found = a.claim(a.nextLine() orelse return null);
+ return found;
+ }
+
+ fn nextLine(a: *EditAnchors) ?[]const u8 {
+ if (a.at > a.text.len) return null;
+ const rest = a.text[a.at..];
+ if (std.mem.indexOfScalar(u8, rest, '\n')) |n| {
+ a.at += n + 1;
+ return rest[0..n];
+ }
+ // The last line has no terminator; one past the end ends the walk.
+ a.at = a.text.len + 1;
+ return rest;
+ }
+
+ /// Where this line still stands over the grid, if anywhere.
+ fn claim(a: *EditAnchors, line: []const u8) ?Anchor {
+ const end = if (line.len == 0) @min(a.cursor + 1, a.end) else a.end;
+ var k = a.cursor;
+ while (k < end) : (k += 1) {
+ if (a.budget == 0) return null;
+ a.budget -= 1;
+ if (!std.mem.eql(u8, line, a.shell[k - a.first])) continue;
+ a.cursor = k + 1;
+ return .{ .row = @intCast(k) };
+ }
+ if (a.cursor >= a.end) return null;
+ const shell = a.shell[a.cursor - a.first];
+ var p: usize = 0;
+ while (p < line.len and p < shell.len and line[p] == shell[p]) p += 1;
+ var s: usize = 0;
+ const room = @min(line.len, shell.len) - p;
+ while (s < room and line[line.len - 1 - s] == shell[shell.len - 1 - s]) s += 1;
+ if (p + s == 0) return null;
+ if (line.len != p + s and shell.len - (p + s) > shell.len / 2) return null;
+ const row = a.cursor;
+ if (s > 0 or p >= shell.len) a.cursor += 1;
+ return .{ .row = @intCast(row), .prefix = p, .suffix = s, .shell_len = shell.len };
+ }
+};
+
+const Anchor = struct {
+ /// the row, absolute while it comes from `EditAnchors`, viewport once
+ /// `recolorAnsi` has subtracted the walk's offset
+ row: i32,
+ prefix: usize = std.math.maxInt(usize),
+ suffix: usize = 0,
+ /// the row's own dumped length — what the suffix is measured from on the
+ /// GRID side, where the edit may have changed the byte count
+ shell_len: usize = 0,
+
+ fn whole(an: Anchor) bool {
+ return an.prefix == std.math.maxInt(usize);
+ }
+};
diff --git a/src/body_layer.zig b/src/body_layer.zig
index 6c0ffcea..abd21090 100644
--- a/src/body_layer.zig
+++ b/src/body_layer.zig
@@ -11,6 +11,7 @@ const modal = @import("modal.zig");
const tracy = @import("tracy.zig");
const panes = @import("panes.zig");
const colors = @import("colors.zig");
+const ansi = @import("ansi.zig");
const Color = @import("surface.zig").Color;
const CellStyle = @import("surface.zig").CellStyle;
const Cell = @import("surface.zig").Cell;
@@ -344,11 +345,11 @@ pub fn renderBody(p: *Pardes, s: *Surface, arena: std.mem.Allocator, pane: *Pane
pane.places.paint(p, s, pane, r, body_h);
panes.Query.paint(p, s, pane, r, body_h);
} else if (pane.isTerminal()) {
- panes.Term.recolor(p, s, pane, r, tx, tw, body_h, body);
+ ansi.recolor(p, s, pane, r, tx, tw, body_h, body);
panes.File.recolorDiffOutput(p, s, pane, r, tx, tw, body_h, body);
}
tz_color.end();
- if (pane.isTerminal()) panes.Term.images(p, s, pane, id, tx, tw, body_y, body_h);
+ if (pane.isTerminal()) ansi.images(p, s, pane, id, tx, tw, body_y, body_h);
const sel_btn = buttonTints(th);
if (p.look_hover_preview) |preview| {
diff --git a/src/config.zig b/src/config.zig
index 8a1528a8..a122fb7c 100644
--- a/src/config.zig
+++ b/src/config.zig
@@ -217,9 +217,6 @@ pub const back_out: []const Chord = &.{.{ .cp = Key.escape, .shift = true }};
pub const tty_toggle_default: u21 = 'b';
-// Projected colors below this contrast use the theme's more legible anchor.
-pub const tty_filter_min_contrast: f64 = 1.5;
-
// What a pty child is told it is talking to. Every pane is emulated by the
// bundled VT, so this describes pardes and never the terminal pardes itself
// was launched from — the child inherits the launcher's TERM otherwise, which
diff --git a/src/plain/plain.zig b/src/plain/plain.zig
index 9c2cbb5a..6dc75f94 100644
--- a/src/plain/plain.zig
+++ b/src/plain/plain.zig
@@ -5,6 +5,8 @@
//! Event.zig, under their old names) and the terminal (src/term/) both
//! import it, and neither imports the other.
const std = @import("std");
+/// The terminal as the core sees it: the records it takes and gives.
+pub const term = @import("term.zig");
pub const Color = union(enum) { default, index: u8, rgb: [3]u8 };
diff --git a/src/plain/term.zig b/src/plain/term.zig
new file mode 100644
index 00000000..2f1323f0
--- /dev/null
+++ b/src/plain/term.zig
@@ -0,0 +1,110 @@
+//! The terminal as the core sees it (docs/next-terminal.md, Phase 1): the
+//! records its draw group takes and gives, plain data. src/Term.zig is the
+//! core's side of it.
+const std = @import("std");
+const plain = @import("plain.zig");
+const Color = plain.Color;
+const CellStyle = plain.CellStyle;
+
+/// How much of a row the prompt it starts with is.
+pub const PromptCut = union(enum) {
+ /// no prompt: the row as the emulator dumps it
+ keep,
+ /// all prompt, nothing typed yet: show nothing of it
+ blank,
+ /// this many leading COLUMNS are the prompt; the rest is what was typed
+ /// at it
+ cut: usize,
+};
+
+// ---- its colours on the body ----
+
+/// A theme's colours as a terminal's paint takes them.
+pub const Ink = struct {
+ fg: ?[3]u8,
+ bg: ?[3]u8,
+ tag_fg: [3]u8,
+ tag_bg: [3]u8,
+ /// The theme's own sixteen, when it has them.
+ palette: ?[16][3]u8,
+ /// The sixteen the filter keys a program's colours to: `palette`, else
+ /// made of the theme's roles.
+ base: [16][3]u8,
+
+ /// A palette index as the theme draws it: its own sixteen, else the
+ /// index.
+ pub fn palColor(ink: *const Ink, idx: u8) Color {
+ if (ink.palette) |pal| if (idx < 16) return .{ .rgb = pal[idx] };
+ return .{ .index = idx };
+ }
+};
+
+/// The theme's 256 colours as the filter maps onto them, kept while the
+/// theme is the same (`Pardes.tty_filter_palette`).
+pub const FilterPalette = struct {
+ key: ?Key = null,
+ colors: [256][3]u8 = undefined,
+
+ pub const Key = struct { bg: [3]u8, fg: [3]u8, base: [16][3]u8 };
+};
+
+/// A program's colours mapped to the theme, once a frame: what a +Pager's
+/// spans are drawn through (`spanColor`), as a terminal's cells are.
+pub const Filter = struct {
+ target: *const [256][3]u8,
+ /// The theme's page and ink, and the page a program's colours are
+ /// drawn on (its OSC 11, keyed to the theme, else the theme's).
+ theme_bg: [3]u8,
+ theme_fg: [3]u8,
+ default_bg: [3]u8,
+ /// What a foreground too near the page's background becomes instead.
+ fallback_fg: [3]u8,
+ default_bg_luminance: f64,
+ fg_for_palette: [256]Color,
+ bg_for_palette: [256]Color,
+ /// The two answers for a cell that names no colour of its own.
+ fg_default: Color,
+ bg_default: Color,
+ cache_rgb: [256][3]u8 = undefined,
+ cache_key: [256]u8 = undefined,
+ cache_valid: [256]bool = @splat(false),
+};
+
+/// One cell of a terminal's view as its paint gives it: its style (its
+/// colours the theme's already), the bytes it spells in the view's text,
+/// and whether it is half of a wide one.
+pub const Painted = struct {
+ style: CellStyle,
+ bytes: u16,
+ wide: enum(u2) { narrow, wide, spacer_tail, spacer_head },
+};
+
+/// One row of a terminal's view as its paint gives it.
+pub const PaintedRow = struct {
+ /// The shell marked it a prompt's: how much of it the prompt is.
+ prompt: ?PromptCut,
+ /// It holds kitty placeholder cells.
+ placeholder: bool,
+ /// Its cells given, from its first: the grid's past them are none.
+ len: u16,
+};
+
+/// Where a terminal's kitty images go, as the body lays out its rows:
+/// `rows_of[v]` is the body row its view's row `v` shows on, null for one
+/// not shown.
+pub const ImagesAt = struct {
+ pane: u8,
+ serial: u32,
+ tx: u16,
+ body_y: u16,
+ cols: u16,
+ rows_of: []const ?u16,
+ /// The pane shows its terminal's rows as they are (tty mode): a prompt
+ /// row is the grid's then, and its images show.
+ tty_mode: bool,
+ /// The core's clock (animations step on it), and a cell's size in
+ /// pixels.
+ now_ms: u64,
+ cell_w: u32,
+ cell_h: u32,
+};
diff --git a/src/term/TerminalImages.zig b/src/term/TerminalImages.zig
index ab7aca25..3847be4c 100644
--- a/src/term/TerminalImages.zig
+++ b/src/term/TerminalImages.zig
@@ -161,37 +161,35 @@ fn decodePng(gpa: std.mem.Allocator, bytes: []const u8) ghostty_vt.sys.DecodeErr
/// columns the body shows, from `tx`.
pub fn draw(
ti: *TerminalImages,
- p: *pardes.Pardes,
- s: *pardes.Surface,
+ gpa: std.mem.Allocator,
vt: *ghostty_vt.Terminal,
- pane_id: u8,
- serial: u32,
- tx: u16,
- body_y: u16,
- cols: u16,
+ where: plain.term.ImagesAt,
rows_of: []const ?u16,
+ out: *std.ArrayList(plain.Placement),
+ frame: []plain.Cell,
+ frame_cols: u16,
) void {
var conv = ti.converted.valueIterator();
while (conv.next()) |c| c.used = false;
- defer ti.prune(p.gpa);
+ defer ti.prune(gpa);
const screen = vt.screens.active;
const storage = &screen.kitty_images;
// Animations step on the core's clock, as this frame shows them; the
// shown frame is `renderData()` (a new `generation` each step, which
// the caches key on).
- const now_ms = p.clock.stepped_ns / std.time.ns_per_ms;
+ const now_ms = where.now_ms;
ti.animation_due_ms = if (storage.animationTick(vt.io(), now_ms)) |delay| now_ms +| delay else null;
const pages = &screen.pages;
const top = pages.getTopLeft(.viewport);
const bottom = pages.getBottomRight(.viewport) orelse return;
- const cw: u32 = @max(1, p.view().cell_pixels.w);
- const ch: u32 = @max(1, p.view().cell_pixels.h);
- const ctx: Ctx = .{ .ti = ti, .p = p, .pane = pane_id, .serial = serial, .tx = tx, .body_y = body_y, .cols = cols, .rows_of = rows_of, .cw = cw, .ch = ch };
+ const cw: u32 = @max(1, where.cell_w);
+ const ch: u32 = @max(1, where.cell_h);
+ const ctx: Ctx = .{ .ti = ti, .gpa = gpa, .out = out, .pane = where.pane, .serial = where.serial, .tx = where.tx, .body_y = where.body_y, .cols = where.cols, .rows_of = rows_of, .cw = cw, .ch = ch };
// Handed on lowest z first (the storage's order is a hash map's), the
// order a shell draws them in; equal z keeps the order they came in.
- const first = s.placements.items.len;
- defer std.sort.insertion(plain.Placement, s.placements.items[first..], {}, struct {
+ const first = out.items.len;
+ defer std.sort.insertion(plain.Placement, out.items[first..], {}, struct {
fn lessThan(_: void, a: plain.Placement, b: plain.Placement) bool {
return a.z < b.z;
}
@@ -206,8 +204,8 @@ pub fn draw(
if (v >= rows_of.len) continue;
const row = rows_of[v] orelse continue;
for (@as(usize, at.viewport.x)..@as(usize, at.viewport.x) + run.width) |x| {
- if (x >= cols) break;
- const cell = s.at(tx + @as(u16, @intCast(x)), body_y + row);
+ if (x >= where.cols) break;
+ const cell = &frame[@as(usize, where.body_y + row) * frame_cols + where.tx + x];
cell.text[0] = ' ';
cell.len = 1;
}
@@ -268,7 +266,8 @@ pub fn draw(
const Ctx = struct {
ti: *TerminalImages,
- p: *pardes.Pardes,
+ gpa: std.mem.Allocator,
+ out: *std.ArrayList(plain.Placement),
pane: u8,
serial: u32,
tx: u16,
@@ -286,7 +285,7 @@ const Ctx = struct {
const x0 = @max(dst.x, 0);
const x1 = @min(dst.x + dst.w, @as(i64, ctx.cols) * cw);
if (x1 <= x0) return;
- const rgba = ctx.ti.pixelsOf(ctx.p.gpa, img) orelse return;
+ const rgba = ctx.ti.pixelsOf(ctx.gpa, img) orelse return;
const first_row = @divFloor(@max(dst.y, 0), ch);
const last_row = @min(@divFloor(dst.y + dst.h - 1, ch), @as(i64, @intCast(ctx.rows_of.len)) - 1);
var v = first_row;
@@ -304,7 +303,7 @@ const Ctx = struct {
};
const c0: u16 = @intCast(@divFloor(x0, cw));
const c1: u16 = @intCast(@divFloor(x1 + cw - 1, cw));
- _ = ctx.p.appendPlacement(.{
+ ctx.out.append(ctx.gpa, .{
.pane = ctx.pane,
.raster = .of(rgba, img.width, img.height),
.src = piece,
@@ -318,7 +317,7 @@ const Ctx = struct {
.key = plain.Placement.keyOf(ctx.serial, img.id, @truncate(img.generation)),
.z = z,
.art = .{ .glyph = ctx.ti.petscii },
- });
+ }) catch {};
}
}
};
diff --git a/src/term/terminal.zig b/src/term/terminal.zig
index d11d1074..320ab6ad 100644
--- a/src/term/terminal.zig
+++ b/src/term/terminal.zig
@@ -13,12 +13,19 @@ const tagline = @import("../tagline.zig");
const Key = plain.Key;
const Pane = panes.Pane;
const Term = @import("../Term.zig");
-const BodyWalk = @import("../body_layer.zig").BodyWalk;
+const ansi = @import("../ansi.zig");
const screen_state = @import("screen_state.zig");
const EditText = panes.EditText;
const File = panes.File;
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;
const EditBuffer = panes.Text.EditBuffer;
const Snapshot = panes.Text.Snapshot;
@@ -367,56 +374,22 @@ pub const State = struct {
const GColor = ghostty_vt.color;
-const FilterPaletteKey = struct {
- bg: GColor.RGB,
- fg: GColor.RGB,
- base: [16]GColor.RGB,
-};
-
-pub const FilterPalette = LivePalette;
-
-const LivePalette = struct {
- key: ?FilterPaletteKey = null,
- colors: GColor.Palette = GColor.default,
-
- fn get(self: *LivePalette, theme: *const pardes.Theme) *const GColor.Palette {
- const bg = asGhostRgb(theme.bg orelse theme.tag_bg);
- const fg = asGhostRgb(theme.fg orelse theme.tag_fg);
- var base: [16]GColor.RGB = undefined;
- if (theme.palette) |palette| {
- for (&base, palette) |*dst, src| dst.* = asGhostRgb(src);
- } else {
- const synthesized = [16][3]u8{
- theme.bg orelse theme.tag_bg,
- theme.kw,
- theme.str,
- theme.num,
- theme.box,
- theme.sel_bg,
- theme.comment,
- theme.fg orelse theme.tag_fg,
- theme.lineno,
- theme.kw,
- theme.str,
- theme.num,
- theme.scroll_thumb,
- theme.sel_fg,
- theme.tag_fg,
- theme.fg orelse theme.tag_fg,
- };
- for (&base, synthesized) |*dst, src| dst.* = asGhostRgb(src);
- }
-
- const wanted: FilterPaletteKey = .{ .bg = bg, .fg = fg, .base = base };
- if (self.key) |old| if (std.meta.eql(old, wanted)) return &self.colors;
+// Projected colors below this contrast use the theme's more legible anchor.
+const min_contrast: f64 = 1.5;
- var seed = GColor.default;
- for (base, 0..) |rgb, i| seed[i] = rgb;
- self.colors = GColor.generate256Color(seed, .empty, bg, fg, false);
- self.key = wanted;
- return &self.colors;
- }
-};
+/// 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.
+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;
+}
fn asGhostRgb(rgb: [3]u8) GColor.RGB {
return .{ .r = rgb[0], .g = rgb[1], .b = rgb[2] };
@@ -449,6 +422,7 @@ pub fn grid(state: ?*const State) Term.Grid {
.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,
};
}
@@ -1054,16 +1028,6 @@ pub fn promptMoves(state: *State, row: i32, col: i32) ?Term.Moves {
/// 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.
-const PromptCut = union(enum) {
- /// show the row exactly as ghostty dumped it
- keep,
- /// show nothing at all
- blank,
- /// drop this many leading COLUMNS — the prompt — and keep the rest, which
- /// is what was typed at it
- cut: usize,
-};
-
fn promptCut(pin: ghostty_vt.Pin) PromptCut {
const cells = pin.cells(.all);
var cols: usize = 0;
@@ -1128,6 +1092,31 @@ fn dumpedBytes(pin: ghostty_vt.Pin, cell: *const ghostty_vt.Cell) usize {
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 {
@@ -1203,247 +1192,43 @@ pub fn viewport(state: *State, arena: std.mem.Allocator, cut: bool) ![]const []c
return vp;
}
-// Match surviving edit-buffer rows to their original terminal styles.
-const EditAnchors = struct {
- /// the buffer's own text, walked in order: a line the VIEWPORT skipped still
- /// consumes the row it came from, so the lines below it stay aligned
- text: []const u8 = &.{},
- at: usize = 0,
- shell: []const []const u8 = &.{},
- /// the covered span, absolute grid rows, as `[first, end)`
- first: usize = 0,
- end: usize = 0,
- lines: usize = 0,
- /// the line `at` names, and the first row still unclaimed
- idx: usize = 0,
- cursor: usize = 0,
- budget: usize = 0,
- active: bool = false,
-
- fn init(p: *Pardes, pane: *Pane, o: EditBuffer) EditAnchors {
- if (o.rows <= 0 or o.row < 0) return .{};
- const first: usize = @intCast(o.row);
- const screen = pane.terminal.?.vt.screens.active;
- const total = screen.pages.scrollbar().total;
- if (first >= total) return .{};
- const covered: usize = @intCast(o.rows);
- const count = @min(covered, total - first);
- const tl = screen.pages.pin(.{ .screen = .{ .y = @intCast(first) } }) orelse return .{};
- const br = screen.pages.pin(.{ .screen = .{
- .x = screen.pages.cols - 1,
- .y = @intCast(first + count - 1),
- } }) orelse return .{};
- const arena = p.scratch.allocator();
- var output: std.Io.Writer.Allocating = .init(arena);
- screen.dumpString(&output.writer, .{ .tl = tl, .br = br, .unwrap = false }) catch return .{};
- const shell = arena.alloc([]const u8, count) catch return .{};
- 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;
- }
- const lines = std.mem.count(u8, o.text, "\n") + 1;
- return .{
- .text = o.text,
- .shell = shell,
- .first = first,
- .end = first + count,
- .lines = lines,
- .cursor = first,
- .budget = covered + 4 * lines,
- .active = true,
- };
- }
-
- fn shellRow(a: *EditAnchors, idx: usize) ?Anchor {
- if (!a.active or idx >= a.lines) return null;
- var found: ?Anchor = null;
- while (a.idx <= idx) : (a.idx += 1) found = a.claim(a.nextLine() orelse return null);
- return found;
- }
-
- fn nextLine(a: *EditAnchors) ?[]const u8 {
- if (a.at > a.text.len) return null;
- const rest = a.text[a.at..];
- if (std.mem.indexOfScalar(u8, rest, '\n')) |n| {
- a.at += n + 1;
- return rest[0..n];
- }
- // The last line has no terminator; one past the end ends the walk.
- a.at = a.text.len + 1;
- return rest;
- }
-
- /// Where this line still stands over the grid, if anywhere.
- fn claim(a: *EditAnchors, line: []const u8) ?Anchor {
- const end = if (line.len == 0) @min(a.cursor + 1, a.end) else a.end;
- var k = a.cursor;
- while (k < end) : (k += 1) {
- if (a.budget == 0) return null;
- a.budget -= 1;
- if (!std.mem.eql(u8, line, a.shell[k - a.first])) continue;
- a.cursor = k + 1;
- return .{ .row = @intCast(k) };
- }
- if (a.cursor >= a.end) return null;
- const shell = a.shell[a.cursor - a.first];
- var p: usize = 0;
- while (p < line.len and p < shell.len and line[p] == shell[p]) p += 1;
- var s: usize = 0;
- const room = @min(line.len, shell.len) - p;
- while (s < room and line[line.len - 1 - s] == shell[shell.len - 1 - s]) s += 1;
- if (p + s == 0) return null;
- if (line.len != p + s and shell.len - (p + s) > shell.len / 2) return null;
- const row = a.cursor;
- if (s > 0 or p >= shell.len) a.cursor += 1;
- return .{ .row = @intCast(row), .prefix = p, .suffix = s, .shell_len = shell.len };
- }
-};
-
-const Anchor = struct {
- /// the row, absolute while it comes from `EditAnchors`, viewport once
- /// `recolorAnsi` has subtracted the walk's offset
- row: i32,
- prefix: usize = std.math.maxInt(usize),
- suffix: usize = 0,
- /// the row's own dumped length — what the suffix is measured from on the
- /// GRID side, where the edit may have changed the byte count
- shell_len: usize = 0,
-
- fn whole(an: Anchor) bool {
- return an.prefix == std.math.maxInt(usize);
- }
-};
-
-pub fn recolorAnsi(p: *Pardes, s: *Surface, pane: *Pane, r: pardes.Rect, tx: u16, tw: u16, body_h: u16, body: []const u8) void {
- // No emulator, no ANSI cells: the whole pass — and the 256-colour theme
- // projection behind it — is compiled out.
- if (pane.terminal == null) return;
- const body_y = p.bodyTop(pane, r);
- var filtered_storage: FilteredColors = undefined;
- const filtered: ?*FilteredColors = if (pane.tty_filter) blk: {
- const tz_filter = tracy.zone(@src(), "filterInit");
- defer tz_filter.end();
- filtered_storage = FilteredColors.init(p, &pane.terminal.?.vt);
- break :blk &filtered_storage;
+/// 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 = pane.terminal.?.vt.modes.get(.reverse_colors);
- const pages = &pane.terminal.?.vt.screens.active.pages;
- 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;
- var walk: BodyWalk = .init(pane);
- var lines = std.mem.splitScalar(u8, body, '\n');
- var vr: u16 = 0;
- while (walk.next()) |row| : (vr += 1) {
- if (vr >= body_h) break;
- // Before any early exit below, or the lines fall out of step with rows.
- const text = lines.next() orelse "";
- const anchor: Anchor = switch (row) {
- .edit => |e| blk: {
- if (anchors == null) anchors = .init(p, pane, pane.ovl.?);
- var an = anchors.?.shellRow(e.idx) orelse continue;
- an.row -= walk.goff;
- break :blk an;
- },
- .grid => |v| .{ .row = v },
- };
- const vi = anchor.row;
- if (vi < 0 or vi >= vp_rows) continue;
+ 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 cut: u16 = if (pane.body.mode == .tty) 0 else cut: {
- if (row_pin.rowAndCell().row.semantic_prompt == .none) break :cut 0;
- break :cut switch (promptCut(row_pin)) {
- .keep => 0,
- // Blanked end to end: the row shows nothing of the grid, so
- // projecting the prompt's own colours onto it would be a lie.
- .blank => continue,
- .cut => |n| std.math.cast(u16, n) orelse continue,
- };
- };
- if (cut > 0 and text.len == 0) continue;
- var at: usize = 0;
- var sc: u16 = 0;
- var gc: u16 = cut;
- var sb: usize = 0;
- const mine_from = @min(anchor.prefix, text.len);
- const mine_to = text.len - @min(anchor.suffix, text.len);
- var crossed = false;
- while (at < text.len and sc < tw) {
- const stop = modal.nextGrapheme(text, at);
- if (stop <= at) break;
- const span: u16 = if (sc + 1 < tw and s.at(tx + sc + 1, body_y + vr).len == 0) 2 else 1;
- if (at >= mine_from and at < mine_to) {
- sc += span;
- at = stop;
- continue;
- }
- if (at >= mine_to and !crossed) {
- crossed = true;
- const upto = anchor.shell_len - @min(anchor.suffix, anchor.shell_len);
- while (sb < upto) {
- const ci = cellAt(pages, row_pin, gc) orelse break;
- sb += dumpedBytes(row_pin, ci.cell);
- gc = std.math.add(u16, gc, 1) catch break;
- }
- }
- const want = stop - at;
- // Consume every cell that contributed to this grapheme. A cluster
- // ghostty split across several cells is still ONE printed glyph.
- var covered: usize = 0;
- var style: ?plain.CellStyle = null;
- while (covered < want) {
- const ci = cellAt(pages, row_pin, gc) orelse break;
- if (style == null and ci.cell.wide != .spacer_tail and ci.cell.wide != .spacer_head)
- style = cellStyle(p, ci, filtered, scnm);
- covered += dumpedBytes(row_pin, ci.cell);
- gc = std.math.add(u16, gc, 1) catch break;
- // A spacer contributes no bytes; without this the loop would
- // spin on a row that ends in one.
- if (covered == 0 and gc >= pane.cols) break;
- }
- while (cellAt(pages, row_pin, gc)) |t| {
- if (t.cell.wide != .spacer_tail) break;
- gc = std.math.add(u16, gc, 1) catch break;
- }
- if (style) |st| for (0..span) |k| {
- const cell = s.at(tx + sc + @as(u16, @intCast(k)), body_y + vr);
- if (cell.default and filtered == null) continue;
- cell.default = false;
- cell.style = st;
- };
- sb += covered;
- sc += span;
- at = stop;
- }
- var tail: ?plain.CellStyle = null;
- if (anchor.whole() or anchor.suffix > 0) {
- while (sc < tw) {
- const ci = cellAt(pages, row_pin, gc) orelse break;
- gc = std.math.add(u16, gc, 1) catch break;
- if (ci.cell.wide == .spacer_tail) continue;
- const cell = s.at(tx + sc, body_y + vr);
- sc += 1;
- const style = cellStyle(p, ci, filtered, scnm);
- tail = style;
- if (cell.default and filtered == null) continue;
- cell.default = false;
- cell.style = style;
- }
- if (tail) |style| while (sc < tw) : (sc += 1) {
- const cell = s.at(tx + sc, body_y + vr);
- if (cell.default and filtered == null) continue;
- cell.default = false;
- cell.style = style;
+ 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;
}
}
@@ -1464,11 +1249,11 @@ comptime {
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(p: *Pardes, ci: ghostty_vt.PageList.Cell, filtered: ?*FilteredColors, scnm: bool) plain.CellStyle {
+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| colors.fg(style) else ghostColor(p, style.fg_color, scnm),
- .bg = if (filtered) |colors| colors.bg(style, ci.cell) else ghostColor(p, style.bg_color, !scnm),
+ .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,
@@ -1479,7 +1264,7 @@ fn cellStyle(p: *Pardes, ci: ghostty_vt.PageList.Cell, filtered: ?*FilteredColor
.ul = @fromBackingInt(@intCast(@backingInt(style.flags.underline))),
};
if (filtered == null) switch (ci.cell.content_tag) {
- .bg_color_palette => cs.bg = palColor(p, ci.cell.content.color_palette.data),
+ .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 } };
@@ -1493,148 +1278,134 @@ fn asPardesColor(rgb: GColor.RGB) plain.Color {
return .{ .rgb = .{ rgb.r, rgb.g, rgb.b } };
}
-/// A program's colours mapped to the theme (Filter): a terminal's cells, or
-/// a +Pager's spans (`vt` null, the program's palette xterm's own).
-pub const FilteredColors = struct {
- source: GColor.Palette,
- target: *const GColor.Palette,
- theme_bg: GColor.RGB,
- theme_fg: GColor.RGB,
- dynamic_bg: ?GColor.RGB,
- dynamic_fg: ?GColor.RGB,
- default_bg: GColor.RGB,
- /// What a foreground too near `default_bg` becomes instead.
- fallback_fg: GColor.RGB,
- default_bg_luminance: f64,
- fg_for_palette: [256]plain.Color = undefined,
- bg_for_palette: [256]plain.Color = undefined,
- /// The two answers for a cell that names no colour of its own.
- fg_default: plain.Color = undefined,
- bg_default: plain.Color = undefined,
- cache_rgb: [256]GColor.RGB = undefined,
- cache_key: [256]u8 = undefined,
- cache_valid: [256]bool = @splat(false),
-
- pub fn init(p: *Pardes, vt: ?*const ghostty_vt.Terminal) FilteredColors {
- var source = GColor.default;
- if (vt) |t| {
- for (&source, 0..) |*rgb, i|
- rgb.* = t.colorForXterm(.{ .palette = @intCast(i) }) orelse rgb.*;
- }
- const theme = p.theme();
- var theme_bg = asGhostRgb(theme.bg orelse theme.tag_bg);
- var theme_fg = asGhostRgb(theme.fg orelse theme.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: FilteredColors = .{
- .source = source,
- .target = p.tty_filter_palette.get(theme),
- .theme_bg = theme_bg,
- .theme_fg = theme_fg,
- .dynamic_bg = dynamic_bg,
- .dynamic_fg = dynamic_fg,
- .default_bg = theme_bg,
- .fallback_fg = theme_fg,
- .default_bg_luminance = luminanceOf(theme_bg),
- };
- if (dynamic_bg) |rgb| self.default_bg = self.keyedRgb(rgb);
- self.default_bg_luminance = luminanceOf(self.default_bg);
- if (self.theme_bg.contrast(self.default_bg) > self.theme_fg.contrast(self.default_bg))
- self.fallback_fg = self.theme_bg;
+fn asTriple(rgb: GColor.RGB) [3]u8 {
+ return .{ rgb.r, rgb.g, rgb.b };
+}
- self.fg_default = asPardesColor(self.legible(
- if (self.dynamic_fg) |rgb| self.keyedRgb(rgb) else self.theme_fg,
- ));
- self.bg_default = asPardesColor(self.default_bg);
- for (&self.source, 0..) |current, i| {
- const idx: u8 = @intCast(i);
- const mapped = self.paletteRgb(idx, current);
- self.fg_for_palette[idx] = asPardesColor(self.legible(mapped));
- self.bg_for_palette[idx] = asPardesColor(mapped);
- }
- return self;
+/// 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.*;
}
-
- fn fg(self: *FilteredColors, style: ghostty_vt.Style) plain.Color {
- return switch (style.fg_color) {
- .none => self.fg_default,
- .palette => |idx| self.fg_for_palette[idx],
- .rgb => asPardesColor(self.legible(self.keyedRgb(style.fg(.{
- .default = self.dynamic_fg orelse self.theme_fg,
- .palette = &self.source,
- .bold = null,
- })))),
- };
+ 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);
- fn bg(self: *FilteredColors, 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(self.keyedRgb(style.bg(cell, &self.source).?));
+ 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;
+}
- /// A +Pager span's colour (Term.page), as `fg` and `bg` map a cell's.
- pub fn spanColor(self: *FilteredColors, 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 = self.keyedRgb(asGhostRgb(rgb));
- break :blk asPardesColor(if (is_bg) keyed else self.legible(keyed));
- },
- };
- }
+/// 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 legible(self: *const FilteredColors, rgb: GColor.RGB) GColor.RGB {
- if (contrastOf(luminanceOf(rgb), self.default_bg_luminance) >=
- config.tty_filter_min_contrast) return rgb;
- return self.fallback_fg;
- }
+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 paletteRgb(self: *FilteredColors, idx: u8, current: GColor.RGB) GColor.RGB {
- if (current.eql(GColor.default[idx])) return self.target[idx];
- return self.keyedRgb(current);
+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).?));
+}
- fn keyedRgb(self: *FilteredColors, rgb: GColor.RGB) GColor.RGB {
- return self.target[self.nearestKey(rgb)];
- }
+/// 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));
+ },
+ };
+}
- fn nearestKey(self: *FilteredColors, 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 self.cache_rgb[slot].eql(rgb))
- return self.cache_key[slot];
+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);
+}
- 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);
- }
+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);
+}
+
+fn keyedRgb(self: *Filter, rgb: GColor.RGB) GColor.RGB {
+ return asGhostRgb(self.target[nearestKey(self, rgb)]);
+}
+
+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] = rgb;
- self.cache_key[slot] = best;
- self.cache_valid[slot] = true;
- return best;
}
-};
+ 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);
@@ -1669,23 +1440,17 @@ fn colorDistance(a: GColor.RGB, b: GColor.RGB) u32 {
return @intCast(dr * dr + dg * dg + db * db);
}
-pub fn palColor(p: *Pardes, idx: u8) plain.Color {
- if (p.theme().palette) |pal| if (idx < 16) return .{ .rgb = pal[idx] };
- return .{ .index = idx };
-}
-
-fn ghostColor(p: *Pardes, color: ghostty_vt.Style.Color, is_bg: bool) plain.Color {
+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) p.theme().bg else p.theme().fg;
+ const t = if (is_bg) ink.bg else ink.fg;
break :blk if (t) |c| .{ .rgb = c } else .default;
},
- .palette => |idx| palColor(p, idx),
+ .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 {
@@ -1715,39 +1480,30 @@ pub fn hasImages(maybe: ?*const State) bool {
return state.vt.screens.active.kitty_images.images.count() > 0;
}
-/// Draw the pane's kitty graphics images over its body rows (after the
-/// rows and their colours: placeholder cells are blanked here).
-pub fn drawImages(p: *Pardes, s: *Surface, pane: *Pane, id: usize, tx: u16, tw: u16, body_y: u16, body_h: u16) void {
+/// 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 state = pane.terminal orelse return;
const screen = state.vt.screens.active;
- 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(grid(state).len, rows_of.len);
- @memset(rows_of[0..vp_rows], null);
+ const vp_rows = @min(at.rows_of.len, rows_of.len);
var any_placeholder = false;
- var walk: BodyWalk = .init(pane);
- var vr: u16 = 0;
- while (walk.next()) |row| : (vr += 1) {
- if (vr >= body_h) break;
- const vi = switch (row) {
- .grid => |v| v,
- .edit => continue,
- };
- if (vi < 0 or vi >= vp_rows) continue;
+ 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;
- // A prompt row outside tty mode is cut or hidden: its columns are
- // not the grid's.
- if (pane.body.mode != .tty and flags.semantic_prompt != .none) continue;
+ if (!at.tty_mode and flags.semantic_prompt != .none) continue;
any_placeholder = any_placeholder or flags.kitty_virtual_placeholder;
- rows_of[@intCast(vi)] = vr;
+ 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(p, s, &state.vt, @intCast(id), pane.serial, tx, body_y, @min(tw, pane.cols), rows_of[0..vp_rows]);
+ state.images.draw(gpa, &state.vt, at, rows_of[0..vp_rows], out, frame, frame_cols);
}
/// Every byte the core wrote to each pane's pty since the last call, `\n`
@@ -2068,11 +1824,11 @@ test "terminal Filter keys indexed truecolor OSC and background-only cells throu
_ = frame.reset(.retain_capacity);
const filtered = try p.render(frame.allocator());
var expected_cache: FilterPalette = .{};
- const expected = expected_cache.get(p.theme());
- try testing.expectEqual(asPardesColor(expected[1]), filtered.at(tx, body_y).style.fg);
- try testing.expectEqual(asPardesColor(expected[196]), filtered.at(tx + 1, body_y).style.fg);
+ const expected = filterPalette(&expected_cache, &ansi.inkOf(p.theme()));
+ try testing.expectEqual(asPardesColor(asGhostRgb(expected[1])), filtered.at(tx, body_y).style.fg);
+ try testing.expectEqual(asPardesColor(asGhostRgb(expected[196])), filtered.at(tx + 1, body_y).style.fg);
try testing.expectEqual(filtered.at(tx + 1, body_y).style.fg, filtered.at(tx + 2, body_y).style.fg);
- try testing.expectEqual(asPardesColor(expected[25]), filtered.at(tx + 3, body_y).style.bg);
+ try testing.expectEqual(asPardesColor(asGhostRgb(expected[25])), filtered.at(tx + 3, body_y).style.bg);
try testing.expectEqual(filtered.at(tx + 3, body_y).style.bg, filtered.at(tx + 4, body_y).style.bg);
const attrs = filtered.at(tx + 5, body_y).style;
@@ -2087,8 +1843,8 @@ test "terminal Filter keys indexed truecolor OSC and background-only cells throu
const erased = pane.terminal.?.vt.screens.active.pages.getCell(.{ .viewport = .{ .x = 6, .y = 0 } }).?;
try testing.expectEqual(.bg_color_palette, erased.cell.content_tag);
- try testing.expectEqual(asPardesColor(expected[25]), filtered.at(tx + 6, body_y).style.bg);
- try testing.expectEqual(asPardesColor(expected[2]), filtered.at(tx, body_y + 1).style.fg);
+ try testing.expectEqual(asPardesColor(asGhostRgb(expected[25])), filtered.at(tx + 6, body_y).style.bg);
+ try testing.expectEqual(asPardesColor(asGhostRgb(expected[2])), filtered.at(tx, body_y + 1).style.fg);
try testing.expectEqual(filtered.at(tx, body_y + 1).style, filtered.at(tx + 1, body_y + 1).style);
// A filtered terminal never delegates either colour to a backend palette,
// including cells which were empty/default before the pass.
@@ -2113,7 +1869,7 @@ test "terminal Filter keys indexed truecolor OSC and background-only cells throu
try testing.expect(osc_red.eql(pane.terminal.?.vt.colorForXterm(.{ .palette = 1 }).?));
_ = frame.reset(.retain_capacity);
const osc_palette = try p.render(frame.allocator());
- try testing.expectEqual(asPardesColor(expected[196]), osc_palette.at(tx, body_y).style.fg);
+ try testing.expectEqual(asPardesColor(asGhostRgb(expected[196])), osc_palette.at(tx, body_y).style.fg);
// Dynamic default foreground/background colours key every default cell,
// including the otherwise blank end of the row.
@@ -2126,19 +1882,19 @@ test "terminal Filter keys indexed truecolor OSC and background-only cells throu
_ = frame.reset(.retain_capacity);
const dynamic = try p.render(frame.allocator());
const edge = dynamic.at(tx + r.w - config.GUTTER - 1, body_y + 2).style;
- try testing.expectEqual(asPardesColor(expected[196]), edge.fg);
- try testing.expectEqual(asPardesColor(expected[59]), edge.bg);
+ try testing.expectEqual(asPardesColor(asGhostRgb(expected[196])), edge.fg);
+ try testing.expectEqual(asPardesColor(asGhostRgb(expected[59])), edge.bg);
const explicit_before_reverse = dynamic.at(tx, body_y).style.fg;
- try testing.expectEqual(asPardesColor(expected[196]), explicit_before_reverse);
+ try testing.expectEqual(asPardesColor(asGhostRgb(expected[196])), explicit_before_reverse);
p.update(.{ .output = .{ .pane = 0, .bytes = "\x1b[?5h" } });
_ = frame.reset(.retain_capacity);
const reversed = try p.render(frame.allocator());
const reversed_blank = reversed.at(tx + r.w - config.GUTTER - 1, body_y + 2).style;
- try testing.expectEqual(asPardesColor(expected[59]), reversed_blank.fg);
- try testing.expectEqual(asPardesColor(expected[196]), reversed_blank.bg);
+ try testing.expectEqual(asPardesColor(asGhostRgb(expected[59])), reversed_blank.fg);
+ try testing.expectEqual(asPardesColor(asGhostRgb(expected[196])), reversed_blank.bg);
const reversed_explicit = reversed.at(tx, body_y).style;
- try testing.expectEqual(asPardesColor(expected[196]), reversed_explicit.bg);
+ try testing.expectEqual(asPardesColor(asGhostRgb(expected[196])), reversed_explicit.bg);
try testing.expectEqual(plain.Color{ .rgb = p.theme().bg.? }, reversed_explicit.fg);
try testing.expect(!std.meta.eql(reversed_explicit.fg, reversed_explicit.bg));
@@ -2146,8 +1902,8 @@ test "terminal Filter keys indexed truecolor OSC and background-only cells throu
_ = frame.reset(.retain_capacity);
const unreversed = try p.render(frame.allocator());
const unreversed_blank = unreversed.at(tx + r.w - config.GUTTER - 1, body_y + 2).style;
- try testing.expectEqual(asPardesColor(expected[196]), unreversed_blank.fg);
- try testing.expectEqual(asPardesColor(expected[59]), unreversed_blank.bg);
+ try testing.expectEqual(asPardesColor(asGhostRgb(expected[196])), unreversed_blank.fg);
+ try testing.expectEqual(asPardesColor(asGhostRgb(expected[59])), unreversed_blank.bg);
// The cache is keyed by values, not a theme name. Replacing a custom
// theme in place immediately recolours already-rendered indexed cells.
@@ -2171,9 +1927,9 @@ test "terminal Filter keeps extended keys dark-to-light on a light theme" {
defer p.deinit();
try std.testing.expectEqualStrings("acme", p.theme().name);
var cache: FilterPalette = .{};
- const palette = cache.get(p.theme());
- try std.testing.expect(palette[16].eql(asGhostRgb(p.theme().fg.?)));
- try std.testing.expect(palette[231].eql(asGhostRgb(p.theme().bg.?)));
+ const palette = filterPalette(&cache, &ansi.inkOf(p.theme()));
+ try std.testing.expect(asGhostRgb(palette[16]).eql(asGhostRgb(p.theme().fg.?)));
+ try std.testing.expect(asGhostRgb(palette[231]).eql(asGhostRgb(p.theme().bg.?)));
}
test "terminal Filter preserves exact palette-null light theme default roles" {
@@ -2222,23 +1978,23 @@ test "terminal Filter maps the default roles before it maps anything else" {
// the null-page fallback that only the legacy dark theme exercises.
for (0..9) |t| {
p.settings.theme = @intCast(t);
- const stage_one = FilteredColors.init(p, &pane.terminal.?.vt);
+ const stage_one = filterOf(&ansi.inkOf(p.theme()), &p.tty_filter_palette, &pane.terminal.?.vt);
// `dark` declares no background of its own, which is exactly why the
// resolver reads the tag colours as the fallback rather than `.?`.
const theme = p.theme();
- try testing.expect(stage_one.theme_bg.eql(asGhostRgb(theme.bg orelse theme.tag_bg)));
- try testing.expect(stage_one.theme_fg.eql(asGhostRgb(theme.fg orelse theme.tag_fg)));
+ try testing.expect(asGhostRgb(stage_one.theme_bg).eql(asGhostRgb(theme.bg orelse theme.tag_bg)));
+ try testing.expect(asGhostRgb(stage_one.theme_fg).eql(asGhostRgb(theme.fg orelse theme.tag_fg)));
// With no OSC 11 in play the mapped page IS that anchor, and the
// fallback is the other one: a background never contrasts with itself.
- try testing.expect(stage_one.default_bg.eql(stage_one.theme_bg));
- try testing.expect(stage_one.fallback_fg.eql(stage_one.theme_fg));
+ try testing.expect(asGhostRgb(stage_one.default_bg).eql(asGhostRgb(stage_one.theme_bg)));
+ try testing.expect(asGhostRgb(stage_one.fallback_fg).eql(asGhostRgb(stage_one.theme_fg)));
}
p.settings.theme = 0;
p.update(.{ .output = .{ .pane = 0, .bytes = "\x1b]11;#5f5f5f\x1b\\" } });
- var moved = FilteredColors.init(p, &pane.terminal.?.vt);
- try testing.expect(!moved.default_bg.eql(moved.theme_bg));
- try testing.expect(moved.default_bg.eql(moved.keyedRgb(.{ .r = 0x5f, .g = 0x5f, .b = 0x5f })));
+ var moved = filterOf(&ansi.inkOf(p.theme()), &p.tty_filter_palette, &pane.terminal.?.vt);
+ try testing.expect(!asGhostRgb(moved.default_bg).eql(asGhostRgb(moved.theme_bg)));
+ try testing.expect(asGhostRgb(moved.default_bg).eql(keyedRgb(&moved, .{ .r = 0x5f, .g = 0x5f, .b = 0x5f })));
}
test "terminal Filter refuses a foreground that would collapse onto the page" {
@@ -2261,16 +2017,16 @@ test "terminal Filter refuses a foreground that would collapse onto the page" {
for (0..9) |t| {
p.settings.theme = @intCast(t);
- var fc = FilteredColors.init(p, &pane.terminal.?.vt);
- const page = asPardesColor(fc.default_bg);
- const rescued = asPardesColor(fc.fallback_fg);
+ var fc = filterOf(&ansi.inkOf(p.theme()), &p.tty_filter_palette, &pane.terminal.?.vt);
+ const page = asPardesColor(asGhostRgb(fc.default_bg));
+ const rescued = asPardesColor(asGhostRgb(fc.fallback_fg));
_ = frame.reset(.retain_capacity);
const g = try p.render(frame.allocator());
// The colour each of the three would have been given with no floor.
- const raw_white = fc.keyedRgb(.{ .r = 255, .g = 255, .b = 255 });
- const raw_black = fc.paletteRgb(0, GColor.default[0]);
- const raw_red = fc.paletteRgb(1, GColor.default[1]);
+ const raw_white = keyedRgb(&fc, .{ .r = 255, .g = 255, .b = 255 });
+ const raw_black = paletteRgb(&fc, 0, GColor.default[0]);
+ const raw_red = paletteRgb(&fc, 1, GColor.default[1]);
for ([_]struct { at: u16, raw: GColor.RGB }{
.{ .at = 0, .raw = raw_white },
@@ -2279,7 +2035,7 @@ test "terminal Filter refuses a foreground that would collapse onto the page" {
}) |case| {
const cell = g.at(tx + case.at, body_y).style;
try testing.expectEqual(page, cell.bg);
- if (case.raw.contrast(fc.default_bg) < config.tty_filter_min_contrast) {
+ if (case.raw.contrast(asGhostRgb(fc.default_bg)) < min_contrast) {
// Refused: the projection's answer is not painted, the anchor is.
try testing.expectEqual(rescued, cell.fg);
try testing.expect(!std.meta.eql(cell.fg, cell.bg));
@@ -2289,18 +2045,18 @@ test "terminal Filter refuses a foreground that would collapse onto the page" {
}
// Either way a filtered cell delegates neither colour to a backend.
switch (cell.fg) {
- .rgb => |ink| try testing.expect(asGhostRgb(ink).contrast(fc.default_bg) >=
- config.tty_filter_min_contrast),
+ .rgb => |ink| try testing.expect(asGhostRgb(ink).contrast(asGhostRgb(fc.default_bg)) >=
+ min_contrast),
else => return error.FilteredForegroundWasNotRgb,
}
}
// At least one of the three has to have been a real collapse, or this
// theme proved nothing: white on the light theme, black on the dark.
- try testing.expect(raw_white.contrast(fc.default_bg) < config.tty_filter_min_contrast or
- raw_black.contrast(fc.default_bg) < config.tty_filter_min_contrast);
+ try testing.expect(raw_white.contrast(asGhostRgb(fc.default_bg)) < min_contrast or
+ raw_black.contrast(asGhostRgb(fc.default_bg)) < min_contrast);
// A saturated red is never the page on any curated theme.
- try testing.expect(raw_red.contrast(fc.default_bg) >= config.tty_filter_min_contrast);
+ try testing.expect(raw_red.contrast(asGhostRgb(fc.default_bg)) >= min_contrast);
}
}
@@ -2313,20 +2069,21 @@ test "terminal Filter holds every projected foreground off the page" {
for (0..9) |t| {
p.settings.theme = @intCast(t);
- var fc = FilteredColors.init(p, &pane.terminal.?.vt);
+ var fc = filterOf(&ansi.inkOf(p.theme()), &p.tty_filter_palette, &pane.terminal.?.vt);
var refused: usize = 0;
- for (fc.target, 0..) |projected, slot| {
- const ink = fc.legible(projected);
- try testing.expect(ink.contrast(fc.default_bg) >= config.tty_filter_min_contrast);
+ for (fc.target, 0..) |projected_triple, slot| {
+ const projected = asGhostRgb(projected_triple);
+ const ink = legible(&fc, projected);
+ try testing.expect(ink.contrast(asGhostRgb(fc.default_bg)) >= min_contrast);
if (!ink.eql(projected)) {
refused += 1;
- try testing.expect(ink.eql(fc.fallback_fg));
+ try testing.expect(ink.eql(asGhostRgb(fc.fallback_fg)));
// Only ever refused for being too near the page.
- try testing.expect(projected.contrast(fc.default_bg) < config.tty_filter_min_contrast);
+ try testing.expect(projected.contrast(asGhostRgb(fc.default_bg)) < min_contrast);
}
// The key a background asks for is handed back untouched, including
// the one whose value is the page itself.
- try testing.expect(fc.keyedRgb(GColor.default[slot]).eql(fc.target[fc.nearestKey(GColor.default[slot])]));
+ try testing.expect(keyedRgb(&fc, GColor.default[slot]).eql(asGhostRgb(fc.target[nearestKey(&fc, GColor.default[slot])])));
}
// Every curated theme owns at least one collapsing key — that is why
// the floor exists — and the floor must not be flattening the palette.