replace std.io.AnyWriter with *std.io.Writer · rockorager.dev/libvaxis@199fdf2

+2 -1

examples/main.zig

··· 14 14 } 15 15 const alloc = gpa.allocator(); 16 16 17 - var tty = try vaxis.Tty.init(); 17 + var buffer: [1024]u8 = undefined; 18 + var tty = try vaxis.Tty.init(&buffer); 18 19 defer tty.deinit(); 19 20 20 21 var vx = try vaxis.init(alloc, .{});

+3

src/Loop.zig

··· 110 110 grapheme_data: *const Graphemes, 111 111 paste_allocator: ?std.mem.Allocator, 112 112 ) !void { 113 + // Return early if we're in test mode to avoid infinite loops 114 + if (builtin.is_test) return; 115 + 113 116 // initialize a grapheme cache 114 117 var cache: GraphemeCache = .{}; 115 118

+89 -41

src/Vaxis.zig

··· 3 3 const atomic = std.atomic; 4 4 const base64Encoder = std.base64.standard.Encoder; 5 5 const zigimg = @import("zigimg"); 6 + const IoWriter = std.io.Writer; 6 7 7 8 const Cell = @import("Cell.zig"); 8 9 const Image = @import("Image.zig"); ··· 13 14 const Unicode = @import("Unicode.zig"); 14 15 const Window = @import("Window.zig"); 15 16 16 - const AnyWriter = std.io.AnyWriter; 17 17 const Hyperlink = Cell.Hyperlink; 18 18 const KittyFlags = Key.KittyFlags; 19 19 const Shape = Mouse.Shape; ··· 113 113 /// passed, this will free resources associated with Vaxis. This is left as an 114 114 /// optional so applications can choose to not free resources when the 115 115 /// application will be exiting anyways 116 - pub fn deinit(self: *Vaxis, alloc: ?std.mem.Allocator, tty: AnyWriter) void { 116 + pub fn deinit(self: *Vaxis, alloc: ?std.mem.Allocator, tty: *IoWriter) void { 117 117 self.resetState(tty) catch {}; 118 118 119 119 if (alloc) |a| { ··· 124 124 } 125 125 126 126 /// resets enabled features, sends cursor to home and clears below cursor 127 - pub fn resetState(self: *Vaxis, tty: AnyWriter) !void { 127 + pub fn resetState(self: *Vaxis, tty: *IoWriter) !void { 128 128 // always show the cursor on state reset 129 129 tty.writeAll(ctlseqs.show_cursor) catch {}; 130 130 tty.writeAll(ctlseqs.sgr_reset) catch {}; ··· 175 175 try tty.writeAll(ctlseqs.osc12_reset); 176 176 self.state.changed_cursor_color = false; 177 177 } 178 + 179 + try tty.flush(); 178 180 } 179 181 180 182 /// resize allocates a slice of cells equal to the number of cells ··· 184 186 pub fn resize( 185 187 self: *Vaxis, 186 188 alloc: std.mem.Allocator, 187 - tty: AnyWriter, 189 + tty: *IoWriter, 188 190 winsize: Winsize, 189 191 ) !void { 190 192 log.debug("resizing screen: width={d} height={d}", .{ winsize.cols, winsize.rows }); ··· 199 201 if (self.state.alt_screen) 200 202 try tty.writeAll(ctlseqs.home) 201 203 else { 202 - try tty.writeBytesNTimes(ctlseqs.ri, self.state.cursor.row); 204 + for (0..self.state.cursor.row) |_| { 205 + try tty.writeAll(ctlseqs.ri); 206 + } 203 207 try tty.writeByte('\r'); 204 208 } 205 209 self.state.cursor.row = 0; 206 210 self.state.cursor.col = 0; 207 211 try tty.writeAll(ctlseqs.sgr_reset ++ ctlseqs.erase_below_cursor); 212 + try tty.flush(); 208 213 } 209 214 210 215 /// returns a Window comprising of the entire terminal screen ··· 221 226 } 222 227 223 228 /// enter the alternate screen. The alternate screen will automatically 224 - /// be exited if calling deinit while in the alt screen 225 - pub fn enterAltScreen(self: *Vaxis, tty: AnyWriter) !void { 229 + /// be exited if calling deinit while in the alt screen. 230 + pub fn enterAltScreen(self: *Vaxis, tty: *IoWriter) !void { 226 231 try tty.writeAll(ctlseqs.smcup); 232 + try tty.flush(); 227 233 self.state.alt_screen = true; 228 234 } 229 235 230 - /// exit the alternate screen 231 - pub fn exitAltScreen(self: *Vaxis, tty: AnyWriter) !void { 236 + /// exit the alternate screen. Does not flush the writer. 237 + pub fn exitAltScreen(self: *Vaxis, tty: *IoWriter) !void { 232 238 try tty.writeAll(ctlseqs.rmcup); 239 + try tty.flush(); 233 240 self.state.alt_screen = false; 234 241 } 235 242 ··· 239 246 /// 240 247 /// This call will block until Vaxis.query_futex is woken up, or the timeout. 241 248 /// Event loops can wake up this futex when cap_da1 is received 242 - pub fn queryTerminal(self: *Vaxis, tty: AnyWriter, timeout_ns: u64) !void { 249 + pub fn queryTerminal(self: *Vaxis, tty: *IoWriter, timeout_ns: u64) !void { 243 250 try self.queryTerminalSend(tty); 244 251 // 1 second timeout 245 252 std.Thread.Futex.timedWait(&self.query_futex, 0, timeout_ns) catch {}; ··· 250 257 /// write queries to the terminal to determine capabilities. This function 251 258 /// is only for use with a custom main loop. Call Vaxis.queryTerminal() if 252 259 /// you are using Loop.run() 253 - pub fn queryTerminalSend(vx: *Vaxis, tty: AnyWriter) !void { 260 + pub fn queryTerminalSend(vx: *Vaxis, tty: *IoWriter) !void { 254 261 vx.queries_done.store(false, .unordered); 255 262 256 263 // TODO: re-enable this ··· 293 300 ctlseqs.csi_u_query ++ 294 301 ctlseqs.kitty_graphics_query ++ 295 302 ctlseqs.primary_device_attrs); 303 + 304 + try tty.flush(); 296 305 } 297 306 298 307 /// Enable features detected by responses to queryTerminal. This function 299 308 /// is only for use with a custom main loop. Call Vaxis.queryTerminal() if 300 309 /// you are using Loop.run() 301 - pub fn enableDetectedFeatures(self: *Vaxis, tty: AnyWriter) !void { 310 + pub fn enableDetectedFeatures(self: *Vaxis, tty: *IoWriter) !void { 302 311 switch (builtin.os.tag) { 303 312 .windows => { 304 313 // No feature detection on windows. We just hard enable some knowns for ConPTY ··· 334 343 } 335 344 }, 336 345 } 346 + 347 + try tty.flush(); 337 348 } 338 349 339 350 // the next render call will refresh the entire screen ··· 342 353 } 343 354 344 355 /// draws the screen to the terminal 345 - pub fn render(self: *Vaxis, tty: AnyWriter) !void { 356 + pub fn render(self: *Vaxis, tty: *IoWriter) !void { 346 357 defer self.refresh = false; 347 358 assert(self.screen.buf.len == @as(usize, @intCast(self.screen.width)) * self.screen.height); // correct size 348 359 assert(self.screen.buf.len == self.screen_last.buf.len); // same size ··· 352 363 // requires a smarter buffered writer, we'll probably have to write 353 364 // our own 354 365 try tty.writeAll(ctlseqs.sync_set); 355 - defer tty.writeAll(ctlseqs.sync_reset) catch {}; 366 + errdefer tty.writeAll(ctlseqs.sync_reset) catch {}; 356 367 357 368 // Send the cursor to 0,0 358 369 // TODO: this needs to move after we optimize writes. We only do ··· 363 374 try tty.writeAll(ctlseqs.home) 364 375 else { 365 376 try tty.writeByte('\r'); 366 - try tty.writeBytesNTimes(ctlseqs.ri, self.state.cursor.row); 377 + for (0..self.state.cursor.row) |_| { 378 + try tty.writeAll(ctlseqs.ri); 379 + } 367 380 } 368 381 try tty.writeAll(ctlseqs.sgr_reset); 369 382 ··· 471 484 try tty.print(ctlseqs.cuf, .{n}); 472 485 } else { 473 486 const n = row - cursor_pos.row; 474 - try tty.writeByteNTimes('\n', n); 487 + for (0..n) |_| { 488 + try tty.writeByte('\n'); 489 + } 475 490 try tty.writeByte('\r'); 476 491 if (col > 0) 477 492 try tty.print(ctlseqs.cuf, .{col}); ··· 723 738 } else { 724 739 // TODO: position cursor relative to current location 725 740 try tty.writeByte('\r'); 726 - if (self.screen.cursor_row >= cursor_pos.row) 727 - try tty.writeByteNTimes('\n', self.screen.cursor_row - cursor_pos.row) 728 - else 729 - try tty.writeBytesNTimes(ctlseqs.ri, cursor_pos.row - self.screen.cursor_row); 741 + if (self.screen.cursor_row >= cursor_pos.row) { 742 + for (0..(self.screen.cursor_row - cursor_pos.row)) |_| { 743 + try tty.writeByte('\n'); 744 + } 745 + } else { 746 + for (0..(cursor_pos.row - self.screen.cursor_row)) |_| { 747 + try tty.writeAll(ctlseqs.ri); 748 + } 749 + } 730 750 if (self.screen.cursor_col > 0) 731 751 try tty.print(ctlseqs.cuf, .{self.screen.cursor_col}); 732 752 } ··· 751 771 ); 752 772 self.screen_last.cursor_shape = self.screen.cursor_shape; 753 773 } 774 + 775 + try tty.writeAll(ctlseqs.sync_reset); 776 + try tty.flush(); 754 777 } 755 778 756 - fn enableKittyKeyboard(self: *Vaxis, tty: AnyWriter, flags: Key.KittyFlags) !void { 779 + fn enableKittyKeyboard(self: *Vaxis, tty: *IoWriter, flags: Key.KittyFlags) !void { 757 780 const flag_int: u5 = @bitCast(flags); 758 781 try tty.print(ctlseqs.csi_u_push, .{flag_int}); 782 + try tty.flush(); 759 783 self.state.kitty_keyboard = true; 760 784 } 761 785 762 786 /// send a system notification 763 - pub fn notify(_: *Vaxis, tty: AnyWriter, title: ?[]const u8, body: []const u8) !void { 787 + pub fn notify(_: *Vaxis, tty: *IoWriter, title: ?[]const u8, body: []const u8) !void { 764 788 if (title) |t| 765 789 try tty.print(ctlseqs.osc777_notify, .{ t, body }) 766 790 else 767 791 try tty.print(ctlseqs.osc9_notify, .{body}); 792 + 793 + try tty.flush(); 768 794 } 769 795 770 796 /// sets the window title 771 - pub fn setTitle(_: *Vaxis, tty: AnyWriter, title: []const u8) !void { 797 + pub fn setTitle(_: *Vaxis, tty: *IoWriter, title: []const u8) !void { 772 798 try tty.print(ctlseqs.osc2_set_title, .{title}); 799 + try tty.flush(); 773 800 } 774 801 775 802 // turn bracketed paste on or off. An event will be sent at the 776 803 // beginning and end of a detected paste. All keystrokes between these 777 804 // events were pasted 778 - pub fn setBracketedPaste(self: *Vaxis, tty: AnyWriter, enable: bool) !void { 805 + pub fn setBracketedPaste(self: *Vaxis, tty: *IoWriter, enable: bool) !void { 779 806 const seq = if (enable) 780 807 ctlseqs.bp_set 781 808 else 782 809 ctlseqs.bp_reset; 783 810 try tty.writeAll(seq); 811 + try tty.flush(); 784 812 self.state.bracketed_paste = enable; 785 813 } 786 814 ··· 790 818 } 791 819 792 820 /// Change the mouse reporting mode 793 - pub fn setMouseMode(self: *Vaxis, tty: AnyWriter, enable: bool) !void { 821 + pub fn setMouseMode(self: *Vaxis, tty: *IoWriter, enable: bool) !void { 794 822 if (enable) { 795 823 self.state.mouse = true; 796 824 if (self.caps.sgr_pixels) { ··· 804 832 } else { 805 833 try tty.writeAll(ctlseqs.mouse_reset); 806 834 } 835 + 836 + try tty.flush(); 807 837 } 808 838 809 839 /// Translate pixel mouse coordinates to cell + offset ··· 832 862 pub fn transmitLocalImagePath( 833 863 self: *Vaxis, 834 864 allocator: std.mem.Allocator, 835 - tty: AnyWriter, 865 + tty: *IoWriter, 836 866 payload: []const u8, 837 867 width: u16, 838 868 height: u16, ··· 878 908 ); 879 909 }, 880 910 } 911 + 912 + try tty.flush(); 881 913 return .{ 882 914 .id = id, 883 915 .width = width, ··· 888 920 /// Transmit an image which has been pre-base64 encoded 889 921 pub fn transmitPreEncodedImage( 890 922 self: *Vaxis, 891 - tty: AnyWriter, 923 + tty: *IoWriter, 892 924 bytes: []const u8, 893 925 width: u16, 894 926 height: u16, ··· 935 967 ); 936 968 } 937 969 } 970 + 971 + try tty.flush(); 938 972 return .{ 939 973 .id = id, 940 974 .width = width, ··· 945 979 pub fn transmitImage( 946 980 self: *Vaxis, 947 981 alloc: std.mem.Allocator, 948 - tty: AnyWriter, 982 + tty: *IoWriter, 949 983 img: *zigimg.Image, 950 984 format: Image.TransmitFormat, 951 985 ) !Image { ··· 979 1013 pub fn loadImage( 980 1014 self: *Vaxis, 981 1015 alloc: std.mem.Allocator, 982 - tty: AnyWriter, 1016 + tty: *IoWriter, 983 1017 src: Image.Source, 984 1018 ) !Image { 985 1019 if (!self.caps.kitty_graphics) return error.NoGraphicsCapability; ··· 993 1027 } 994 1028 995 1029 /// deletes an image from the terminal's memory 996 - pub fn freeImage(_: Vaxis, tty: AnyWriter, id: u32) void { 1030 + pub fn freeImage(_: Vaxis, tty: *IoWriter, id: u32) void { 997 1031 tty.print("\x1b_Ga=d,d=I,i={d};\x1b\\", .{id}) catch |err| { 998 1032 log.err("couldn't delete image {d}: {}", .{ id, err }); 999 1033 return; 1000 1034 }; 1035 + tty.flush() catch {}; 1001 1036 } 1002 1037 1003 - pub fn copyToSystemClipboard(_: Vaxis, tty: AnyWriter, text: []const u8, encode_allocator: std.mem.Allocator) !void { 1038 + pub fn copyToSystemClipboard(_: Vaxis, tty: *IoWriter, text: []const u8, encode_allocator: std.mem.Allocator) !void { 1004 1039 const encoder = std.base64.standard.Encoder; 1005 1040 const size = encoder.calcSize(text.len); 1006 1041 const buf = try encode_allocator.alloc(u8, size); ··· 1010 1045 ctlseqs.osc52_clipboard_copy, 1011 1046 .{b64}, 1012 1047 ); 1048 + 1049 + try tty.flush(); 1013 1050 } 1014 1051 1015 - pub fn requestSystemClipboard(self: Vaxis, tty: AnyWriter) !void { 1052 + pub fn requestSystemClipboard(self: Vaxis, tty: *IoWriter) !void { 1016 1053 if (self.opts.system_clipboard_allocator == null) return error.NoClipboardAllocator; 1017 1054 try tty.print( 1018 1055 ctlseqs.osc52_clipboard_request, 1019 1056 .{}, 1020 1057 ); 1058 + try tty.flush(); 1021 1059 } 1022 1060 1023 1061 /// Set the default terminal foreground color 1024 - pub fn setTerminalForegroundColor(self: *Vaxis, tty: AnyWriter, rgb: [3]u8) !void { 1062 + pub fn setTerminalForegroundColor(self: *Vaxis, tty: *IoWriter, rgb: [3]u8) !void { 1025 1063 try tty.print(ctlseqs.osc10_set, .{ rgb[0], rgb[0], rgb[1], rgb[1], rgb[2], rgb[2] }); 1064 + try tty.flush(); 1026 1065 self.state.changed_default_fg = true; 1027 1066 } 1028 1067 1029 1068 /// Set the default terminal background color 1030 - pub fn setTerminalBackgroundColor(self: *Vaxis, tty: AnyWriter, rgb: [3]u8) !void { 1069 + pub fn setTerminalBackgroundColor(self: *Vaxis, tty: *IoWriter, rgb: [3]u8) !void { 1031 1070 try tty.print(ctlseqs.osc11_set, .{ rgb[0], rgb[0], rgb[1], rgb[1], rgb[2], rgb[2] }); 1071 + try tty.flush(); 1032 1072 self.state.changed_default_bg = true; 1033 1073 } 1034 1074 1035 1075 /// Set the terminal cursor color 1036 - pub fn setTerminalCursorColor(self: *Vaxis, tty: AnyWriter, rgb: [3]u8) !void { 1076 + pub fn setTerminalCursorColor(self: *Vaxis, tty: *IoWriter, rgb: [3]u8) !void { 1037 1077 try tty.print(ctlseqs.osc12_set, .{ rgb[0], rgb[0], rgb[1], rgb[1], rgb[2], rgb[2] }); 1078 + try tty.flush(); 1038 1079 self.state.changed_cursor_color = true; 1039 1080 } 1040 1081 1041 1082 /// Request a color report from the terminal. Note: not all terminals support 1042 1083 /// reporting colors. It is always safe to try, but you may not receive a 1043 1084 /// response. 1044 - pub fn queryColor(_: Vaxis, tty: AnyWriter, kind: Cell.Color.Kind) !void { 1085 + pub fn queryColor(_: Vaxis, tty: *IoWriter, kind: Cell.Color.Kind) !void { 1045 1086 switch (kind) { 1046 1087 .fg => try tty.writeAll(ctlseqs.osc10_query), 1047 1088 .bg => try tty.writeAll(ctlseqs.osc11_query), 1048 1089 .cursor => try tty.writeAll(ctlseqs.osc12_query), 1049 1090 .index => |idx| try tty.print(ctlseqs.osc4_query, .{idx}), 1050 1091 } 1092 + try tty.flush(); 1051 1093 } 1052 1094 1053 1095 /// Subscribe to color theme updates. A `color_scheme: Color.Scheme` tag must ··· 1055 1097 /// capability. Support can be detected by checking the value of 1056 1098 /// vaxis.caps.color_scheme_updates. The initial scheme will be reported when 1057 1099 /// subscribing. 1058 - pub fn subscribeToColorSchemeUpdates(self: *Vaxis, tty: AnyWriter) !void { 1100 + pub fn subscribeToColorSchemeUpdates(self: *Vaxis, tty: *IoWriter) !void { 1059 1101 try tty.writeAll(ctlseqs.color_scheme_request); 1060 1102 try tty.writeAll(ctlseqs.color_scheme_set); 1103 + try tty.flush(); 1061 1104 self.state.color_scheme_updates = true; 1062 1105 } 1063 1106 1064 - pub fn deviceStatusReport(_: Vaxis, tty: AnyWriter) !void { 1107 + pub fn deviceStatusReport(_: Vaxis, tty: *IoWriter) !void { 1065 1108 try tty.writeAll(ctlseqs.device_status_report); 1109 + try tty.flush(); 1066 1110 } 1067 1111 1068 1112 /// prettyPrint is used to print the contents of the Screen to the tty. The state is not stored, and 1069 1113 /// the cursor will be put on the next line after the last line is printed. This is useful to 1070 1114 /// sequentially print data in a styled format to eg. stdout. This function returns an error if you 1071 1115 /// are not in the alt screen. The cursor is always hidden, and mouse shapes are not available 1072 - pub fn prettyPrint(self: *Vaxis, tty: AnyWriter) !void { 1116 + pub fn prettyPrint(self: *Vaxis, tty: *IoWriter) !void { 1073 1117 if (self.state.alt_screen) return error.NotInPrimaryScreen; 1074 1118 1075 1119 try tty.writeAll(ctlseqs.hide_cursor); ··· 1135 1179 try tty.print(ctlseqs.cuf, .{n}); 1136 1180 } else { 1137 1181 const n = row - cursor_pos.row; 1138 - try tty.writeByteNTimes('\n', n); 1182 + for (0..n) |_| { 1183 + try tty.writeByte('\n'); 1184 + } 1139 1185 try tty.writeByte('\r'); 1140 1186 if (col > 0) 1141 1187 try tty.print(ctlseqs.cuf, .{col}); ··· 1334 1380 cursor_pos.row = row; 1335 1381 } 1336 1382 try tty.writeAll("\r\n"); 1383 + try tty.flush(); 1337 1384 } 1338 1385 1339 1386 /// Set the terminal's current working directory 1340 - pub fn setTerminalWorkingDirectory(_: *Vaxis, tty: AnyWriter, path: []const u8) !void { 1387 + pub fn setTerminalWorkingDirectory(_: *Vaxis, tty: *IoWriter, path: []const u8) !void { 1341 1388 if (path.len == 0 or path[0] != '/') 1342 1389 return error.InvalidAbsolutePath; 1343 1390 const hostname = switch (builtin.os.tag) { ··· 1351 1398 .path = .{ .raw = path }, 1352 1399 }; 1353 1400 try tty.print(ctlseqs.osc7, .{uri}); 1401 + try tty.flush(); 1354 1402 }

+6 -31

src/tty.zig

··· 116 116 return self.writer.interface.write(bytes); 117 117 } 118 118 119 - pub fn anyWriter(self: *PosixTty) std.io.AnyWriter { 120 - return self.writer.interface.any(); 119 + pub fn anyWriter(self: *PosixTty) *std.io.Writer { 120 + return &self.writer.interface; 121 121 } 122 122 123 123 pub fn read(self: *const PosixTty, buf: []u8) !usize { ··· 336 336 return self.writer.interface.write(bytes); 337 337 } 338 338 339 - pub fn anyWriter(self: *Tty) std.io.AnyWriter { 340 - return self.writer.interface.any(); 341 - } 342 - 343 - pub fn bufferedWriter(self: *Tty) std.io.AnyWriter { 344 - // File.Writer is already buffered 345 - return self.writer.interface.any(); 339 + pub fn anyWriter(self: *Tty) *std.io.Writer { 340 + return &self.writer.interface; 346 341 } 347 342 348 343 pub fn nextEvent(self: *Tty, parser: *Parser, paste_allocator: ?std.mem.Allocator) !Event { ··· 758 753 std.testing.allocator.destroy(self.writer); 759 754 } 760 755 761 - /// Write bytes to the tty 762 - pub fn write(self: *const TestTty, bytes: []const u8) !usize { 763 - if (std.mem.eql(u8, bytes, ctlseqs.device_status_report)) { 764 - _ = posix.write(self.pipe_write, "\x1b") catch {}; 765 - } 766 - return self.writer.writer.write(bytes); 767 - } 768 - 769 - pub fn opaqueWrite(ptr: *const anyopaque, bytes: []const u8) !usize { 770 - const self: *const TestTty = @ptrCast(@alignCast(ptr)); 771 - return self.write(bytes); 772 - } 773 - 774 - pub fn anyWriter(self: *const TestTty) std.io.AnyWriter { 775 - return .{ 776 - .context = self, 777 - .writeFn = TestTty.opaqueWrite, 778 - }; 756 + pub fn anyWriter(self: *const TestTty) *std.io.Writer { 757 + return &self.writer.writer; 779 758 } 780 759 781 760 pub fn read(self: *const TestTty, buf: []u8) !usize { ··· 802 781 .x_pixel = 40 * 8, 803 782 .y_pixel = 40 * 8 * 2, 804 783 }; 805 - } 806 - 807 - pub fn bufferedWriter(self: *const TestTty) std.io.BufferedWriter(4096, std.io.AnyWriter) { 808 - return std.io.bufferedWriter(self.anyWriter()); 809 784 } 810 785 811 786 /// Implemented for the Windows API

+3 -2

src/widgets/terminal/Terminal.zig

··· 252 252 return posix.write(self.pty.pty, buf); 253 253 } 254 254 255 - pub fn anyWriter(self: *const Terminal) std.io.AnyWriter { 256 - return .{ 255 + pub fn anyWriter(self: *const Terminal) *std.io.Writer { 256 + const writer: std.io.Writer = .{ 257 257 .context = self, 258 258 .writeFn = Terminal.opaqueWrite, 259 259 }; 260 + return @constCast(&writer); 260 261 } 261 262 262 263 fn opaqueRead(ptr: *const anyopaque, buf: []u8) !usize {

Configure Feed

Configure Feed