634 lines
19 KiB
Zig
634 lines
19 KiB
Zig
//! The terminal widget: draws a libghostty-vt screen with Cairo/Pango and
|
|
//! feeds user input back to the session.
|
|
//!
|
|
//! Rendering is deliberately simple. Ghostty itself uses a GPU renderer with
|
|
//! a glyph atlas; here we walk the visible rows every frame and hand runs of
|
|
//! same-styled text to Pango. That is far slower in principle, but a terminal
|
|
//! grid is small and this keeps the proof of concept readable.
|
|
|
|
const std = @import("std");
|
|
const cairo = @import("cairo");
|
|
const gdk = @import("gdk");
|
|
const gobject = @import("gobject");
|
|
const gtk = @import("gtk");
|
|
const pango = @import("pango");
|
|
const pangocairo = @import("pangocairo");
|
|
const vt = @import("ghostty-vt");
|
|
|
|
const keymap = @import("key.zig");
|
|
const theme = @import("theme.zig");
|
|
const Pane = @import("Pane.zig");
|
|
const Session = @import("Session.zig");
|
|
|
|
const Terminal = @This();
|
|
|
|
/// Pango measures in 1/1024ths of a device unit.
|
|
const pango_scale: f64 = @floatFromInt(pango.SCALE);
|
|
|
|
/// The font we render with. Any monospace family the system provides.
|
|
const font_spec = "monospace 11";
|
|
|
|
/// Padding between the grid and the widget edge, in pixels.
|
|
const pad: f64 = 8;
|
|
|
|
alloc: std.mem.Allocator,
|
|
session: *Session,
|
|
|
|
area: *gtk.DrawingArea,
|
|
font: *pango.FontDescription,
|
|
|
|
/// Cell geometry derived from the font metrics.
|
|
cell_w: f64 = 8,
|
|
cell_h: f64 = 16,
|
|
ascent: f64 = 12,
|
|
|
|
/// Scratch buffer for building the UTF-8 of a single text run.
|
|
run_buf: std.ArrayListUnmanaged(u8) = .empty,
|
|
|
|
/// Called when the session's title changes, so the owner can retitle the tab.
|
|
on_title: *const fn (ctx: ?*anyopaque, title: []const u8) void,
|
|
on_exit: *const fn (ctx: ?*anyopaque) void,
|
|
|
|
/// Called when this terminal takes keyboard focus.
|
|
on_focus: *const fn (ctx: ?*anyopaque) void,
|
|
|
|
ctx: ?*anyopaque = null,
|
|
|
|
/// What a layout can specify for a terminal pane.
|
|
pub const Options = Session.Options;
|
|
|
|
pub fn create(
|
|
alloc: std.mem.Allocator,
|
|
opts: Options,
|
|
cbs: Pane.Callbacks,
|
|
) !*Terminal {
|
|
const self = try alloc.create(Terminal);
|
|
errdefer alloc.destroy(self);
|
|
|
|
const area = gtk.DrawingArea.new();
|
|
const font = pango.FontDescription.fromString(font_spec);
|
|
|
|
self.* = .{
|
|
.alloc = alloc,
|
|
.session = undefined,
|
|
.area = area,
|
|
.font = font,
|
|
.on_title = cbs.on_title,
|
|
.on_exit = cbs.on_exit,
|
|
.on_focus = cbs.on_focus,
|
|
.ctx = cbs.ctx,
|
|
};
|
|
|
|
self.measureFont();
|
|
|
|
// The grid size follows the widget size, but we need a starting point
|
|
// for the session before the widget has ever been allocated.
|
|
self.session = try .create(alloc, 80, 24, opts, .{
|
|
.on_damage = &onDamage,
|
|
.on_title = &onSessionTitle,
|
|
.on_exit = &onSessionExit,
|
|
.ctx = self,
|
|
});
|
|
errdefer self.session.destroy();
|
|
|
|
const w = area.as(gtk.Widget);
|
|
w.setHexpand(1);
|
|
w.setVexpand(1);
|
|
// Without this the drawing area can never hold keyboard focus, and all
|
|
// key events would go to the sidebar instead.
|
|
w.setFocusable(1);
|
|
w.setCanFocus(1);
|
|
|
|
area.setDrawFunc(&drawFunc, self, null);
|
|
_ = gtk.DrawingArea.signals.resize.connect(area, *Terminal, &onResize, self, .{});
|
|
|
|
const keys = gtk.EventControllerKey.new();
|
|
_ = gtk.EventControllerKey.signals.key_pressed.connect(
|
|
keys,
|
|
*Terminal,
|
|
&onKeyPressed,
|
|
self,
|
|
.{},
|
|
);
|
|
w.addController(keys.as(gtk.EventController));
|
|
|
|
const scroll = gtk.EventControllerScroll.new(.{ .vertical = true });
|
|
_ = gtk.EventControllerScroll.signals.scroll.connect(
|
|
scroll,
|
|
*Terminal,
|
|
&onScroll,
|
|
self,
|
|
.{},
|
|
);
|
|
w.addController(scroll.as(gtk.EventController));
|
|
|
|
// Clicking the terminal should focus it.
|
|
const click = gtk.GestureClick.new();
|
|
_ = gtk.GestureClick.signals.pressed.connect(
|
|
click,
|
|
*Terminal,
|
|
&onClick,
|
|
self,
|
|
.{},
|
|
);
|
|
w.addController(click.as(gtk.EventController));
|
|
|
|
// Watching the property rather than just the click gesture means focus
|
|
// taken programmatically or by keyboard navigation is reported too.
|
|
_ = gobject.Object.signals.notify.connect(
|
|
area,
|
|
*Terminal,
|
|
&onNotifyHasFocus,
|
|
self,
|
|
.{ .detail = "has-focus" },
|
|
);
|
|
|
|
return self;
|
|
}
|
|
|
|
pub fn destroy(self: *Terminal) void {
|
|
self.session.destroy();
|
|
self.run_buf.deinit(self.alloc);
|
|
self.font.free();
|
|
self.alloc.destroy(self);
|
|
}
|
|
|
|
pub fn widget(self: *Terminal) *gtk.Widget {
|
|
return self.area.as(gtk.Widget);
|
|
}
|
|
|
|
pub fn grabFocus(self: *Terminal) void {
|
|
_ = self.widget().grabFocus();
|
|
}
|
|
|
|
/// Derive cell geometry from the font. A monospace font's "approximate
|
|
/// character width" is its advance, which is exactly our cell width.
|
|
fn measureFont(self: *Terminal) void {
|
|
const ctx = self.area.as(gtk.Widget).createPangoContext();
|
|
defer ctx.unref();
|
|
|
|
const metrics = ctx.getMetrics(self.font, null);
|
|
defer metrics.unref();
|
|
|
|
const ascent = @as(f64, @floatFromInt(metrics.getAscent())) / pango_scale;
|
|
const descent = @as(f64, @floatFromInt(metrics.getDescent())) / pango_scale;
|
|
const char_w = @as(f64, @floatFromInt(metrics.getApproximateCharWidth())) / pango_scale;
|
|
|
|
self.cell_w = @max(1, @ceil(char_w));
|
|
self.cell_h = @max(1, @ceil(ascent + descent));
|
|
self.ascent = ascent;
|
|
}
|
|
|
|
fn onDamage(ctx: ?*anyopaque) void {
|
|
const self: *Terminal = @ptrCast(@alignCast(ctx.?));
|
|
self.area.as(gtk.Widget).queueDraw();
|
|
}
|
|
|
|
fn onSessionTitle(ctx: ?*anyopaque, title: []const u8) void {
|
|
const self: *Terminal = @ptrCast(@alignCast(ctx.?));
|
|
self.on_title(self.ctx, title);
|
|
}
|
|
|
|
fn onNotifyHasFocus(
|
|
_: *gtk.DrawingArea,
|
|
_: *gobject.ParamSpec,
|
|
self: *Terminal,
|
|
) callconv(.c) void {
|
|
if (self.widget().hasFocus() != 0) self.on_focus(self.ctx);
|
|
}
|
|
|
|
fn onSessionExit(ctx: ?*anyopaque) void {
|
|
const self: *Terminal = @ptrCast(@alignCast(ctx.?));
|
|
self.on_exit(self.ctx);
|
|
}
|
|
|
|
/// The widget was resized: recompute the grid and tell the child process.
|
|
fn onResize(_: *gtk.DrawingArea, width: c_int, height: c_int, self: *Terminal) callconv(.c) void {
|
|
const usable_w = @max(0.0, @as(f64, @floatFromInt(width)) - pad * 2);
|
|
const usable_h = @max(0.0, @as(f64, @floatFromInt(height)) - pad * 2);
|
|
|
|
const cols: u16 = @intFromFloat(@max(1, @floor(usable_w / self.cell_w)));
|
|
const rows: u16 = @intFromFloat(@max(1, @floor(usable_h / self.cell_h)));
|
|
|
|
self.session.resize(
|
|
cols,
|
|
rows,
|
|
@intFromFloat(self.cell_w),
|
|
@intFromFloat(self.cell_h),
|
|
) catch |err| {
|
|
std.log.warn("resize failed: {s}", .{@errorName(err)});
|
|
};
|
|
}
|
|
|
|
// -------------------------------------------------------------------------
|
|
// Input
|
|
|
|
fn onClick(
|
|
_: *gtk.GestureClick,
|
|
_: c_int,
|
|
_: f64,
|
|
_: f64,
|
|
self: *Terminal,
|
|
) callconv(.c) void {
|
|
self.grabFocus();
|
|
}
|
|
|
|
fn onScroll(
|
|
_: *gtk.EventControllerScroll,
|
|
_: f64,
|
|
dy: f64,
|
|
self: *Terminal,
|
|
) callconv(.c) c_int {
|
|
// Three rows per notch matches the conventional feel.
|
|
const delta: isize = @intFromFloat(dy * 3);
|
|
if (delta == 0) return 0;
|
|
|
|
self.session.term.screens.active.pages.scroll(.{ .delta_row = delta });
|
|
self.area.as(gtk.Widget).queueDraw();
|
|
return 1;
|
|
}
|
|
|
|
fn onKeyPressed(
|
|
_: *gtk.EventControllerKey,
|
|
keyval: c_uint,
|
|
_: c_uint,
|
|
state: gdk.ModifierType,
|
|
self: *Terminal,
|
|
) callconv(.c) c_int {
|
|
const mods = keymap.translateMods(state);
|
|
|
|
var event: vt.input.KeyEvent = .{
|
|
.action = .press,
|
|
.key = keymap.keyFromKeyval(keyval) orelse .unidentified,
|
|
.mods = mods,
|
|
};
|
|
|
|
// GDK has already applied the keyboard layout and shift level, so the
|
|
// unicode value of the keyval is the text this key produces.
|
|
var utf8_buf: [8]u8 = undefined;
|
|
const codepoint = gdk.keyvalToUnicode(keyval);
|
|
if (codepoint > 0) {
|
|
if (std.unicode.utf8Encode(@intCast(codepoint), &utf8_buf)) |n| {
|
|
event.utf8 = utf8_buf[0..n];
|
|
// Shift is consumed producing the shifted character; ctrl/alt
|
|
// are not, and the encoder needs to know that to build e.g.
|
|
// ctrl sequences correctly.
|
|
event.consumed_mods = .{ .shift = mods.shift };
|
|
} else |_| {}
|
|
|
|
const lower = gdk.keyvalToLower(keyval);
|
|
const unshifted = gdk.keyvalToUnicode(lower);
|
|
if (unshifted > 0) event.unshifted_codepoint = @intCast(unshifted);
|
|
}
|
|
|
|
var out: [128]u8 = undefined;
|
|
var writer: std.Io.Writer = .fixed(&out);
|
|
const opts: vt.input.KeyEncodeOptions = .fromTerminal(&self.session.term);
|
|
vt.input.encodeKey(&writer, event, opts) catch |err| {
|
|
std.log.warn("key encode failed: {s}", .{@errorName(err)});
|
|
return 0;
|
|
};
|
|
|
|
const encoded = writer.buffered();
|
|
// Keys with no terminal representation (bare modifiers, unmapped keys)
|
|
// encode to nothing. Let GTK keep processing them.
|
|
if (encoded.len == 0) return 0;
|
|
|
|
// Typing should always snap the view back to the prompt.
|
|
self.session.term.screens.active.pages.scroll(.active);
|
|
self.session.write(encoded);
|
|
self.area.as(gtk.Widget).queueDraw();
|
|
return 1;
|
|
}
|
|
|
|
// -------------------------------------------------------------------------
|
|
// Rendering
|
|
|
|
/// A cell's appearance after resolving palette indices and SGR attributes.
|
|
const Appearance = struct {
|
|
fg: theme.Rgb,
|
|
bg: ?theme.Rgb,
|
|
bold: bool,
|
|
italic: bool,
|
|
underline: bool,
|
|
strikethrough: bool,
|
|
|
|
fn sameRun(a: Appearance, b: Appearance) bool {
|
|
return std.meta.eql(a.fg, b.fg) and
|
|
a.bold == b.bold and
|
|
a.italic == b.italic and
|
|
a.underline == b.underline and
|
|
a.strikethrough == b.strikethrough;
|
|
}
|
|
};
|
|
|
|
fn drawFunc(
|
|
_: *gtk.DrawingArea,
|
|
cr: *cairo.Context,
|
|
width: c_int,
|
|
height: c_int,
|
|
data: ?*anyopaque,
|
|
) callconv(.c) void {
|
|
const self: *Terminal = @ptrCast(@alignCast(data.?));
|
|
self.render(cr, width, height) catch |err| {
|
|
std.log.warn("render failed: {s}", .{@errorName(err)});
|
|
};
|
|
}
|
|
|
|
fn render(self: *Terminal, cr: *cairo.Context, _: c_int, _: c_int) !void {
|
|
const term = &self.session.term;
|
|
const screen = term.screens.active;
|
|
|
|
// Background. The pane frame around us clips to its own rounded corners,
|
|
// so this just fills.
|
|
const default_bg: theme.Rgb = if (term.colors.background.get()) |c|
|
|
.from(c)
|
|
else
|
|
theme.bg;
|
|
{
|
|
const r, const g, const b = default_bg.cairoRgb();
|
|
cr.setSourceRgb(r, g, b);
|
|
cr.paint();
|
|
}
|
|
|
|
const default_fg: theme.Rgb = if (term.colors.foreground.get()) |c|
|
|
.from(c)
|
|
else
|
|
theme.fg;
|
|
|
|
const layout = pangocairo.createLayout(cr);
|
|
defer layout.unref();
|
|
layout.setFontDescription(self.font);
|
|
|
|
var y: u16 = 0;
|
|
while (y < term.rows) : (y += 1) {
|
|
const pin = screen.pages.pin(.{ .viewport = .{ .x = 0, .y = y } }) orelse continue;
|
|
const cells = pin.cells(.all);
|
|
const row_top = pad + @as(f64, @floatFromInt(y)) * self.cell_h;
|
|
|
|
// Pass 1: backgrounds. Drawn as one rect per run so that a wide
|
|
// block of color doesn't turn into hundreds of tiny fills.
|
|
var x: usize = 0;
|
|
while (x < cells.len) {
|
|
const start_bg = appearance(pin, &cells[x], term, default_fg, default_bg).bg;
|
|
var end = x + 1;
|
|
while (end < cells.len) : (end += 1) {
|
|
const next = appearance(pin, &cells[end], term, default_fg, default_bg).bg;
|
|
if (!std.meta.eql(start_bg, next)) break;
|
|
}
|
|
|
|
if (start_bg) |color| {
|
|
const r, const g, const b = color.cairoRgb();
|
|
cr.setSourceRgb(r, g, b);
|
|
cr.rectangle(
|
|
pad + @as(f64, @floatFromInt(x)) * self.cell_w,
|
|
row_top,
|
|
@as(f64, @floatFromInt(end - x)) * self.cell_w,
|
|
self.cell_h,
|
|
);
|
|
cr.fill();
|
|
}
|
|
|
|
x = end;
|
|
}
|
|
|
|
// Pass 2: text runs.
|
|
x = 0;
|
|
while (x < cells.len) {
|
|
if (cells[x].wide == .spacer_tail) {
|
|
x += 1;
|
|
continue;
|
|
}
|
|
|
|
const look = appearance(pin, &cells[x], term, default_fg, default_bg);
|
|
|
|
self.run_buf.clearRetainingCapacity();
|
|
const run_start = x;
|
|
while (x < cells.len) : (x += 1) {
|
|
const cell = &cells[x];
|
|
if (cell.wide == .spacer_tail) continue;
|
|
|
|
const cell_look = appearance(pin, cell, term, default_fg, default_bg);
|
|
if (x != run_start and !look.sameRun(cell_look)) break;
|
|
|
|
try self.appendCell(pin, cell);
|
|
}
|
|
|
|
if (self.run_buf.items.len > 0) {
|
|
try self.drawRun(
|
|
cr,
|
|
layout,
|
|
look,
|
|
pad + @as(f64, @floatFromInt(run_start)) * self.cell_w,
|
|
row_top,
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
self.drawCursor(cr, layout, term, default_bg);
|
|
}
|
|
|
|
/// Append a cell's text to the current run.
|
|
fn appendCell(self: *Terminal, pin: vt.Pin, cell: *const vt.Cell) !void {
|
|
switch (cell.content_tag) {
|
|
.codepoint, .codepoint_grapheme => {
|
|
const cp = cell.content.codepoint.data;
|
|
// An empty cell still occupies a column, so emit a space to
|
|
// keep the run's characters aligned to the grid.
|
|
try self.appendCodepoint(if (cp == 0) ' ' else cp);
|
|
|
|
if (cell.content_tag == .codepoint_grapheme) {
|
|
if (pin.grapheme(cell)) |extra| {
|
|
for (extra) |cp2| try self.appendCodepoint(cp2);
|
|
}
|
|
}
|
|
},
|
|
// Background-only cells have no text.
|
|
.bg_color_palette, .bg_color_rgb => try self.appendCodepoint(' '),
|
|
}
|
|
}
|
|
|
|
fn appendCodepoint(self: *Terminal, cp: u21) !void {
|
|
var buf: [4]u8 = undefined;
|
|
const n = std.unicode.utf8Encode(cp, &buf) catch return;
|
|
try self.run_buf.appendSlice(self.alloc, buf[0..n]);
|
|
}
|
|
|
|
fn drawRun(
|
|
self: *Terminal,
|
|
cr: *cairo.Context,
|
|
layout: *pango.Layout,
|
|
look: Appearance,
|
|
x: f64,
|
|
y: f64,
|
|
) !void {
|
|
self.font.setWeight(if (look.bold) .bold else .normal);
|
|
self.font.setStyle(if (look.italic) .italic else .normal);
|
|
layout.setFontDescription(self.font);
|
|
|
|
// Pango wants a NUL-terminated pointer even though we pass the length.
|
|
try self.run_buf.append(self.alloc, 0);
|
|
const text = self.run_buf.items[0 .. self.run_buf.items.len - 1 :0];
|
|
layout.setText(text.ptr, @intCast(text.len));
|
|
|
|
const r, const g, const b = look.fg.cairoRgb();
|
|
cr.setSourceRgb(r, g, b);
|
|
cr.moveTo(x, y);
|
|
pangocairo.showLayout(cr, layout);
|
|
|
|
// Pango has no notion of our grid, so decorations are drawn by hand
|
|
// across the exact width of the run.
|
|
const run_w = runWidth(layout);
|
|
if (look.underline) {
|
|
cr.rectangle(x, y + self.ascent + 2, run_w, 1);
|
|
cr.fill();
|
|
}
|
|
if (look.strikethrough) {
|
|
cr.rectangle(x, y + self.ascent * 0.6, run_w, 1);
|
|
cr.fill();
|
|
}
|
|
}
|
|
|
|
fn runWidth(layout: *pango.Layout) f64 {
|
|
var w: c_int = 0;
|
|
var h: c_int = 0;
|
|
layout.getPixelSize(&w, &h);
|
|
return @floatFromInt(w);
|
|
}
|
|
|
|
fn drawCursor(
|
|
self: *Terminal,
|
|
cr: *cairo.Context,
|
|
layout: *pango.Layout,
|
|
term: *vt.Terminal,
|
|
default_bg: theme.Rgb,
|
|
) void {
|
|
// Only show the cursor when we're looking at the live screen; while
|
|
// scrolled back into history there is nothing meaningful to point at.
|
|
if (term.screens.active.pages.viewport != .active) return;
|
|
if (!term.modes.get(.cursor_visible)) return;
|
|
|
|
const cursor = term.screens.active.cursor;
|
|
if (cursor.x >= term.cols or cursor.y >= term.rows) return;
|
|
|
|
const x = pad + @as(f64, @floatFromInt(cursor.x)) * self.cell_w;
|
|
const y = pad + @as(f64, @floatFromInt(cursor.y)) * self.cell_h;
|
|
|
|
const color: theme.Rgb = if (term.colors.cursor.get()) |c| .from(c) else theme.cursor;
|
|
const r, const g, const b = color.cairoRgb();
|
|
cr.setSourceRgb(r, g, b);
|
|
|
|
switch (cursor.cursor_style) {
|
|
.block => {
|
|
cr.rectangle(x, y, self.cell_w, self.cell_h);
|
|
cr.fill();
|
|
|
|
// Redraw the covered character in the background color so it
|
|
// stays legible through the block.
|
|
const pin = term.screens.active.pages.pin(.{
|
|
.viewport = .{ .x = cursor.x, .y = cursor.y },
|
|
}) orelse return;
|
|
const cell = pin.rowAndCell().cell;
|
|
if (cell.content_tag != .codepoint and cell.content_tag != .codepoint_grapheme) return;
|
|
const cp = cell.content.codepoint.data;
|
|
if (cp == 0 or cp == ' ') return;
|
|
|
|
var buf: [5]u8 = @splat(0);
|
|
const n = std.unicode.utf8Encode(cp, buf[0..4]) catch return;
|
|
layout.setText(buf[0..n :0].ptr, @intCast(n));
|
|
|
|
const tr, const tg, const tb = default_bg.cairoRgb();
|
|
cr.setSourceRgb(tr, tg, tb);
|
|
cr.moveTo(x, y);
|
|
pangocairo.showLayout(cr, layout);
|
|
},
|
|
.bar => {
|
|
cr.rectangle(x, y, 2, self.cell_h);
|
|
cr.fill();
|
|
},
|
|
.underline => {
|
|
cr.rectangle(x, y + self.cell_h - 2, self.cell_w, 2);
|
|
cr.fill();
|
|
},
|
|
.block_hollow => {
|
|
cr.rectangle(x + 0.5, y + 0.5, self.cell_w - 1, self.cell_h - 1);
|
|
cr.setLineWidth(1);
|
|
cr.stroke();
|
|
},
|
|
}
|
|
}
|
|
|
|
/// Resolve a cell's style into concrete colors and attributes.
|
|
fn appearance(
|
|
pin: vt.Pin,
|
|
cell: *const vt.Cell,
|
|
term: *vt.Terminal,
|
|
default_fg: theme.Rgb,
|
|
default_bg: theme.Rgb,
|
|
) Appearance {
|
|
const palette = &term.colors.palette.current;
|
|
|
|
// Cells that carry only a background color have no style entry.
|
|
switch (cell.content_tag) {
|
|
.bg_color_palette => return .{
|
|
.fg = default_fg,
|
|
.bg = .from(palette[cell.content.color_palette.data]),
|
|
.bold = false,
|
|
.italic = false,
|
|
.underline = false,
|
|
.strikethrough = false,
|
|
},
|
|
.bg_color_rgb => {
|
|
const c = cell.content.color_rgb;
|
|
return .{
|
|
.fg = default_fg,
|
|
.bg = .{ .r = c.r, .g = c.g, .b = c.b },
|
|
.bold = false,
|
|
.italic = false,
|
|
.underline = false,
|
|
.strikethrough = false,
|
|
};
|
|
},
|
|
else => {},
|
|
}
|
|
|
|
const style = pin.style(cell);
|
|
|
|
var fg: theme.Rgb = switch (style.fg_color) {
|
|
.none => default_fg,
|
|
.palette => |i| brightIfBold(palette, i, style.flags.bold),
|
|
.rgb => |c| .from(c),
|
|
};
|
|
var bg: ?theme.Rgb = switch (style.bg_color) {
|
|
.none => null,
|
|
.palette => |i| .from(palette[i]),
|
|
.rgb => |c| .from(c),
|
|
};
|
|
|
|
if (style.flags.inverse) {
|
|
const new_fg = bg orelse default_bg;
|
|
const new_bg = fg;
|
|
fg = new_fg;
|
|
bg = new_bg;
|
|
}
|
|
|
|
if (style.flags.invisible) fg = bg orelse default_bg;
|
|
|
|
return .{
|
|
.fg = fg,
|
|
.bg = bg,
|
|
.bold = style.flags.bold,
|
|
.italic = style.flags.italic,
|
|
.underline = style.flags.underline != .none,
|
|
.strikethrough = style.flags.strikethrough,
|
|
};
|
|
}
|
|
|
|
/// Bold text using one of the low 8 palette colors conventionally renders
|
|
/// with the matching bright color.
|
|
fn brightIfBold(palette: *const [256]vt.color.RGB, index: u8, bold: bool) theme.Rgb {
|
|
const effective = if (bold and index < 8) index + 8 else index;
|
|
return .from(palette[effective]);
|
|
}
|