summaryrefslogtreecommitdiff
path: root/src/File.zig
diff options
context:
space:
mode:
Diffstat (limited to 'src/File.zig')
-rw-r--r--src/File.zig120
1 files changed, 44 insertions, 76 deletions
diff --git a/src/File.zig b/src/File.zig
index 2a7d5b40..64614191 100644
--- a/src/File.zig
+++ b/src/File.zig
@@ -616,6 +616,29 @@ pub fn setContent(p: *Pardes, f: *State, new: []u8) void {
setContentSpan(p, f, new, null);
}
+/// `rows`, a row a line of the text from its first (where each points, how
+/// it is coloured: locations.Row), made the pane's, taken: the one way a
+/// pane's rows are set, by a producer in the editor (Output.fillRows, a
+/// query pane) or from outside (the pane's `rows` file). RowsMismatch, the
+/// rows still the caller's, for rows the text cannot hold: more of them
+/// than it has lines, or an offset or styles past its line's end. Rows
+/// equal to the pane's keep its painting; others drop it, to be painted
+/// from them. An edit of the text drops them (setContentSpan).
+pub fn setRows(p: *Pardes, f: *State, rows: []locations.Row) error{RowsMismatch}!void {
+ var lines = std.mem.splitScalar(u8, f.content, '\n');
+ for (rows) |row| {
+ const line = lines.next() orelse return error.RowsMismatch;
+ if (row.location_end > line.len or row.code_start > line.len or row.colors.len > line.len - row.code_start) return error.RowsMismatch;
+ }
+ if (locations.equalRows(f.location_rows, rows)) return locations.freeRows(p.gpa, rows);
+ locations.freeRows(p.gpa, f.location_rows);
+ f.location_rows = rows;
+ if (f.highlights.len > 0) p.tree_sitter_gpa.free(f.highlights);
+ f.highlights = &.{};
+ f.highlight_start = 0;
+ f.syntax_dirty = true;
+}
+
/// `setContent` for a splice that knows what it left alone at either end,
/// so it is not found again by comparing the whole text. The edit is what
/// lies between them, made by `edit`, which takes `new`, a whole text its
@@ -1791,59 +1814,6 @@ fn fillBody(dst: ?[]u8, pane: *Pane, f: *State, width: usize, record_wrap: bool)
const SynStyle = struct { fg: [3]u8, bold: bool };
-/// How added and removed diff lines are told apart in every theme: a row
-/// ground a little way from the page toward green or red (the theme's own
-/// ANSI green and red where it has a palette), and the prefix column in
-/// that hue, pushed toward the ink until it reads on that ground. The
-/// syntax colours are drawn over the ground unchanged.
-pub const DiffTints = struct {
- added_bg: [3]u8,
- removed_bg: [3]u8,
- /// The words a changed line changed (hunks.zig), on a stronger ground.
- added_emph_bg: [3]u8,
- removed_emph_bg: [3]u8,
- /// A +Diff line added or removed whole: a faint ground.
- added_line_bg: [3]u8,
- removed_line_bg: [3]u8,
- added_fg: [3]u8,
- removed_fg: [3]u8,
-
- pub fn of(p: *Pardes) DiffTints {
- const th = p.theme();
- const page = th.bg orelse th.tag_bg;
- const ink = th.fg orelse th.tag_fg;
- const green: [3]u8 = if (th.palette) |pal| pal[2] else .{ 0x2e, 0xa0, 0x43 };
- const red: [3]u8 = if (th.palette) |pal| pal[1] else .{ 0xcf, 0x22, 0x2e };
- const added_bg = Colors.mixOklab(page, green, 0.18);
- const removed_bg = Colors.mixOklab(page, red, 0.18);
- return .{
- .added_bg = added_bg,
- .removed_bg = removed_bg,
- .added_emph_bg = Colors.mixOklab(page, green, 0.28),
- .removed_emph_bg = Colors.mixOklab(page, red, 0.28),
- .added_line_bg = Colors.mixOklab(page, green, 0.07),
- .removed_line_bg = Colors.mixOklab(page, red, 0.07),
- .added_fg = legible(green, ink, added_bg),
- .removed_fg = legible(red, ink, removed_bg),
- };
- }
-
- fn legible(hue: [3]u8, ink: [3]u8, ground: [3]u8) [3]u8 {
- var fg = hue;
- var step: usize = 0;
- while (step < 4 and Colors.contrast(fg, ground) < 3) : (step += 1) fg = Colors.mixOklab(fg, ink, 0.4);
- return fg;
- }
-
- /// The row ground and prefix ink for a line's style byte, if it is an
- /// added or removed line.
- pub fn forStyle(t: *const DiffTints, style: u8) ?struct { bg: [3]u8, fg: [3]u8, emph_bg: [3]u8, line_bg: [3]u8 } {
- if (style & syntax.diff_added != 0) return .{ .bg = t.added_bg, .fg = t.added_fg, .emph_bg = t.added_emph_bg, .line_bg = t.added_line_bg };
- if (style & syntax.diff_removed != 0) return .{ .bg = t.removed_bg, .fg = t.removed_fg, .emph_bg = t.removed_emph_bg, .line_bg = t.removed_line_bg };
- return null;
- }
-};
-
fn synStyle(p: *Pardes, sy: syntax.Syn) ?SynStyle {
return .{ .fg = Colors.synInk(p.theme(), sy) orelse return null, .bold = false };
}
@@ -1858,12 +1828,9 @@ pub fn recolorSyntax(p: *Pardes, s: *Surface, pane: *Pane, f: *State, r: pardes.
const prefix_width = gutterWidth(pane);
const tz_recolor = tracy.zone(@src(), "synRecolor");
defer tz_recolor.end();
- // A diff's rows, and a +Diff's (hunks.zig): their markers coloured.
- // A diff's whole row is tinted; a +Diff tints only the words a
- // changed line changed.
- const algo = pane.colorAlgo();
- const tints: ?DiffTints = if ((algo == .diff or algo == .locations) and highlights.len > 0) DiffTints.of(p) else null;
- const row_tint = algo == .diff;
+ // 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;
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);
@@ -1901,19 +1868,20 @@ pub fn recolorSyntax(p: *Pardes, s: *Surface, pane: *Pane, f: *State, r: pardes.
const metadata: ?locations.Row = if (row_index < f.location_rows.len) f.location_rows[row_index] else null;
const decoration = Output.decorateRow(f.output, line, metadata);
const chrome: ?*const pardes.ChromeTheme = if (decoration.plain()) null else p.bodyChrome();
- // An added or removed line's row, every wrapped row of it, is tinted.
- const tint = if (tints) |*t| if (base >= highlight_start and base - highlight_start < highlights.len)
- t.forStyle(highlights[base - highlight_start])
- else
- null else null;
+ // The row's first byte: its hue and its ground, on every wrapped
+ // row of it (syntax.ground_add).
+ const lead: u8 = if (base >= highlight_start and base - highlight_start < highlights.len) highlights[base - highlight_start] else 0;
+ const tint: ?Colors.Grounds.Ground = if (lead & (syntax.ground_add | syntax.ground_del) == 0) null else (grounds orelse ground: {
+ grounds = .of(p.theme());
+ break :ground grounds.?;
+ }).forStyle(lead);
if (tint) |t| if (prefix_width < tw) {
- // A +Diff line added or removed whole: faintly (hunks.zig).
- const whole = highlights[base - highlight_start] & syntax.diff_whole != 0;
- if (row_tint or whole) s.tint(tx + @as(u16, @intCast(prefix_width)), body_y + vr, tw -| @as(u16, @intCast(prefix_width)), if (row_tint) t.bg else t.line_bg, null);
+ const ground: ?[3]u8 = if (lead & syntax.ground_emph != 0) t.row else if (lead & syntax.ground_line != 0) t.line else null;
+ if (ground) |g| s.tint(tx + @as(u16, @intCast(prefix_width)), body_y + vr, tw -| @as(u16, @intCast(prefix_width)), g, null);
};
- // A +Pager's own colours (Term.page) on every row but one the diff
- // look tints: an added or removed line is drawn as pardes draws a
- // diff, and git's red and green on it would only fight the tint.
+ // A +Pager's own colours (Term.page) on every row but one in a hue:
+ // an added or removed line is drawn as pardes draws a diff, and
+ // git's red and green on it would only fight the tint.
var span_at = if (tint != null) spans.len else std.sort.partitionPoint(pardes.Term.Span, spans, base + hs, struct {
fn before(at: usize, span: pardes.Term.Span) bool {
return span.end <= at;
@@ -1947,7 +1915,7 @@ pub fn recolorSyntax(p: *Pardes, s: *Surface, pane: *Pane, f: *State, r: pardes.
const hidx = idx - highlight_start;
if (hidx < highlights.len) {
if (if (tint != null and hs + c == 0)
- SynStyle{ .fg = tint.?.fg, .bold = true }
+ SynStyle{ .fg = tint.?.ink, .bold = true }
else
synStyle(p, @fromBackingInt(@intCast(highlights[hidx] & syntax.syn_bits)))) |ss|
{
@@ -1959,10 +1927,10 @@ pub fn recolorSyntax(p: *Pardes, s: *Surface, pane: *Pane, f: *State, r: pardes.
cell.style.bold = ss.bold;
}
}
- if (tint) |t| if (highlights[hidx] & syntax.diff_emph != 0) {
+ if (tint) |t| if (highlights[hidx] & syntax.ground_emph != 0 and hs + c > 0) {
var fill: usize = 0;
while (fill < cells and prefix_width + screen_c + fill < tw) : (fill += 1)
- s.at(tx + @as(u16, @intCast(prefix_width + screen_c + fill)), body_y + vr).style.bg = .{ .rgb = t.emph_bg };
+ s.at(tx + @as(u16, @intCast(prefix_width + screen_c + fill)), body_y + vr).style.bg = .{ .rgb = t.emph };
};
}
}
@@ -2131,7 +2099,7 @@ pub fn recolorDiffOutput(p: *Pardes, s: *Surface, pane: *Pane, r: pardes.Rect, t
}
if (lo > hi) return;
const styles = syntax.highlightDiffRows(arena, flat, lo, hi, true) catch return;
- const tints = DiffTints.of(p);
+ const tints: Colors.Grounds = .of(p.theme());
const ink = p.theme().fg orelse p.theme().tag_fg;
const body_y = p.bodyTop(pane, r);
shown = std.mem.splitScalar(u8, body, '\n');
@@ -2140,7 +2108,7 @@ pub fn recolorDiffOutput(p: *Pardes, s: *Surface, pane: *Pane, r: pardes.Rect, t
const view = maybe orelse continue;
const base = @intFromPtr(rows[view.row].ptr) - flat_start - lo;
const tint = if (base < styles.len) tints.forStyle(styles[base]) else null;
- if (tint) |t| s.tint(tx, body_y + @as(u16, @intCast(vr)), tw, t.bg, null);
+ if (tint) |t| s.tint(tx, body_y + @as(u16, @intCast(vr)), tw, t.row, null);
var c: usize = 0;
var screen_c: usize = 0;
while (c < line.len and screen_c < tw) {
@@ -2152,7 +2120,7 @@ pub fn recolorDiffOutput(p: *Pardes, s: *Surface, pane: *Pane, r: pardes.Rect, t
// On an added or removed line, what the program coloured red or
// green is the tint's to say now: its code takes the page's ink.
const paint: ?SynStyle = if (tint != null and prefix)
- .{ .fg = tint.?.fg, .bold = true }
+ .{ .fg = tint.?.ink, .bold = true }
else if (synStyle(p, @fromBackingInt(@intCast(style & syntax.syn_bits)))) |ss|
ss
else if (tint != null)