mod: use unbuffered streaming writer for TUIs

examples/continuous.zig

@@ -83,14 +83,14 @@ const InputField = struct {
         };
     }
 
-    fn handle(ctx: *anyopaque, _: *App.Model, event: App.Event) !void {
+    fn handle(ctx: *anyopaque, io: std.Io, _: *App.Model, event: App.Event) !void {
         const this: *@This() = @ptrCast(@alignCast(ctx));
         switch (event) {
             .key => |key| {
                 if (key.isUnicode()) try this.input.append(this.allocator, key.cp);
 
                 if (key.eql(.{ .cp = zterm.input.Enter }) or key.eql(.{ .cp = zterm.input.KpEnter }))
-                    this.queue.push(.{ .accept = try this.input.toOwnedSlice(this.allocator) });
+                    try this.queue.push(io, .{ .accept = try this.input.toOwnedSlice(this.allocator) });
 
                 if (key.eql(.{ .cp = zterm.input.Backspace }))
                     _ = this.input.pop();
@@ -132,8 +132,9 @@ pub fn main(init: std.process.Init) !void {
 
     var app: App = .init(allocator, io, .{});
     var stdout = std.Io.File.stdout();
-    var stdout_buffer: [4096]u8 = undefined;
+    // var stdout_buffer: [4096]u8 = undefined;
-    var writer = stdout.writerStreaming(io, &stdout_buffer);
+    // var writer = stdout.writerStreaming(io, &stdout_buffer);
+    var writer = stdout.writerStreaming(io, &.{});
     const w = &writer.interface;
     defer w.flush() catch |err| log.err("Could not flush: {any}", .{err});
 
@@ -168,8 +169,8 @@ pub fn main(init: std.process.Init) !void {
     }, spinner.element());
     try container.append(nested_container);
 
-    try app.start(.full);
+    try app.start(.full, w);
-    defer app.stop() catch |err| log.err("Failed to stop application: {any}", .{err});
+    defer app.stop(w) catch |err| log.err("Failed to stop application: {any}", .{err});
 
     var framerate: u64 = 60;
     var tick_ms: u64 = @divFloor(time.ms_per_s, framerate);
@@ -177,17 +178,17 @@ pub fn main(init: std.process.Init) !void {
 
     // draw loop
     draw: while (true) {
-        const now_ms: u64 = @intCast(time.milliTimestamp());
+        const now_ms: u64 = @intCast(std.Io.Timestamp.now(io, .real).toMilliseconds());
         if (now_ms >= next_frame_ms) {
             next_frame_ms = now_ms + tick_ms;
         } else {
-            std.Thread.sleep((next_frame_ms - now_ms) * time.ns_per_ms);
+            try io.sleep(.{ .nanoseconds = (next_frame_ms - now_ms) * time.ns_per_ms }, .real);
             next_frame_ms += tick_ms;
         }
 
         const len = blk: {
-            app.queue.lock();
+            try app.queue.lock(io);
-            defer app.queue.unlock();
+            defer app.queue.unlock(io);
             break :blk app.queue.len();
         };
 
@@ -199,7 +200,7 @@ pub fn main(init: std.process.Init) !void {
             switch (event) {
                 .key => |key| {
                     log.debug("key {any}", .{key});
-                    if (key.eql(.{ .cp = 'c', .mod = .{ .ctrl = true } })) app.quit();
+                    if (key.eql(.{ .cp = 'c', .mod = .{ .ctrl = true } })) try app.quit();
                 },
                 .accept => |input| {
                     defer allocator.free(input);
@@ -217,7 +218,7 @@ pub fn main(init: std.process.Init) !void {
                 else => {},
             }
 
-            container.handle(&app.model, event) catch |err| app.postEvent(.{
+            container.handle(io, &app.model, event) catch |err| try app.postEvent(.{
                 .err = .{
                     .err = err,
                     .msg = "Container Event handling failed",
@@ -231,10 +232,10 @@ pub fn main(init: std.process.Init) !void {
             }
         }
 
-        container.resize(&app.model, try renderer.resize());
+        container.resize(&app.model, try renderer.resize(w));
         container.reposition(&app.model, .{});
         try renderer.render(@TypeOf(container), &container, App.Model, &app.model);
-        try renderer.flush();
+        try renderer.flush(w);
     }
 }
 

examples/demo.zig

@@ -31,8 +31,9 @@ pub fn main(init: std.process.Init) !void {
 
     var app: App = .init(gpa, io, .{});
     var stdout = std.Io.File.stdout();
-    var stdout_buffer: [4096]u8 = undefined;
+    // var stdout_buffer: [4096]u8 = undefined;
-    var writer = stdout.writerStreaming(io, &stdout_buffer);
+    // var writer = stdout.writerStreaming(io, &stdout_buffer);
+    var writer = stdout.writerStreaming(io, &.{});
     const w = &writer.interface;
     defer w.flush() catch |err| log.err("Could not flush: {any}", .{err});
 
@@ -186,6 +187,7 @@ pub fn main(init: std.process.Init) !void {
         container.reposition(&app.model, .{});
         try renderer.render(@TypeOf(container), &container, App.Model, &app.model);
         try renderer.flush(w);
+        try w.flush();
     }
 }
 

examples/direct.zig

@@ -166,7 +166,7 @@ pub fn main(init: std.process.Init) !void {
             }
 
             // NOTE returned errors should be propagated back to the application
-            container.handle(&app.model, event) catch |err| try app.postEvent(.{
+            container.handle(io, &app.model, event) catch |err| try app.postEvent(.{
                 .err = .{
                     .err = err,
                     .msg = "Container Event handling failed",

examples/elements/alignment.zig

@@ -58,22 +58,22 @@ pub fn main(init: std.process.Init) !void {
     var alignment: App.Alignment = .init(quit_container, .center);
     try container.append(try .init(allocator, .{}, alignment.element()));
 
-    try app.start(.full);
+    try app.start(.full, w);
-    defer app.stop() catch |err| log.err("Failed to stop application: {any}", .{err});
+    defer app.stop(w) catch |err| log.err("Failed to stop application: {any}", .{err});
 
     // event loop
     while (true) {
-        const event = app.nextEvent();
+        const event = try app.nextEvent();
         log.debug("received event: {s}", .{@tagName(event)});
 
         // pre event handling
         switch (event) {
-            .key => |key| if (key.eql(.{ .cp = 'c', .mod = .{ .ctrl = true } })) app.quit(),
+            .key => |key| if (key.eql(.{ .cp = 'c', .mod = .{ .ctrl = true } })) try app.quit(),
             .err => |err| log.err("Received {s} with message: {s}", .{ @errorName(err.err), err.msg }),
             else => {},
         }
 
-        container.handle(&app.model, event) catch |err| app.postEvent(.{
+        container.handle(io, &app.model, event) catch |err| try app.postEvent(.{
             .err = .{
                 .err = err,
                 .msg = "Container Event handling failed",
@@ -86,10 +86,10 @@ pub fn main(init: std.process.Init) !void {
             else => {},
         }
 
-        container.resize(&app.model, try renderer.resize());
+        container.resize(&app.model, try renderer.resize(w));
         container.reposition(&app.model, .{});
         try renderer.render(@TypeOf(container), &container, App.Model, &app.model);
-        try renderer.flush();
+        try renderer.flush(w);
     }
 }
 

examples/elements/button.zig

@@ -80,6 +80,13 @@ pub fn main(init: std.process.Init) !void {
     const io = init.io;
 
     var app: App = .init(allocator, io, .{});
+    var stdout = std.Io.File.stdout();
+    // var stdout_buffer: [4096]u8 = undefined;
+    // var writer = stdout.writerStreaming(io, &stdout_buffer);
+    var writer = stdout.writerStreaming(io, &.{});
+    const w = &writer.interface;
+    defer w.flush() catch |err| log.err("Could not flush: {any}", .{err});
+
     var renderer = zterm.Renderer.Buffered.init(allocator);
     defer renderer.deinit();
 

examples/elements/input.zig

@@ -37,7 +37,7 @@ const MouseDraw = struct {
         };
     }
 
-    fn handle(ctx: *anyopaque, _: *App.Model, event: App.Event) !void {
+    fn handle(ctx: *anyopaque, _: std.Io, _: *App.Model, event: App.Event) !void {
         const this: *@This() = @ptrCast(@alignCast(ctx));
         switch (event) {
             .mouse => |mouse| this.position = .{ .x = mouse.x, .y = mouse.y },
@@ -115,17 +115,17 @@ pub fn main(init: std.process.Init) !void {
     }, second_mouse_draw.element()));
     try container.append(nested_container);
 
-    try app.start(.full);
+    try app.start(.full, w);
-    defer app.stop() catch |err| log.err("Failed to stop application: {any}", .{err});
+    defer app.stop(w) catch |err| log.err("Failed to stop application: {any}", .{err});
 
     // event loop
     while (true) {
-        const event = app.nextEvent();
+        const event = try app.nextEvent();
         log.debug("received event: {s}", .{@tagName(event)});
 
         // pre event handling
         switch (event) {
-            .key => |key| if (key.eql(.{ .cp = 'c', .mod = .{ .ctrl = true } })) app.quit(),
+            .key => |key| if (key.eql(.{ .cp = 'c', .mod = .{ .ctrl = true } })) try app.quit(),
             .accept => |input| {
                 defer allocator.free(input);
                 log.debug("Accepted input '{s}'", .{input});
@@ -134,7 +134,7 @@ pub fn main(init: std.process.Init) !void {
             else => {},
         }
 
-        container.handle(&app.model, event) catch |err| app.postEvent(.{
+        container.handle(io, &app.model, event) catch |err| try app.postEvent(.{
             .err = .{
                 .err = err,
                 .msg = "Container Event handling failed",
@@ -147,10 +147,10 @@ pub fn main(init: std.process.Init) !void {
             else => {},
         }
 
-        container.resize(&app.model, try renderer.resize());
+        container.resize(&app.model, try renderer.resize(w));
         container.reposition(&app.model, .{});
         try renderer.render(@TypeOf(container), &container, App.Model, &app.model);
-        try renderer.flush();
+        try renderer.flush(w);
     }
 }
 

examples/elements/progress.zig

@@ -88,8 +88,8 @@ pub fn main(init: std.process.Init) !void {
         });
         try container.append(try App.Container.init(allocator, .{}, progress.element()));
     }
-    try app.start(.full);
+    try app.start(.full, w);
-    defer app.stop() catch |err| log.err("Failed to stop application: {any}", .{err});
+    defer app.stop(w) catch |err| log.err("Failed to stop application: {any}", .{err});
 
     var framerate: u64 = 60;
     var tick_ms: u64 = @divFloor(time.ms_per_s, framerate);
@@ -100,11 +100,11 @@ pub fn main(init: std.process.Init) !void {
     // Continuous drawing
     // draw loop
     draw: while (true) {
-        const now_ms: u64 = @intCast(time.milliTimestamp());
+        const now_ms: u64 = @intCast(std.Io.Timestamp.now(io, .real).toMilliseconds());
         if (now_ms >= next_frame_ms) {
             next_frame_ms = now_ms + tick_ms;
         } else {
-            std.Thread.sleep((next_frame_ms - now_ms) * time.ns_per_ms);
+            try io.sleep(.{ .nanoseconds = (next_frame_ms - now_ms) * time.ns_per_ms }, .real);
             next_frame_ms += tick_ms;
         }
 
@@ -114,12 +114,12 @@ pub fn main(init: std.process.Init) !void {
             increase_progress = 10;
             progress_percent += 1;
             if (progress_percent > 100) progress_percent = 0;
-            app.postEvent(.{ .progress = progress_percent });
+            try app.postEvent(.{ .progress = progress_percent });
         }
 
         const len = blk: {
-            app.queue.lock();
+            try app.queue.lock(io);
-            defer app.queue.unlock();
+            defer app.queue.unlock(io);
             break :blk app.queue.len();
         };
 
@@ -130,7 +130,7 @@ pub fn main(init: std.process.Init) !void {
             // pre event handling
             switch (event) {
                 .key => |key| {
-                    if (key.eql(.{ .cp = 'c', .mod = .{ .ctrl = true } })) app.quit();
+                    if (key.eql(.{ .cp = 'c', .mod = .{ .ctrl = true } })) try app.quit();
                 },
                 .err => |err| log.err("Received {s} with message: {s}", .{ @errorName(err.err), err.msg }),
                 .focus => |b| {
@@ -141,7 +141,7 @@ pub fn main(init: std.process.Init) !void {
                 else => {},
             }
 
-            container.handle(&app.model, event) catch |err| app.postEvent(.{
+            container.handle(io, &app.model, event) catch |err| try app.postEvent(.{
                 .err = .{
                     .err = err,
                     .msg = "Container Event handling failed",
@@ -155,10 +155,10 @@ pub fn main(init: std.process.Init) !void {
             }
         }
 
-        container.resize(&app.model, try renderer.resize());
+        container.resize(&app.model, try renderer.resize(w));
         container.reposition(&app.model, .{});
         try renderer.render(@TypeOf(container), &container, App.Model, &app.model);
-        try renderer.flush();
+        try renderer.flush(w);
     }
 }
 

examples/elements/radio-button.zig

@@ -54,23 +54,23 @@ pub fn main(init: std.process.Init) !void {
     try container.append(try .init(allocator, .{}, radiobutton.element()));
     try container.append(try App.Container.init(allocator, .{ .rectangle = .{ .fill = .black } }, button.element()));
 
-    try app.start(.full);
+    try app.start(.full, w);
-    defer app.stop() catch |err| log.err("Failed to stop application: {any}", .{err});
+    defer app.stop(w) catch |err| log.err("Failed to stop application: {any}", .{err});
 
     // event loop
     while (true) {
-        const event = app.nextEvent();
+        const event = try app.nextEvent();
         log.debug("received event: {s}", .{@tagName(event)});
 
         // pre event handling
         switch (event) {
-            .key => |key| if (key.eql(.{ .cp = 'c', .mod = .{ .ctrl = true } })) app.quit(),
+            .key => |key| if (key.eql(.{ .cp = 'c', .mod = .{ .ctrl = true } })) try app.quit(),
             .accept => log.info("Clicked built-in button using the mouse", .{}),
             .err => |err| log.err("Received {s} with message: {s}", .{ @errorName(err.err), err.msg }),
             else => {},
         }
 
-        container.handle(&app.model, event) catch |err| app.postEvent(.{
+        container.handle(io, &app.model, event) catch |err| try app.postEvent(.{
             .err = .{
                 .err = err,
                 .msg = "Container Event handling failed",
@@ -83,10 +83,10 @@ pub fn main(init: std.process.Init) !void {
             else => {},
         }
 
-        container.resize(&app.model, try renderer.resize());
+        container.resize(&app.model, try renderer.resize(w));
         container.reposition(&app.model, .{});
         try renderer.render(@TypeOf(container), &container, App.Model, &app.model);
-        try renderer.flush();
+        try renderer.flush(w);
     }
 }
 

examples/elements/scrollable.zig

@@ -60,8 +60,9 @@ pub fn main(init: std.process.Init) !void {
 
     var app: App = .init(allocator, io, .{});
     var stdout = std.Io.File.stdout();
-    var stdout_buffer: [4096]u8 = undefined;
+    // var stdout_buffer: [4096]u8 = undefined;
-    var writer = stdout.writerStreaming(io, &stdout_buffer);
+    // var writer = stdout.writerStreaming(io, &stdout_buffer);
+    var writer = stdout.writerStreaming(io, &.{});
     const w = &writer.interface;
     defer w.flush() catch |err| log.err("Could not flush: {any}", .{err});
 
@@ -165,7 +166,7 @@ pub fn main(init: std.process.Init) !void {
             else => {},
         }
 
-        container.handle(&app.model, event) catch |err| try app.postEvent(.{
+        container.handle(io, &app.model, event) catch |err| try app.postEvent(.{
             .err = .{
                 .err = err,
                 .msg = "Container Event handling failed",

examples/elements/selection.zig

@@ -55,22 +55,22 @@ pub fn main(init: std.process.Init) !void {
     defer container.deinit();
     try container.append(try .init(allocator, .{}, selection.element()));
 
-    try app.start(.full);
+    try app.start(.full, w);
-    defer app.stop() catch |err| log.err("Failed to stop application: {any}", .{err});
+    defer app.stop(w) catch |err| log.err("Failed to stop application: {any}", .{err});
 
     // event loop
     while (true) {
-        const event = app.nextEvent();
+        const event = try app.nextEvent();
         log.debug("received event: {s}", .{@tagName(event)});
 
         // pre event handling
         switch (event) {
-            .key => |key| if (key.eql(.{ .cp = 'c', .mod = .{ .ctrl = true } })) app.quit(),
+            .key => |key| if (key.eql(.{ .cp = 'c', .mod = .{ .ctrl = true } })) try app.quit(),
             .err => |err| log.err("Received {s} with message: {s}", .{ @errorName(err.err), err.msg }),
             else => {},
         }
 
-        container.handle(&app.model, event) catch |err| app.postEvent(.{
+        container.handle(io, &app.model, event) catch |err| try app.postEvent(.{
             .err = .{
                 .err = err,
                 .msg = "Container Event handling failed",
@@ -83,10 +83,10 @@ pub fn main(init: std.process.Init) !void {
             else => {},
         }
 
-        container.resize(&app.model, try renderer.resize());
+        container.resize(&app.model, try renderer.resize(w));
         container.reposition(&app.model, .{});
         try renderer.render(@TypeOf(container), &container, App.Model, &app.model);
-        try renderer.flush();
+        try renderer.flush(w);
     }
 }
 

examples/errors.zig

@@ -57,7 +57,7 @@ const ErrorNotification = struct {
         return .{ .ptr = this, .vtable = &.{ .handle = handle, .content = content } };
     }
 
-    fn handle(ctx: *anyopaque, _: *App.Model, event: App.Event) !void {
+    fn handle(ctx: *anyopaque, _: std.Io, _: *App.Model, event: App.Event) !void {
         const this: *@This() = @ptrCast(@alignCast(ctx));
         switch (event) {
             .key => |key| if (!key.isAscii()) return zterm.Error.TooSmall,
@@ -119,21 +119,21 @@ pub fn main(init: std.process.Init) !void {
     try container.append(try App.Container.init(allocator, .{}, info_text.element()));
     try container.append(try App.Container.init(allocator, .{}, error_notification.element()));
 
-    try app.start(.full);
+    try app.start(.full, w);
-    defer app.stop() catch |err| log.err("Failed to stop application: {any}", .{err});
+    defer app.stop(w) catch |err| log.err("Failed to stop application: {any}", .{err});
 
     while (true) {
-        const event = app.nextEvent();
+        const event = try app.nextEvent();
         log.debug("received event: {s}", .{@tagName(event)});
 
         // pre event handling
         switch (event) {
-            .key => |key| if (key.eql(.{ .cp = 'c', .mod = .{ .ctrl = true } })) app.quit(),
+            .key => |key| if (key.eql(.{ .cp = 'c', .mod = .{ .ctrl = true } })) try app.quit(),
             .err => |err| log.err("Received {s} with message: {s}", .{ @errorName(err.err), err.msg }),
             else => {},
         }
 
-        container.handle(&app.model, event) catch |err| app.postEvent(.{
+        container.handle(io, &app.model, event) catch |err| try app.postEvent(.{
             .err = .{
                 .err = err,
                 .msg = "Container Event handling failed",
@@ -146,10 +146,10 @@ pub fn main(init: std.process.Init) !void {
             else => {},
         }
 
-        container.resize(&app.model, try renderer.resize());
+        container.resize(&app.model, try renderer.resize(w));
         container.reposition(&app.model, .{});
         try renderer.render(@TypeOf(container), &container, App.Model, &app.model);
-        try renderer.flush();
+        try renderer.flush(w);
     }
 }
 

examples/layouts/grid.zig

@@ -72,24 +72,24 @@ pub fn main(init: std.process.Init) !void {
     }
     defer container.deinit(); // also de-initializes the children
 
-    try app.start(.full);
+    try app.start(.full, w);
-    defer app.stop() catch |err| log.err("Failed to stop application: {any}", .{err});
+    defer app.stop(w) catch |err| log.err("Failed to stop application: {any}", .{err});
 
     // event loop
     while (true) {
-        const event = app.nextEvent();
+        const event = try app.nextEvent();
         log.debug("received event: {s}", .{@tagName(event)});
 
         // pre event handling
         switch (event) {
-            .key => |key| if (key.eql(.{ .cp = 'c', .mod = .{ .ctrl = true } })) app.quit(),
+            .key => |key| if (key.eql(.{ .cp = 'c', .mod = .{ .ctrl = true } })) try app.quit(),
             // NOTE errors could be displayed in another container in case one was received, etc. to provide the user with feedback
             .err => |err| log.err("Received {s} with message: {s}", .{ @errorName(err.err), err.msg }),
             else => {},
         }
 
         // NOTE returned errors should be propagated back to the application
-        container.handle(&app.model, event) catch |err| app.postEvent(.{
+        container.handle(io, &app.model, event) catch |err| try app.postEvent(.{
             .err = .{
                 .err = err,
                 .msg = "Container Event handling failed",
@@ -102,10 +102,10 @@ pub fn main(init: std.process.Init) !void {
             else => {},
         }
 
-        container.resize(&app.model, try renderer.resize());
+        container.resize(&app.model, try renderer.resize(w));
         container.reposition(&app.model, .{});
         try renderer.render(@TypeOf(container), &container, App.Model, &app.model);
-        try renderer.flush();
+        try renderer.flush(w);
     }
 }
 

examples/layouts/horizontal.zig

@@ -64,24 +64,24 @@ pub fn main(init: std.process.Init) !void {
     }, .{}));
     defer container.deinit(); // also de-initializes the children
 
-    try app.start(.full);
+    try app.start(.full, w);
-    defer app.stop() catch |err| log.err("Failed to stop application: {any}", .{err});
+    defer app.stop(w) catch |err| log.err("Failed to stop application: {any}", .{err});
 
     // event loop
     while (true) {
-        const event = app.nextEvent();
+        const event = try app.nextEvent();
         log.debug("received event: {s}", .{@tagName(event)});
 
         // pre event handling
         switch (event) {
-            .key => |key| if (key.eql(.{ .cp = 'c', .mod = .{ .ctrl = true } })) app.quit(),
+            .key => |key| if (key.eql(.{ .cp = 'c', .mod = .{ .ctrl = true } })) try app.quit(),
             // NOTE errors could be displayed in another container in case one was received, etc. to provide the user with feedback
             .err => |err| log.err("Received {s} with message: {s}", .{ @errorName(err.err), err.msg }),
             else => {},
         }
 
         // NOTE returned errors should be propagated back to the application
-        container.handle(&app.model, event) catch |err| app.postEvent(.{
+        container.handle(io, &app.model, event) catch |err| try app.postEvent(.{
             .err = .{
                 .err = err,
                 .msg = "Container Event handling failed",
@@ -94,10 +94,10 @@ pub fn main(init: std.process.Init) !void {
             else => {},
         }
 
-        container.resize(&app.model, try renderer.resize());
+        container.resize(&app.model, try renderer.resize(w));
         container.reposition(&app.model, .{});
         try renderer.render(@TypeOf(container), &container, App.Model, &app.model);
-        try renderer.flush();
+        try renderer.flush(w);
     }
 }
 

examples/layouts/mixed.zig

@@ -80,24 +80,24 @@ pub fn main(init: std.process.Init) !void {
     }
     defer container.deinit(); // also de-initializes the children
 
-    try app.start(.full);
+    try app.start(.full, w);
-    defer app.stop() catch |err| log.err("Failed to stop application: {any}", .{err});
+    defer app.stop(w) catch |err| log.err("Failed to stop application: {any}", .{err});
 
     // event loop
     while (true) {
-        const event = app.nextEvent();
+        const event = try app.nextEvent();
         log.debug("received event: {s}", .{@tagName(event)});
 
         // pre event handling
         switch (event) {
-            .key => |key| if (key.eql(.{ .cp = 'c', .mod = .{ .ctrl = true } })) app.quit(),
+            .key => |key| if (key.eql(.{ .cp = 'c', .mod = .{ .ctrl = true } })) try app.quit(),
             // NOTE errors could be displayed in another container in case one was received, etc. to provide the user with feedback
             .err => |err| log.err("Received {s} with message: {s}", .{ @errorName(err.err), err.msg }),
             else => {},
         }
 
         // NOTE returned errors should be propagated back to the application
-        container.handle(&app.model, event) catch |err| app.postEvent(.{
+        container.handle(io, &app.model, event) catch |err| try app.postEvent(.{
             .err = .{
                 .err = err,
                 .msg = "Container Event handling failed",
@@ -110,10 +110,10 @@ pub fn main(init: std.process.Init) !void {
             else => {},
         }
 
-        container.resize(&app.model, try renderer.resize());
+        container.resize(&app.model, try renderer.resize(w));
         container.reposition(&app.model, .{});
         try renderer.render(@TypeOf(container), &container, App.Model, &app.model);
-        try renderer.flush();
+        try renderer.flush(w);
     }
 }
 

examples/layouts/vertical.zig

@@ -63,24 +63,24 @@ pub fn main(init: std.process.Init) !void {
     }, .{}));
     defer container.deinit(); // also de-initializes the children
 
-    try app.start(.full);
+    try app.start(.full, w);
-    defer app.stop() catch |err| log.err("Failed to stop application: {any}", .{err});
+    defer app.stop(w) catch |err| log.err("Failed to stop application: {any}", .{err});
 
     // event loop
     while (true) {
-        const event = app.nextEvent();
+        const event = try app.nextEvent();
         log.debug("received event: {s}", .{@tagName(event)});
 
         // pre event handling
         switch (event) {
-            .key => |key| if (key.eql(.{ .cp = 'c', .mod = .{ .ctrl = true } })) app.quit(),
+            .key => |key| if (key.eql(.{ .cp = 'c', .mod = .{ .ctrl = true } })) try app.quit(),
             // NOTE errors could be displayed in another container in case one was received, etc. to provide the user with feedback
             .err => |err| log.err("Received {s} with message: {s}", .{ @errorName(err.err), err.msg }),
             else => {},
         }
 
         // NOTE returned errors should be propagated back to the application
-        container.handle(&app.model, event) catch |err| app.postEvent(.{
+        container.handle(io, &app.model, event) catch |err| try app.postEvent(.{
             .err = .{
                 .err = err,
                 .msg = "Container Event handling failed",
@@ -93,10 +93,10 @@ pub fn main(init: std.process.Init) !void {
             else => {},
         }
 
-        container.resize(&app.model, try renderer.resize());
+        container.resize(&app.model, try renderer.resize(w));
         container.reposition(&app.model, .{});
         try renderer.render(@TypeOf(container), &container, App.Model, &app.model);
-        try renderer.flush();
+        try renderer.flush(w);
     }
 }
 

examples/styles/palette.zig

@@ -31,8 +31,9 @@ pub fn main(init: std.process.Init) !void {
 
     var app: App = .init(allocator, io, .{});
     var stdout = std.Io.File.stdout();
-    var stdout_buffer: [4096]u8 = undefined;
+    // var stdout_buffer: [4096]u8 = undefined;
-    var writer = stdout.writerStreaming(io, &stdout_buffer);
+    // var writer = stdout.writerStreaming(io, &stdout_buffer);
+    var writer = stdout.writerStreaming(io, &.{});
     const w = &writer.interface;
     defer w.flush() catch |err| log.err("Could not flush: {any}", .{err});
 
@@ -61,21 +62,21 @@ pub fn main(init: std.process.Init) !void {
     var scrollable: App.Scrollable = .init(box, .disabled);
     try container.append(try App.Container.init(allocator, .{}, scrollable.element()));
 
-    try app.start(.full);
+    try app.start(.full, w);
-    defer app.stop() catch |err| log.err("Failed to stop application: {any}", .{err});
+    defer app.stop(w) catch |err| log.err("Failed to stop application: {any}", .{err});
 
     while (true) {
-        const event = app.nextEvent();
+        const event = try app.nextEvent();
         log.debug("received event: {s}", .{@tagName(event)});
 
         // pre event handling
         switch (event) {
-            .key => |key| if (key.eql(.{ .cp = 'c', .mod = .{ .ctrl = true } })) app.quit(),
+            .key => |key| if (key.eql(.{ .cp = 'c', .mod = .{ .ctrl = true } })) try app.quit(),
             .err => |err| log.err("Received {s} with message: {s}", .{ @errorName(err.err), err.msg }),
             else => {},
         }
 
-        container.handle(&app.model, event) catch |err| app.postEvent(.{
+        container.handle(io, &app.model, event) catch |err| try app.postEvent(.{
             .err = .{
                 .err = err,
                 .msg = "Container Event handling failed",
@@ -88,10 +89,10 @@ pub fn main(init: std.process.Init) !void {
             else => {},
         }
 
-        container.resize(&app.model, try renderer.resize());
+        container.resize(&app.model, try renderer.resize(w));
         container.reposition(&app.model, .{});
         try renderer.render(@TypeOf(container), &container, App.Model, &app.model);
-        try renderer.flush();
+        try renderer.flush(w);
     }
 }
 

examples/styles/text.zig

@@ -212,31 +212,31 @@ pub fn main(init: std.process.Init) !void {
     }, text_styles.element()), .enabled(.white, true));
     try container.append(try App.Container.init(allocator, .{}, scrollable.element()));
 
-    try app.start(.full);
+    try app.start(.full, w);
-    defer app.stop() catch |err| log.err("Failed to stop application: {any}", .{err});
+    defer app.stop(w) catch |err| log.err("Failed to stop application: {any}", .{err});
 
     // event loop
     loop: while (true) {
         // batch events since last iteration
         const len = blk: {
-            app.queue.poll();
+            try app.queue.poll(io);
-            app.queue.lock();
+            try app.queue.lock(io);
-            defer app.queue.unlock();
+            defer app.queue.unlock(io);
             break :blk app.queue.len();
         };
 
         // handle events
         for (0..len) |_| {
-            const event = app.queue.pop();
+            const event = app.queue.drain() orelse break;
             log.debug("handling event: {s}", .{@tagName(event)});
             // pre event handling
             switch (event) {
-                .key => |key| if (key.eql(.{ .cp = 'c', .mod = .{ .ctrl = true } })) app.quit(),
+                .key => |key| if (key.eql(.{ .cp = 'c', .mod = .{ .ctrl = true } })) try app.quit(),
                 .err => |err| log.err("Received {s} with message: {s}", .{ @errorName(err.err), err.msg }),
                 else => {},
             }
 
-            container.handle(&app.model, event) catch |err| app.postEvent(.{
+            container.handle(io, &app.model, event) catch |err| try app.postEvent(.{
                 .err = .{
                     .err = err,
                     .msg = "Container Event handling failed",
@@ -250,10 +250,10 @@ pub fn main(init: std.process.Init) !void {
             }
         }
 
-        container.resize(&app.model, try renderer.resize());
+        container.resize(&app.model, try renderer.resize(w));
         container.reposition(&app.model, .{});
         try renderer.render(@TypeOf(container), &container, App.Model, &app.model);
-        try renderer.flush();
+        try renderer.flush(w);
     }
 }
 

src/cell.zig

@@ -16,7 +16,10 @@ pub fn value(this: Cell, writer: *std.Io.Writer) !void {
     // TODO the style values should be concatinated, such that less bytes are written to the terminal
     try this.style.value(writer, this.cp);
     // std.log.debug("writer buffer size: {d}", .{writer.end});
-    if (writer.end >= writer.buffer.len - 32) writer.flush() catch {};
+    // NOTE flushing should not be necessary by the library, but from the user!
+    // if (writer.buffer.len > 255) {
+    //     if (writer.end >= writer.buffer.len - 256) try writer.flush();
+    // } else try writer.flush();
 }
 
 const std = @import("std");