vaxis: use vt caps to measure grapheme widths

Implement our own grapheme measuring function which switches on whether
the terminal supports mode 2027

Signed-off-by: Tim Culverhouse <[e-mail]>

src/InternalScreen.zig

···
 pub const InternalCell = struct {
     char: std.ArrayList(u8) = undefined,
     style: Style = .{},
+    // if we got skipped because of a wide character
+    skipped: bool = false,
 
     pub fn eql(self: InternalCell, cell: Cell) bool {
         return std.mem.eql(u8, self.char.items, cell.char.grapheme) and std.meta.eql(self.style, cell.style);

src/Screen.zig

···
 cursor_col: usize = 0,
 cursor_vis: bool = false,
 
+unicode: bool = false,
+
 pub fn init(alloc: std.mem.Allocator, w: usize, h: usize) !Screen {
     var self = Screen{
         .buf = try alloc.alloc(Cell, w * h),

src/Tty.zig

···
                     }
                 },
                 .cap_kitty_keyboard => {
+                    log.info("kitty capability detected", .{});
                     vx.caps.kitty_keyboard = true;
                 },
                 .cap_rgb => {
+                    log.info("rgb capability detected", .{});
                     vx.caps.rgb = true;
                 },
                 .cap_unicode => {
+                    log.info("unicode capability detected", .{});
                     vx.caps.unicode = true;
+                    vx.screen.unicode = true;
                 },
                 .cap_da1 => {
                     std.Thread.Futex.wake(&vx.query_futex, 10);

src/Window.zig

···
 
 const Screen = @import("Screen.zig");
 const Cell = @import("cell.zig").Cell;
+const gw = @import("gwidth.zig");
 
 const log = std.log.scoped(.window);
 
···
 /// fills the window with the default cell
 pub fn clear(self: Window) void {
     self.fill(.{});
+}
+
+/// returns the width of the grapheme. This depends on the terminal capabilities
+pub fn gwidth(self: Window, str: []const u8) usize {
+    const m: gw.Method = if (self.screen.unicode) .unicode else .wcwidth;
+    log.info("using method {any}", .{m});
+    return gw.gwidth(str, m) catch 1;
 }
 
 /// fills the window with the provided cell

src/vaxis.zig

···
 const Options = @import("Options.zig");
 const Style = @import("cell.zig").Style;
 const strWidth = @import("ziglyph").display_width.strWidth;
+const gwidth = @import("gwidth.zig");
 
 /// Vaxis is the entrypoint for a Vaxis application. The provided type T should
 /// be a tagged union which contains all of the events the application will
···
             log.debug("resizing screen: width={d} height={d}", .{ winsize.cols, winsize.rows });
             self.screen.deinit(alloc);
             self.screen = try Screen.init(alloc, winsize.cols, winsize.rows);
+            self.screen.unicode = self.caps.unicode;
             // try self.screen.int(alloc, winsize.cols, winsize.rows);
             // we only init our current screen. This has the effect of redrawing
             // every cell
···
                 const cell = self.screen.buf[i];
                 defer {
                     // advance by the width of this char mod 1
-                    const width = blk: {
-                        if (cell.char.width > 0) break :blk cell.char.width;
-                        break :blk strWidth(cell.char.grapheme, .half) catch 1;
-                    };
-                    col += width;
-                    i += width;
+                    const method: gwidth.Method = if (self.caps.unicode) .unicode else .wcwidth;
+                    const w = gwidth.gwidth(cell.char.grapheme, method) catch 1;
+                    var j = i + 1;
+                    while (j < i + w) : (j += 1) {
+                        self.screen_last.buf[j].skipped = true;
+                    }
+                    col += w;
+                    i += w;
                 }
                 if (col >= self.screen.width) {
                     row += 1;
···
                 }
                 // If cell is the same as our last frame, we don't need to do
                 // anything
-                if (!self.refresh and self.screen_last.buf[i].eql(cell)) {
+                const last = self.screen_last.buf[i];
+                if (!self.refresh and last.eql(cell) and !last.skipped) {
                     reposition = true;
                     // Close any osc8 sequence we might be in before
                     // repositioning
···
                     }
                     continue;
                 }
+                self.screen_last.buf[i].skipped = false;
                 defer cursor = cell.style;
                 // Set this cell in the last frame
                 self.screen_last.writeCell(col, row, cell.char.grapheme, cell.style);

src/widgets/TextInput.zig

···
 const Key = @import("../Key.zig");
 const Window = @import("../Window.zig");
 const GraphemeIterator = @import("ziglyph").GraphemeIterator;
-const strWidth = @import("ziglyph").display_width.strWidth;
 
 const log = std.log.scoped(.text_input);
 
···
     var cursor_idx: usize = 0;
     while (iter.next()) |grapheme| {
         const g = grapheme.slice(self.buf.items);
-        const w = strWidth(g, .half) catch 1;
+        const w = win.gwidth(g);
         win.writeCell(col, 0, .{
             .char = .{
                 .grapheme = g,