//! 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); } };