refactor: update libvaxis and remove some notcurses cruft

build.zig

@@ -51,10 +51,6 @@ pub fn build(b: *std.Build) void {
     const vaxis_dep = b.dependency("vaxis", .{
         .target = target,
         .optimize = dependency_optimize,
-        .use_libxev = false,
-        .use_zigimg = false,
-        .use_znvim = false,
-        .use_gap_buffer = false,
     });
     const vaxis_mod = vaxis_dep.module("vaxis");
 

build.zig.zon

@@ -32,8 +32,8 @@
             .hash = "122019f077d09686b1ec47928ca2b4bf264422f3a27afc5b49dafb0129a4ceca0d01",
         },
         .vaxis = .{
-            .url = "https://github.com/rockorager/libvaxis/archive/f41b4dcc0718e4c3c95db6d1f4ac0193382b767c.tar.gz",
+            .url = "https://github.com/neurocyte/libvaxis/archive/cba7e049dd22648bba6c0f4fab01eeeed2d69a5b.tar.gz",
-            .hash = "122003a9b987a0b77bbad2ea2c396b570646faa165f73503391d7419fbb935fcc363",
+            .hash = "1220e9c7c197181bc3ac405266f1160826720675160ae3e2b38204322e901c4244d8",
         },
         .zg = .{
             .url = "git+https://codeberg.org/dude_the_builder/zg#c425c9c8511bf92e14b8b612d1d16e774b186f2e",

src/renderer/vaxis/renderer.zig

@@ -90,11 +90,9 @@ pub fn run(self: *Self) !void {
 
     panic_cleanup_tty = &self.tty;
     if (!self.no_alternate) try self.vx.enterAltScreen(self.tty.anyWriter());
-    try self.vx.queryTerminalSend(self.tty.anyWriter());
+    try self.query_resize();
-    const ws = try vaxis.Tty.getWinsize(self.input_fd_blocking());
-    try self.vx.resize(self.a, self.tty.anyWriter(), ws);
-    self.vx.queueRefresh();
     try self.vx.setBracketedPaste(self.tty.anyWriter(), true);
+    try self.vx.queryTerminalSend(self.tty.anyWriter());
 }
 
 pub fn render(self: *Self) !void {
@@ -103,8 +101,11 @@ pub fn render(self: *Self) !void {
     try bufferedWriter.flush();
 }
 
-pub fn refresh(self: *Self) !void {
+pub fn query_resize(self: *Self) !void {
-    const ws = try vaxis.Tty.getWinsize(self.input_fd_blocking());
+    try self.resize(try vaxis.Tty.getWinsize(self.input_fd_blocking()));
+}
+
+pub fn resize(self: *Self, ws: vaxis.Winsize) !void {
     try self.vx.resize(self.a, self.tty.anyWriter(), ws);
     self.vx.queueRefresh();
 }
@@ -243,6 +244,8 @@ pub fn process_input(self: *Self, input_: []const u8) !void {
             },
             .color_report => {},
             .color_scheme => {},
+            .winsize => |ws| try self.resize(ws),
+
             .cap_unicode => {
                 self.logger.print("unicode capability detected", .{});
                 self.vx.caps.unicode = .unicode;

src/tui/tui.zig

@@ -31,7 +31,6 @@ frame_time: usize, // in microseconds
 frame_clock: tp.metronome,
 frame_clock_running: bool = false,
 frame_last_time: i64 = 0,
-fd_stdin: tp.file_descriptor,
 receiver: Receiver,
 mainview: Widget,
 message_filters: MessageFilter.List,
@@ -77,8 +76,6 @@ fn start(args: StartArgs) tp.result {
 
 fn init(a: Allocator) !*Self {
     var self = try a.create(Self);
-    const ctx = try renderer.init(a, self, tp.env.get().is("no-alternate"));
-
     var conf_buf: ?[]const u8 = null;
     var conf = root.read_config(a, &conf_buf);
     defer if (conf_buf) |buf| a.free(buf);
@@ -96,11 +93,10 @@ fn init(a: Allocator) !*Self {
     self.* = .{
         .a = a,
         .config = conf,
-        .rdr = ctx,
+        .rdr = try renderer.init(a, self, tp.env.get().is("no-alternate")),
         .frame_time = frame_time,
         .frame_clock = frame_clock,
         .frame_clock_running = true,
-        .fd_stdin = undefined,
         .receiver = Receiver.init(receive, self),
         .mainview = undefined,
         .message_filters = MessageFilter.List.init(a),
@@ -115,16 +111,10 @@ fn init(a: Allocator) !*Self {
     defer instance_ = null;
 
     try self.rdr.run();
-    if (comptime @hasDecl(renderer, "input_fd"))
-        self.fd_stdin = try tp.file_descriptor.init("stdin", self.rdr.input_fd());
     const n = self.rdr.stdplane();
 
     try frame_clock.start();
-    if (comptime @hasDecl(renderer, "input_fd")) {
-        try self.fd_stdin.wait_read();
-    } else {
     try InputReader.create(a, self.rdr.input_fd_blocking());
-    }
 
     self.rdr.handler_ctx = self;
     self.rdr.dispatch_input = dispatch_input;
@@ -160,8 +150,6 @@ fn deinit(self: *Self) void {
     self.frame_clock.deinit();
     self.rdr.stop();
     self.rdr.deinit();
-    if (comptime @hasDecl(renderer, "input_fd"))
-        self.fd_stdin.deinit();
     self.logger.deinit();
     self.a.destroy(self);
 }
@@ -178,8 +166,6 @@ fn receive(self: *Self, from: tp.pid_ref, m: tp.message) tp.result {
     defer instance_ = null;
     errdefer self.deinit();
 
-    errdefer if (comptime @hasDecl(renderer, "input_fd"))
-        self.fd_stdin.cancel() catch {};
     self.receive_safe(from, m) catch |e| {
         if (std.mem.eql(u8, "normal", tp.error_text()))
             return e;
@@ -221,7 +207,13 @@ fn receive_safe(self: *Self, from: tp.pid_ref, m: tp.message) tp.result {
 
     if (try m.match(.{"sigwinch"})) {
         try self.listen_sigwinch();
-        self.rdr.refresh() catch |e| return self.logger.err("refresh", e);
+        self.rdr.query_resize() catch |e| return self.logger.err("query_resize", e);
+        self.mainview.resize(Widget.Box.from(self.rdr.stdplane()));
+        need_render();
+        return;
+    }
+
+    if (try m.match(.{"resize"})) {
         self.mainview.resize(Widget.Box.from(self.rdr.stdplane()));
         need_render();
         return;
@@ -233,13 +225,6 @@ fn receive_safe(self: *Self, from: tp.pid_ref, m: tp.message) tp.result {
         return;
     }
 
-    if (comptime @hasDecl(renderer, "input_fd")) {
-        if (self.dispatch_input_fd(m) catch |e| b: {
-            self.logger.err("input dispatch", e);
-            break :b true;
-        })
-            return;
-    } else {
     var input: []const u8 = undefined;
     if (try m.match(.{ "process_input", tp.extract(&input) })) {
         self.rdr.process_input(input) catch |e| return tp.exit_error(e);
@@ -248,7 +233,6 @@ fn receive_safe(self: *Self, from: tp.pid_ref, m: tp.message) tp.result {
             need_render();
         return;
     }
-    }
 
     if (try m.match(.{"render"})) {
         if (!self.frame_clock_running)
@@ -361,28 +345,6 @@ fn dispatch_flush_input_event(self: *Self) tp.result {
         try mode.handler.send(tp.self_pid(), tp.message.fmtbuf(&buf, .{"F"}) catch |e| return tp.exit_error(e));
 }
 
-fn dispatch_input_fd(self: *Self, m: tp.message) error{Exit}!bool {
-    const frame = tracy.initZone(@src(), .{ .name = "tui input" });
-    defer frame.deinit();
-    var err: i64 = 0;
-    var err_msg: []u8 = "";
-    if (try m.match(.{ "fd", "stdin", "read_ready" })) {
-        self.fd_stdin.wait_read() catch |e| return tp.exit_error(e);
-        self.rdr.process_input() catch |e| switch (e) {
-            error.WouldBlock => return true,
-            else => return tp.exit_error(e),
-        };
-        try self.dispatch_flush_input_event();
-        if (self.unrendered_input_events_count > 0 and !self.frame_clock_running)
-            need_render();
-        return true; // consume message
-    }
-    if (try m.match(.{ "fd", "stdin", "read_error", tp.extract(&err), tp.extract(&err_msg) })) {
-        return tp.exit(err_msg);
-    }
-    return false;
-}
-
 fn dispatch_input(ctx: *anyopaque, cbor_msg: []const u8) void {
     const self: *Self = @ptrCast(@alignCast(ctx));
     const m: tp.message = .{ .buf = cbor_msg };