518 lines
17 KiB
Zig
518 lines
17 KiB
Zig
const std = @import("std");
|
|
const Style = @import("theme").Style;
|
|
const ThemeColor = @import("theme").Color;
|
|
const FontStyle = @import("theme").FontStyle;
|
|
const StyleBits = @import("style.zig").StyleBits;
|
|
const Cell = @import("Cell.zig");
|
|
const vaxis = @import("vaxis");
|
|
const Buffer = @import("Buffer");
|
|
const color = @import("color");
|
|
const RGB = @import("color").RGB;
|
|
|
|
const Plane = @This();
|
|
|
|
const name_buf_len = 128;
|
|
|
|
window: vaxis.Window,
|
|
row: i32 = 0,
|
|
col: i32 = 0,
|
|
name_buf: [name_buf_len]u8,
|
|
name_len: usize,
|
|
cache: GraphemeCache = .{},
|
|
style: vaxis.Cell.Style = .{},
|
|
style_base: vaxis.Cell.Style = .{},
|
|
scrolling: bool = false,
|
|
transparent: bool = false,
|
|
|
|
pub const Options = struct {
|
|
y: usize = 0,
|
|
x: usize = 0,
|
|
rows: usize = 0,
|
|
cols: usize = 0,
|
|
name: []const u8,
|
|
flags: option = .none,
|
|
};
|
|
|
|
pub const option = enum {
|
|
none,
|
|
VSCROLL,
|
|
};
|
|
|
|
pub fn init(nopts: *const Options, parent_: Plane) !Plane {
|
|
const opts: vaxis.Window.ChildOptions = .{
|
|
.x_off = @as(i17, @intCast(nopts.x)),
|
|
.y_off = @as(i17, @intCast(nopts.y)),
|
|
.width = @as(u16, @intCast(nopts.cols)),
|
|
.height = @as(u16, @intCast(nopts.rows)),
|
|
.border = .{},
|
|
};
|
|
const len = @min(nopts.name.len, name_buf_len);
|
|
var plane: Plane = .{
|
|
.window = parent_.window.child(opts),
|
|
.name_buf = undefined,
|
|
.name_len = len,
|
|
.scrolling = nopts.flags == .VSCROLL,
|
|
};
|
|
@memcpy(plane.name_buf[0..len], nopts.name[0..len]);
|
|
return plane;
|
|
}
|
|
|
|
pub fn deinit(_: *Plane) void {}
|
|
|
|
pub fn name(self: Plane, buf: []u8) []const u8 {
|
|
@memcpy(buf[0..self.name_len], self.name_buf[0..self.name_len]);
|
|
return buf[0..self.name_len];
|
|
}
|
|
|
|
pub fn above(_: Plane) ?Plane {
|
|
return null;
|
|
}
|
|
|
|
pub fn below(_: Plane) ?Plane {
|
|
return null;
|
|
}
|
|
|
|
pub fn erase(self: Plane) void {
|
|
self.window.fill(.{ .style = self.style_base });
|
|
}
|
|
|
|
pub inline fn abs_y(self: Plane) c_int {
|
|
return @intCast(self.window.y_off);
|
|
}
|
|
|
|
pub inline fn abs_x(self: Plane) c_int {
|
|
return @intCast(self.window.x_off);
|
|
}
|
|
|
|
pub inline fn dim_y(self: Plane) c_uint {
|
|
return @intCast(self.window.height);
|
|
}
|
|
|
|
pub inline fn dim_x(self: Plane) c_uint {
|
|
return @intCast(self.window.width);
|
|
}
|
|
|
|
pub fn abs_yx_to_rel_nearest_x(self: Plane, y: c_int, x: c_int, xoffset: c_int) struct { c_int, c_int } {
|
|
if (self.window.screen.width == 0 or self.window.screen.height == 0) return self.abs_yx_to_rel(y, x);
|
|
const xextra = self.window.screen.width_pix % self.window.screen.width;
|
|
const xcell = (self.window.screen.width_pix - xextra) / self.window.screen.width;
|
|
if (xcell == 0)
|
|
return self.abs_yx_to_rel(y, x);
|
|
if (xoffset > xcell / 2)
|
|
return self.abs_yx_to_rel(y, x + 1);
|
|
return self.abs_yx_to_rel(y, x);
|
|
}
|
|
|
|
pub fn abs_yx_to_rel(self: Plane, y: c_int, x: c_int) struct { c_int, c_int } {
|
|
return .{ y - self.abs_y(), x - self.abs_x() };
|
|
}
|
|
|
|
pub fn abs_y_to_rel(self: Plane, y: c_int) c_int {
|
|
return y - self.abs_y();
|
|
}
|
|
|
|
pub fn rel_yx_to_abs(self: Plane, y: c_int, x: c_int) struct { c_int, c_int } {
|
|
return .{ self.abs_y() + y, self.abs_x() + x };
|
|
}
|
|
|
|
pub fn hide(_: Plane) void {}
|
|
|
|
pub fn move_yx(self: *Plane, y: c_int, x: c_int) !void {
|
|
self.window.y_off = @intCast(y);
|
|
self.window.x_off = @intCast(x);
|
|
}
|
|
|
|
pub fn resize_simple(self: *Plane, ylen: c_uint, xlen: c_uint) !void {
|
|
self.window.height = @intCast(ylen);
|
|
self.window.width = @intCast(xlen);
|
|
}
|
|
|
|
pub fn home(self: *Plane) void {
|
|
self.row = 0;
|
|
self.col = 0;
|
|
}
|
|
|
|
pub fn fill(self: *Plane, egc: []const u8) void {
|
|
for (0..self.dim_y()) |y|
|
|
for (0..self.dim_x()) |x|
|
|
self.write_cell(x, y, egc);
|
|
}
|
|
|
|
pub fn fill_width(self: *Plane, comptime fmt: anytype, args: anytype) !usize {
|
|
var buf: [fmt.len + 4096]u8 = undefined;
|
|
var pos: usize = 0;
|
|
const width = self.window.width;
|
|
var text_width: usize = 0;
|
|
while (text_width < width) {
|
|
const text = try std.fmt.bufPrint(buf[pos..], fmt, args);
|
|
pos += text.len;
|
|
text_width += self.egc_chunk_width(text, 0, 8);
|
|
}
|
|
return self.putstr(buf[0..pos]);
|
|
}
|
|
|
|
pub fn print(self: *Plane, comptime fmt: anytype, args: anytype) !usize {
|
|
var buf: [fmt.len + 4096]u8 = undefined;
|
|
const text = try std.fmt.bufPrint(&buf, fmt, args);
|
|
return self.putstr(text);
|
|
}
|
|
|
|
pub fn print_aligned_right(self: *Plane, y: c_int, comptime fmt: anytype, args: anytype) !usize {
|
|
var buf: [fmt.len + 4096]u8 = undefined;
|
|
const width = self.window.width;
|
|
const text = try std.fmt.bufPrint(&buf, fmt, args);
|
|
const text_width = self.egc_chunk_width(text, 0, 8);
|
|
self.row = @intCast(y);
|
|
self.col = @intCast(if (text_width >= width) 0 else width - text_width);
|
|
return self.putstr(text);
|
|
}
|
|
|
|
pub fn print_aligned_center(self: *Plane, y: c_int, comptime fmt: anytype, args: anytype) !usize {
|
|
var buf: [fmt.len + 4096]u8 = undefined;
|
|
const width = self.window.width;
|
|
const text = try std.fmt.bufPrint(&buf, fmt, args);
|
|
const text_width = self.egc_chunk_width(text, 0, 8);
|
|
self.row = @intCast(y);
|
|
self.col = @intCast(if (text_width >= width) 0 else (width - text_width) / 2);
|
|
return self.putstr(text);
|
|
}
|
|
|
|
pub fn putstr(self: *Plane, text: []const u8) !usize {
|
|
var result: usize = 0;
|
|
const height = self.window.height;
|
|
const width = self.window.width;
|
|
var iter = self.window.screen.unicode.graphemeIterator(text);
|
|
while (iter.next()) |grapheme| {
|
|
const s = grapheme.bytes(text);
|
|
if (std.mem.eql(u8, s, "\n")) {
|
|
if (self.scrolling and self.row == height - 1)
|
|
self.window.scroll(1)
|
|
else
|
|
self.row += 1;
|
|
self.col = 0;
|
|
result += 1;
|
|
continue;
|
|
}
|
|
if (self.col >= width) {
|
|
if (self.scrolling) {
|
|
self.row += 1;
|
|
self.col = 0;
|
|
} else return result;
|
|
}
|
|
self.write_cell(@intCast(self.col), @intCast(self.row), s);
|
|
result += 1;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
pub fn putstr_unicode(self: *Plane, text: []const u8) !usize {
|
|
var result: usize = 0;
|
|
var iter = self.window.screen.unicode.graphemeIterator(text);
|
|
while (iter.next()) |grapheme| {
|
|
const s_ = grapheme.bytes(text);
|
|
const s = switch (s_[0]) {
|
|
0...31 => |code| Buffer.unicode.control_code_to_unicode(code),
|
|
else => s_,
|
|
};
|
|
self.write_cell(@intCast(self.col), @intCast(self.row), s);
|
|
result += 1;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
pub fn putchar(self: *Plane, ecg: []const u8) void {
|
|
self.write_cell(@intCast(self.col), @intCast(self.row), ecg);
|
|
}
|
|
|
|
pub fn putc(self: *Plane, cell: *const Cell) !usize {
|
|
return self.putc_yx(@intCast(self.row), @intCast(self.col), cell);
|
|
}
|
|
|
|
pub fn putc_yx(self: *Plane, y: c_int, x: c_int, cell: *const Cell) !usize {
|
|
try self.cursor_move_yx(y, x);
|
|
const w = if (cell.cell.char.width == 0) self.window.gwidth(cell.cell.char.grapheme) else cell.cell.char.width;
|
|
if (w == 0) return w;
|
|
self.window.writeCell(@intCast(self.col), @intCast(self.row), cell.cell);
|
|
self.col += @intCast(w);
|
|
return w;
|
|
}
|
|
|
|
fn write_cell(self: *Plane, col: usize, row: usize, egc: []const u8) void {
|
|
var cell: vaxis.Cell = self.window.readCell(@intCast(col), @intCast(row)) orelse .{ .style = self.style };
|
|
const w = self.window.gwidth(egc);
|
|
cell.char.grapheme = self.cache.put(egc);
|
|
cell.char.width = @intCast(w);
|
|
if (self.transparent) {
|
|
cell.style.fg = self.style.fg;
|
|
} else {
|
|
cell.style = self.style;
|
|
}
|
|
self.window.writeCell(@intCast(col), @intCast(row), cell);
|
|
self.col += @intCast(w);
|
|
}
|
|
|
|
pub fn cursor_yx(self: Plane, y: *c_uint, x: *c_uint) void {
|
|
y.* = @intCast(self.row);
|
|
x.* = @intCast(self.col);
|
|
}
|
|
|
|
pub fn cursor_y(self: Plane) c_uint {
|
|
return @intCast(self.row);
|
|
}
|
|
|
|
pub fn cursor_x(self: Plane) c_uint {
|
|
return @intCast(self.col);
|
|
}
|
|
|
|
pub fn cursor_move_yx(self: *Plane, y: c_int, x: c_int) !void {
|
|
if (self.window.height == 0 or self.window.width == 0) return;
|
|
if (self.window.height <= y or self.window.width <= x) return;
|
|
if (y >= 0)
|
|
self.row = @intCast(y);
|
|
if (x >= 0)
|
|
self.col = @intCast(x);
|
|
}
|
|
|
|
pub fn cursor_move_rel(self: *Plane, y: c_int, x: c_int) !void {
|
|
if (self.window.height == 0 or self.window.width == 0) return error.OutOfBounds;
|
|
const new_y: isize = @as(c_int, @intCast(self.row)) + y;
|
|
const new_x: isize = @as(c_int, @intCast(self.col)) + x;
|
|
if (new_y < 0 or new_x < 0) return error.OutOfBounds;
|
|
if (self.window.height <= new_y or self.window.width <= new_x) return error.OutOfBounds;
|
|
self.row = @intCast(new_y);
|
|
self.col = @intCast(new_x);
|
|
}
|
|
|
|
pub fn cell_init(self: Plane) Cell {
|
|
return .{ .cell = .{ .style = self.style } };
|
|
}
|
|
|
|
pub fn cell_load(self: *Plane, cell: *Cell, gcluster: []const u8) !usize {
|
|
var cols: c_int = 0;
|
|
const bytes = self.egc_length(gcluster, &cols, 0, 1);
|
|
cell.cell.char.grapheme = self.cache.put(gcluster[0..bytes]);
|
|
cell.cell.char.width = @intCast(cols);
|
|
return bytes;
|
|
}
|
|
|
|
pub fn at_cursor_cell(self: Plane, cell: *Cell) !usize {
|
|
cell.* = .{};
|
|
if (self.window.readCell(@intCast(self.col), @intCast(self.row))) |cell_| cell.cell = cell_;
|
|
return if (std.mem.eql(u8, cell.cell.char.grapheme, " ")) 0 else cell.cell.char.grapheme.len;
|
|
}
|
|
|
|
pub fn set_styles(self: *Plane, stylebits: StyleBits) void {
|
|
self.style.strikethrough = false;
|
|
self.style.bold = false;
|
|
self.style.ul_style = .off;
|
|
self.style.italic = false;
|
|
self.on_styles(stylebits);
|
|
}
|
|
|
|
pub fn on_styles(self: *Plane, stylebits: StyleBits) void {
|
|
if (stylebits.struck) self.style.strikethrough = true;
|
|
if (stylebits.bold) self.style.bold = true;
|
|
if (stylebits.undercurl) self.style.ul_style = .curly;
|
|
if (stylebits.underline) self.style.ul_style = .single;
|
|
if (stylebits.italic) self.style.italic = true;
|
|
}
|
|
|
|
pub fn off_styles(self: *Plane, stylebits: StyleBits) void {
|
|
if (stylebits.struck) self.style.strikethrough = false;
|
|
if (stylebits.bold) self.style.bold = false;
|
|
if (stylebits.undercurl) self.style.ul_style = .off;
|
|
if (stylebits.underline) self.style.ul_style = .off;
|
|
if (stylebits.italic) self.style.italic = false;
|
|
}
|
|
|
|
pub fn set_fg_rgb(self: *Plane, col: ThemeColor) !void {
|
|
self.style.fg = to_cell_color(col);
|
|
}
|
|
|
|
pub fn set_fg_rgb_alpha(self: *Plane, alpha_fg: ThemeColor, col: ThemeColor) !void {
|
|
self.style.fg = apply_alpha_theme(alpha_fg, col);
|
|
}
|
|
|
|
pub fn set_bg_rgb(self: *Plane, col: ThemeColor) !void {
|
|
self.style.bg = to_cell_color(col);
|
|
}
|
|
|
|
pub fn set_bg_rgb_alpha(self: *Plane, alpha_bg: ThemeColor, col: ThemeColor) !void {
|
|
self.style.bg = apply_alpha_theme(alpha_bg, col);
|
|
}
|
|
|
|
pub fn set_fg_palindex(self: *Plane, idx: c_uint) !void {
|
|
self.style.fg = .{ .index = @intCast(idx) };
|
|
}
|
|
|
|
pub fn set_bg_palindex(self: *Plane, idx: c_uint) !void {
|
|
self.style.bg = .{ .index = @intCast(idx) };
|
|
}
|
|
|
|
pub inline fn set_base_style(self: *Plane, style_: Style) void {
|
|
self.style_base.fg = if (style_.fg) |col| to_cell_color(col) else .default;
|
|
self.style_base.bg = if (style_.bg) |col| to_cell_color(col) else .default;
|
|
if (style_.fs) |fs| set_font_style(&self.style, fs);
|
|
self.set_style(style_);
|
|
}
|
|
|
|
pub fn set_base_style_transparent(self: *Plane, _: [*:0]const u8, style_: Style) void {
|
|
self.style_base.fg = if (style_.fg) |col| to_cell_color(col) else .default;
|
|
self.style_base.bg = if (style_.bg) |col| to_cell_color(col) else .default;
|
|
if (style_.fs) |fs| set_font_style(&self.style, fs);
|
|
self.set_style(style_);
|
|
self.transparent = true;
|
|
}
|
|
|
|
pub fn set_base_style_bg_transparent(self: *Plane, _: [*:0]const u8, style_: Style) void {
|
|
self.style_base.fg = if (style_.fg) |col| to_cell_color(col) else .default;
|
|
self.style_base.bg = if (style_.bg) |col| to_cell_color(col) else .default;
|
|
if (style_.fs) |fs| set_font_style(&self.style, fs);
|
|
self.set_style(style_);
|
|
self.transparent = true;
|
|
}
|
|
|
|
fn apply_alpha(base: vaxis.Cell.Color, col: ThemeColor) vaxis.Cell.Color {
|
|
const alpha = col.alpha;
|
|
return if (alpha == 0xFF or base != .rgb)
|
|
.{ .rgb = RGB.to_u8s(RGB.from_u24(col.color)) }
|
|
else
|
|
.{ .rgb = color.apply_alpha(RGB.from_u8s(base.rgb), RGB.from_u24(col.color), alpha).to_u8s() };
|
|
}
|
|
|
|
fn apply_alpha_theme(base: ThemeColor, col: ThemeColor) vaxis.Cell.Color {
|
|
const alpha = col.alpha;
|
|
return if (alpha == 0xFF)
|
|
.{ .rgb = RGB.to_u8s(RGB.from_u24(col.color)) }
|
|
else
|
|
.{ .rgb = color.apply_alpha(RGB.from_u24(base.color), RGB.from_u24(col.color), alpha).to_u8s() };
|
|
}
|
|
|
|
pub inline fn reverse_style(self: *Plane) void {
|
|
const swap = self.style.fg;
|
|
self.style.fg = self.style.bg;
|
|
self.style.bg = swap;
|
|
}
|
|
|
|
pub inline fn set_style(self: *Plane, style_: Style) void {
|
|
if (style_.fg) |col| self.style.fg = apply_alpha(self.style_base.bg, col);
|
|
if (style_.bg) |col| self.style.bg = apply_alpha(self.style_base.bg, col);
|
|
if (style_.fs) |fs| set_font_style(&self.style, fs);
|
|
self.transparent = false;
|
|
}
|
|
|
|
pub inline fn set_style_bg_transparent(self: *Plane, style_: Style) void {
|
|
if (style_.fg) |col| self.style.fg = apply_alpha(self.style_base.fg, col);
|
|
if (style_.bg) |col| self.style.bg = apply_alpha(self.style_base.bg, col);
|
|
if (style_.fs) |fs| set_font_style(&self.style, fs);
|
|
self.transparent = true;
|
|
}
|
|
|
|
inline fn set_font_style(style: *vaxis.Cell.Style, fs: FontStyle) void {
|
|
switch (fs) {
|
|
.normal => {
|
|
style.bold = false;
|
|
style.italic = false;
|
|
style.dim = false;
|
|
},
|
|
.bold => style.bold = true,
|
|
.italic => style.italic = true,
|
|
.underline => style.ul_style = .single,
|
|
.undercurl => style.ul_style = .curly,
|
|
.strikethrough => style.strikethrough = true,
|
|
}
|
|
}
|
|
|
|
inline fn is_control_code(c: u8) bool {
|
|
return switch (c) {
|
|
0...8, 10...31 => true,
|
|
else => false,
|
|
};
|
|
}
|
|
|
|
pub fn egc_length(self: *const Plane, egcs: []const u8, colcount: *c_int, abs_col: usize, tab_width: usize) usize {
|
|
if (egcs.len == 0) {
|
|
colcount.* = 0;
|
|
return 0;
|
|
}
|
|
if (is_control_code(egcs[0])) {
|
|
colcount.* = 1;
|
|
return 1;
|
|
}
|
|
if (egcs[0] == '\t') {
|
|
colcount.* = @intCast(tab_width - (abs_col % tab_width));
|
|
return 1;
|
|
}
|
|
var iter = self.window.screen.unicode.graphemeIterator(egcs);
|
|
const grapheme = iter.next() orelse {
|
|
colcount.* = 1;
|
|
return 1;
|
|
};
|
|
const s = grapheme.bytes(egcs);
|
|
const w = self.window.gwidth(s);
|
|
colcount.* = @intCast(w);
|
|
return s.len;
|
|
}
|
|
|
|
pub fn egc_chunk_width(self: *const Plane, chunk_: []const u8, abs_col_: usize, tab_width: usize) usize {
|
|
var abs_col = abs_col_;
|
|
var chunk = chunk_;
|
|
var colcount: usize = 0;
|
|
var cols: c_int = 0;
|
|
while (chunk.len > 0) {
|
|
const bytes = self.egc_length(chunk, &cols, abs_col, tab_width);
|
|
colcount += @intCast(cols);
|
|
abs_col += @intCast(cols);
|
|
if (chunk.len < bytes) break;
|
|
chunk = chunk[bytes..];
|
|
}
|
|
return colcount;
|
|
}
|
|
|
|
pub fn egc_last(self: *const Plane, egcs: []const u8) []const u8 {
|
|
var iter = self.window.screen.unicode.graphemeIterator(egcs);
|
|
var last: []const u8 = egcs[0..0];
|
|
while (iter.next()) |grapheme| last = grapheme.bytes(egcs);
|
|
return last;
|
|
}
|
|
|
|
pub fn metrics(self: *const Plane, tab_width: usize) Buffer.Metrics {
|
|
return .{
|
|
.ctx = self,
|
|
.egc_length = struct {
|
|
fn f(self_: Buffer.Metrics, egcs: []const u8, colcount: *c_int, abs_col: usize) usize {
|
|
const plane: *const Plane = @ptrCast(@alignCast(self_.ctx));
|
|
return plane.egc_length(egcs, colcount, abs_col, self_.tab_width);
|
|
}
|
|
}.f,
|
|
.egc_chunk_width = struct {
|
|
fn f(self_: Buffer.Metrics, chunk_: []const u8, abs_col_: usize) usize {
|
|
const plane: *const Plane = @ptrCast(@alignCast(self_.ctx));
|
|
return plane.egc_chunk_width(chunk_, abs_col_, self_.tab_width);
|
|
}
|
|
}.f,
|
|
.tab_width = tab_width,
|
|
.egc_last = struct {
|
|
fn f(self_: Buffer.Metrics, egcs: []const u8) []const u8 {
|
|
const plane: *const Plane = @ptrCast(@alignCast(self_.ctx));
|
|
return plane.egc_last(egcs);
|
|
}
|
|
}.f,
|
|
};
|
|
}
|
|
|
|
const GraphemeCache = struct {
|
|
buf: [1024 * 16]u8 = undefined,
|
|
idx: usize = 0,
|
|
|
|
pub fn put(self: *GraphemeCache, bytes: []const u8) []u8 {
|
|
if (self.idx + bytes.len > self.buf.len) self.idx = 0;
|
|
defer self.idx += bytes.len;
|
|
@memcpy(self.buf[self.idx .. self.idx + bytes.len], bytes);
|
|
return self.buf[self.idx .. self.idx + bytes.len];
|
|
}
|
|
};
|
|
|
|
fn to_cell_color(col: ThemeColor) vaxis.Cell.Color {
|
|
return .{ .rgb = RGB.to_u8s(RGB.from_u24(col.color)) };
|
|
}
|