refactor: add renderer abstraction layer

src/renderer/notcurses/Plane.zig

@@ -0,0 +1,247 @@
+const nc = @import("notcurses");
+const Style = @import("theme").Style;
+const channels = @import("channels.zig");
+const StyleBits = @import("style.zig").StyleBits;
+const Cell = @import("Cell.zig").Cell;
+
+pub const Plane = struct {
+    plane: nc.Plane,
+
+    pub const Options = struct {
+        y: usize = 0,
+        x: usize = 0,
+        rows: usize = 0,
+        cols: usize = 0,
+        name: [*:0]const u8,
+        flags: option = .none,
+    };
+
+    pub const option = enum {
+        none,
+        VSCROLL,
+    };
+
+    pub fn init(nopts: *const Options, parent_: Plane) !Plane {
+        var nopts_: nc.Plane.Options = .{
+            .y = @intCast(nopts.y),
+            .x = @intCast(nopts.x),
+            .rows = @intCast(nopts.rows),
+            .cols = @intCast(nopts.cols),
+            .name = nopts.name,
+        };
+        switch (nopts.flags) {
+            .none => {},
+            .VSCROLL => nopts_.flags = nc.Plane.option.VSCROLL,
+        }
+
+        return .{ .plane = nc.Plane.init(&nopts_, parent_.plane) catch |e| return e };
+    }
+
+    pub fn deinit(self: *Plane) void {
+        self.plane.deinit();
+    }
+
+    pub fn name(self: Plane, buf: []u8) []u8 {
+        return self.plane.name(buf);
+    }
+
+    pub fn parent(self: Plane) Plane {
+        return .{ .plane = self.plane.parent() };
+    }
+
+    pub fn above(self: Plane) ?Plane {
+        return .{ .plane = self.plane.above() orelse return null };
+    }
+
+    pub fn below(self: Plane) ?Plane {
+        return .{ .plane = self.plane.below() orelse return null };
+    }
+
+    pub fn erase(self: Plane) void {
+        return self.plane.erase();
+    }
+
+    pub fn abs_y(self: Plane) c_int {
+        return self.plane.abs_y();
+    }
+
+    pub fn abs_x(self: Plane) c_int {
+        return self.plane.abs_x();
+    }
+
+    pub fn dim_y(self: Plane) c_uint {
+        return self.plane.dim_y();
+    }
+
+    pub fn dim_x(self: Plane) c_uint {
+        return self.plane.dim_x();
+    }
+
+    pub fn abs_yx_to_rel(self: Plane, y: ?*c_int, x: ?*c_int) void {
+        self.plane.abs_yx_to_rel(y, x);
+    }
+
+    pub fn rel_yx_to_abs(self: Plane, y: ?*c_int, x: ?*c_int) void {
+        self.plane.rel_yx_to_abs(y, x);
+    }
+
+    pub fn move_bottom(self: Plane) void {
+        self.plane.move_bottom();
+    }
+
+    pub fn move_yx(self: Plane, y: c_int, x: c_int) !void {
+        return self.plane.move_yx(y, x);
+    }
+
+    pub fn resize_simple(self: Plane, ylen: c_uint, xlen: c_uint) !void {
+        return self.plane.resize_simple(ylen, xlen);
+    }
+
+    pub fn home(self: Plane) void {
+        return self.plane.home();
+    }
+
+    pub fn print(self: Plane, comptime fmt: anytype, args: anytype) !usize {
+        return self.plane.print(fmt, args);
+    }
+
+    pub fn print_aligned_right(self: Plane, y: c_int, comptime fmt: anytype, args: anytype) !usize {
+        return self.plane.print_aligned(y, .right, fmt, args);
+    }
+
+    pub fn print_aligned_center(self: Plane, y: c_int, comptime fmt: anytype, args: anytype) !usize {
+        return self.plane.print_aligned(y, .center, fmt, args);
+    }
+
+    pub fn putstr(self: Plane, gclustarr: [*:0]const u8) !usize {
+        return self.plane.putstr(gclustarr);
+    }
+
+    pub fn putc(self: Plane, cell: *const Cell) !usize {
+        return self.plane.putc(&cell.cell);
+    }
+
+    pub fn putc_yx(self: Plane, y: c_int, x: c_int, cell: *const Cell) !usize {
+        return self.plane.put_yx(y, x, &cell.cell);
+    }
+
+    pub fn cursor_yx(self: Plane, y: *c_uint, x: *c_uint) void {
+        self.plane.cursor_yx(y, x);
+    }
+
+    pub fn cursor_y(self: Plane) c_uint {
+        return self.plane.cursor_y();
+    }
+
+    pub fn cursor_x(self: Plane) c_uint {
+        return self.plane.cursor_x();
+    }
+
+    pub fn cursor_move_yx(self: Plane, y: c_int, x: c_int) !void {
+        return self.plane.cursor_move_yx(y, x);
+    }
+
+    pub fn cursor_move_rel(self: Plane, y: c_int, x: c_int) !void {
+        return self.plane.cursor_move_rel(y, x);
+    }
+
+    pub fn cell_init(self: Plane) Cell {
+        return .{ .cell = self.plane.cell_init() };
+    }
+
+    pub fn cell_load(self: Plane, cell: *Cell, gcluster: [:0]const u8) !usize {
+        return self.plane.cell_load(&cell.cell, gcluster);
+    }
+
+    pub fn at_cursor_cell(self: Plane, cell: *Cell) !usize {
+        return self.plane.at_cursor_cell(&cell.cell);
+    }
+
+    pub fn set_styles(self: Plane, stylebits: StyleBits) void {
+        return self.plane.set_styles(@intCast(@as(u5, @bitCast(stylebits))));
+    }
+
+    pub fn on_styles(self: Plane, stylebits: StyleBits) void {
+        return self.plane.on_styles(@intCast(@as(u5, @bitCast(stylebits))));
+    }
+
+    pub fn off_styles(self: Plane, stylebits: StyleBits) void {
+        return self.plane.off_styles(@intCast(@as(u5, @bitCast(stylebits))));
+    }
+
+    pub fn set_fg_rgb(self: Plane, channel: u32) !void {
+        return self.plane.set_fg_rgb(channel);
+    }
+
+    pub fn set_bg_rgb(self: Plane, channel: u32) !void {
+        return self.plane.set_bg_rgb(channel);
+    }
+
+    pub fn set_fg_palindex(self: Plane, idx: c_uint) !void {
+        return self.plane.set_fg_palindex(idx);
+    }
+
+    pub fn set_bg_palindex(self: Plane, idx: c_uint) !void {
+        return self.plane.set_bg_palindex(idx);
+    }
+
+    pub fn set_channels(self: Plane, channels_: u64) void {
+        return self.plane.set_channels(channels_);
+    }
+
+    pub inline fn set_base_style(plane: *const Plane, egc_: [*c]const u8, style_: Style) void {
+        var channels_: u64 = 0;
+        channels.from_style(&channels_, style_);
+        if (style_.fg) |fg| plane.plane.set_fg_rgb(fg) catch {};
+        if (style_.bg) |bg| plane.plane.set_bg_rgb(bg) catch {};
+        _ = plane.plane.set_base(egc_, 0, channels_) catch {};
+    }
+
+    pub fn set_base_style_transparent(plane: Plane, egc_: [*:0]const u8, style_: Style) void {
+        var channels_: u64 = 0;
+        channels.from_style(&channels_, style_);
+        if (style_.fg) |fg| plane.plane.set_fg_rgb(fg) catch {};
+        if (style_.bg) |bg| plane.plane.set_bg_rgb(bg) catch {};
+        channels.set_fg_transparent(&channels_);
+        channels.set_bg_transparent(&channels_);
+        _ = plane.plane.set_base(egc_, 0, channels_) catch {};
+    }
+
+    pub fn set_base_style_bg_transparent(plane: Plane, egc_: [*:0]const u8, style_: Style) void {
+        var channels_: u64 = 0;
+        channels.from_style(&channels_, style_);
+        if (style_.fg) |fg| plane.plane.set_fg_rgb(fg) catch {};
+        if (style_.bg) |bg| plane.plane.set_bg_rgb(bg) catch {};
+        channels.set_bg_transparent(&channels_);
+        _ = plane.plane.set_base(egc_, 0, channels_) catch {};
+    }
+
+    pub inline fn set_style(plane: *const Plane, style_: Style) void {
+        var channels_: u64 = 0;
+        channels.from_style(&channels_, style_);
+        plane.plane.set_channels(channels_);
+        if (style_.fs) |fs| switch (fs) {
+            .normal => plane.plane.set_styles(nc.style.none),
+            .bold => plane.plane.set_styles(nc.style.bold),
+            .italic => plane.plane.set_styles(nc.style.italic),
+            .underline => plane.plane.set_styles(nc.style.underline),
+            .undercurl => plane.plane.set_styles(nc.style.undercurl),
+            .strikethrough => plane.plane.set_styles(nc.style.struck),
+        };
+    }
+
+    pub inline fn set_style_bg_transparent(plane: *const Plane, style_: Style) void {
+        var channels_: u64 = 0;
+        channels.from_style(&channels_, style_);
+        channels.set_bg_transparent(&channels_);
+        plane.plane.set_channels(channels_);
+        if (style_.fs) |fs| switch (fs) {
+            .normal => plane.plane.set_styles(nc.style.none),
+            .bold => plane.plane.set_styles(nc.style.bold),
+            .italic => plane.plane.set_styles(nc.style.italic),
+            .underline => plane.plane.set_styles(nc.style.underline),
+            .undercurl => plane.plane.set_styles(nc.style.undercurl),
+            .strikethrough => plane.plane.set_styles(nc.style.struck),
+        };
+    }
+};