Screen: move unicode field to Window and widgets.View

Unicode is not actually used by Screen anyway,
and Vaxis.init cannot return with Vaxis.screen.unicode assigned
as the pointer to Vaxis.unicode could be dangling.

The initial Vaxis without .screen.unicode
makes {Window,widgets.View}.gwidth a footgun.

src/Screen.zig

···
 const Shape = @import("Mouse.zig").Shape;
 const Image = @import("Image.zig");
 const Winsize = @import("main.zig").Winsize;
-const Unicode = @import("Unicode.zig");
 const Method = @import("gwidth.zig").Method;
 
 const Screen = @This();
···
 cursor_row: u16 = 0,
 cursor_col: u16 = 0,
 cursor_vis: bool = false,
-
-unicode: *const Unicode = undefined,
 
 width_method: Method = .wcwidth,
 
 mouse_shape: Shape = .default,
 cursor_shape: Cell.CursorShape = .default,
 
-pub fn init(alloc: std.mem.Allocator, winsize: Winsize, unicode: *const Unicode) std.mem.Allocator.Error!Screen {
+pub fn init(alloc: std.mem.Allocator, winsize: Winsize) std.mem.Allocator.Error!Screen {
     const w = winsize.cols;
     const h = winsize.rows;
     const self = Screen{
···
         .height = h,
         .width_pix = winsize.x_pixel,
         .height_pix = winsize.y_pixel,
-        .unicode = unicode,
     };
     const base_cell: Cell = .{};
     @memset(self.buf, base_cell);

src/Vaxis.zig

···
 ) !void {
     log.debug("resizing screen: width={d} height={d}", .{ winsize.cols, winsize.rows });
     self.screen.deinit(alloc);
-    self.screen = try Screen.init(alloc, winsize, &self.unicode);
+    self.screen = try Screen.init(alloc, winsize);
     self.screen.width_method = self.caps.unicode;
     // try self.screen.int(alloc, winsize.cols, winsize.rows);
     // we only init our current screen. This has the effect of redrawing
···
         .width = self.screen.width,
         .height = self.screen.height,
         .screen = &self.screen,
+        .unicode = &self.unicode,
     };
 }
 

src/Window.zig

···
 height: u16,
 
 screen: *Screen,
+unicode: *const Unicode,
 
 /// Creates a new window with offset relative to parent and size clamped to the
 /// parent's size. Windows do not retain a reference to their parent and are
···
         .width = @min(width, max_width),
         .height = @min(height, max_height),
         .screen = self.screen,
+        .unicode = self.unicode,
     };
 }
 
···
 
 /// returns the width of the grapheme. This depends on the terminal capabilities
 pub fn gwidth(self: Window, str: []const u8) u16 {
-    return gw.gwidth(str, self.screen.width_method, &self.screen.unicode.width_data);
+    return gw.gwidth(str, self.screen.width_method, &self.unicode.width_data);
 }
 
 /// fills the window with the provided cell
···
         .grapheme => {
             var col: u16 = opts.col_offset;
             const overflow: bool = blk: for (segments) |segment| {
-                var iter = self.screen.unicode.graphemeIterator(segment.text);
+                var iter = self.unicode.graphemeIterator(segment.text);
                 while (iter.next()) |grapheme| {
                     if (col >= self.width) {
                         row += 1;
···
                                     col = 0;
                                 }
 
-                                var grapheme_iterator = self.screen.unicode.graphemeIterator(word);
+                                var grapheme_iterator = self.unicode.graphemeIterator(word);
                                 while (grapheme_iterator.next()) |grapheme| {
                                     soft_wrapped = false;
                                     if (row >= self.height) {
···
         .none => {
             var col: u16 = opts.col_offset;
             const overflow: bool = blk: for (segments) |segment| {
-                var iter = self.screen.unicode.graphemeIterator(segment.text);
+                var iter = self.unicode.graphemeIterator(segment.text);
                 while (iter.next()) |grapheme| {
                     if (col >= self.width) break :blk true;
                     const s = grapheme.bytes(segment.text);
···
         .width = 20,
         .height = 20,
         .screen = undefined,
+        .unicode = undefined,
     };
 
     const ch = parent.initChild(1, 1, null, null);
···
         .width = 20,
         .height = 20,
         .screen = undefined,
+        .unicode = undefined,
     };
 
     const ch = parent.initChild(0, 0, 21, 21);
···
         .width = 20,
         .height = 20,
         .screen = undefined,
+        .unicode = undefined,
     };
 
     const ch = parent.initChild(10, 10, 21, 21);
···
         .width = 20,
         .height = 20,
         .screen = undefined,
+        .unicode = undefined,
     };
 
     const ch = parent.initChild(10, 10, 21, 21);
···
         .width = 20,
         .height = 20,
         .screen = undefined,
+        .unicode = undefined,
     };
 
     const ch = parent.initChild(10, 10, 21, 21);
···
     const alloc = std.testing.allocator_instance.allocator();
     const unicode = try Unicode.init(alloc);
     defer unicode.deinit(alloc);
-    var screen: Screen = .{ .width_method = .unicode, .unicode = &unicode };
+    var screen: Screen = .{ .width_method = .unicode };
     const win: Window = .{
         .x_off = 0,
         .y_off = 0,
···
         .width = 4,
         .height = 2,
         .screen = &screen,
+        .unicode = &unicode,
     };
     const opts: PrintOptions = .{
         .commit = false,
···
     defer unicode.deinit(alloc);
     var screen: Screen = .{
         .width_method = .unicode,
-        .unicode = &unicode,
     };
     const win: Window = .{
         .x_off = 0,
···
         .width = 4,
         .height = 2,
         .screen = &screen,
+        .unicode = &unicode,
     };
     const opts: PrintOptions = .{
         .commit = false,

src/widgets/View.zig

···
 /// Underlying Screen
 screen: Screen,
 
+unicode: *const Unicode,
+
 /// View Initialization Config
 pub const Config = struct {
     width: u16,
···
 
 /// Initialize a new View
 pub fn init(alloc: mem.Allocator, unicode: *const Unicode, config: Config) mem.Allocator.Error!View {
-    const screen = try Screen.init(
-        alloc,
-        .{
+    return .{
+        .alloc = alloc,
+        .screen = try Screen.init(alloc, .{
             .cols = config.width,
             .rows = config.height,
             .x_pixel = 0,
             .y_pixel = 0,
-        },
-        unicode,
-    );
-    return .{
-        .alloc = alloc,
-        .screen = screen,
+        }),
+        .unicode = unicode,
     };
 }
 
···
         .width = self.screen.width,
         .height = self.screen.height,
         .screen = &self.screen,
+        .unicode = self.unicode,
     };
 }
 
···
 
 /// Returns the width of the grapheme. This depends on the terminal capabilities
 pub fn gwidth(self: View, str: []const u8) u16 {
-    return gw.gwidth(str, self.screen.width_method, &self.screen.unicode.width_data);
+    return gw.gwidth(str, self.screen.width_method, &self.unicode.width_data);
 }
 
 /// Fills the View with the provided cell