feat: console: Add paging output

JacobCrabill · JacobCrabill · commit b409bf86b1a6 · 2025-12-12T14:56:32.000-08:00
A bit weird when attempting to display images, but works for plain text
diff --git a/src/app/present.zig b/src/app/present.zig
@@ -1,6 +1,6 @@
 const std = @import("std");
 const zd = @import("zigdown");
-const RawTTY = @import("RawTTY.zig");
+const RawTTY = zd.RawTTY;
 
 const Allocator = std.mem.Allocator;
 const ArrayList = std.array_list.Managed;
diff --git a/src/lib/RawTTY.zig b/src/lib/RawTTY.zig
@@ -74,6 +74,7 @@ pub fn read(self: Self) u8 {
     }
 }
 
-fn moveCursor(self: Self, row: usize, col: usize) !void {
+/// Move the cursor to the given (zero-indexed) row and column
+pub fn moveCursor(self: Self, row: usize, col: usize) !void {
     _ = try self.writer.print("\x1B[{};{}H", .{ row + 1, col + 1 });
 }
diff --git a/src/lib/cli.zig b/src/lib/cli.zig
@@ -98,6 +98,7 @@ pub const ConsoleRenderCmdOpts = struct {
     verbose: bool = false,
     timeit: bool = false,
     nofetch: bool = false,
+    pager: bool = false,
     positional: struct {
         file: ?[]const u8,
         pub const descriptions = .{
@@ -111,6 +112,7 @@ pub const ConsoleRenderCmdOpts = struct {
         .timeit = "Time the parsing & rendering and display the results",
         .verbose = "Enable verbose output from the parser",
         .nofetch = "Don't fetch images from the internet (just display the image link)",
+        .pager = "Page the output in the terminal (e.g. like 'less')",
     };
     pub const switches = .{
         .stdin = 'i',
@@ -119,6 +121,7 @@ pub const ConsoleRenderCmdOpts = struct {
         .verbose = 'v',
         .timeit = 't',
         .nofetch = 'n',
+        .pager = 'p',
     };
 };
 
diff --git a/src/lib/render.zig b/src/lib/render.zig
@@ -2,6 +2,8 @@ const std = @import("std");
 const blocks = @import("ast/blocks.zig");
 const gfx = @import("image.zig");
 const cli = @import("cli.zig");
+const cons = @import("console.zig");
+const RawTTY = @import("RawTTY.zig");
 
 const Allocator = std.mem.Allocator;
 
@@ -57,8 +59,13 @@ pub fn render(opts: RenderOptions) !void {
                 columns = @min(tsize.cols, columns);
             }
 
+            var render_buf: std.io.Writer.Allocating = .init(opts.alloc);
+            defer render_buf.deinit();
+
+            const render_writer: *std.io.Writer = if (cfg.pager) &render_buf.writer else opts.out_stream;
+
             var c_renderer = ConsoleRenderer.init(
-                opts.out_stream,
+                render_writer,
                 arena.allocator(),
                 .{
                     .root_dir = opts.document_dir,
@@ -71,6 +78,12 @@ pub fn render(opts: RenderOptions) !void {
             );
             defer c_renderer.deinit();
             try c_renderer.renderBlock(opts.document);
+
+            if (cfg.pager) {
+                // If we're paging the output, the render above was to a temporary buffer.
+                // Take that output and page it to the console
+                try pageOutput(opts.alloc, opts.out_stream, render_buf.written());
+            }
         },
         .range => {
             // Get the terminal size; limit our width to that
@@ -112,6 +125,84 @@ pub fn render(opts: RenderOptions) !void {
     opts.out_stream.flush() catch @panic("Can't flush output stream");
 }
 
+/// Page the output to the terminal given by 'writer'.
+///
+/// alloc:  The allocator to use for all file reading, parsing, and rendering.
+/// writer: The writer for the tty to page the output to.
+/// output: The rendered output to page.
+pub fn pageOutput(alloc: Allocator, writer: *std.io.Writer, output: []const u8) !void {
+    const raw_tty = try RawTTY.init(writer);
+    defer raw_tty.deinit();
+
+    var lines: std.ArrayList([]const u8) = try splitLines(alloc, output);
+    defer lines.deinit(alloc);
+
+    const n_rows = lines.items.len;
+    const tsize = gfx.getTerminalSize() catch gfx.TermSize{};
+
+    // Begin the presentation, using stdin to go forward/backward
+    var quit: bool = false;
+    var row: usize = 0;
+    while (!quit) {
+        _ = try writer.write(cons.clear_screen);
+        try raw_tty.moveCursor(0, 0);
+        for (lines.items[row..@min(row + tsize.rows - 1, n_rows)]) |line| {
+            try writer.writeAll(line);
+            try writer.writeAll("\n");
+        }
+        // TODO: Consider putting in lower-right corner like slide # in present mode
+        // try writer.print("[row {d} / {d}]\n", .{ row, n_rows });
+        try writer.flush();
+
+        switch (raw_tty.read()) {
+            'n', 'j', 'l' => { // Next Slide
+                if (row < n_rows)
+                    row += 1;
+            },
+            'p', 'h', 'k' => { // Previous Slide
+                if (row > 0) {
+                    row -= 1;
+                }
+            },
+            'q' => { // Quit
+                quit = true;
+            },
+            27 => { // Escape (0x1b)
+                if (raw_tty.read() == 91) { // 0x5b (??)
+                    switch (raw_tty.read()) {
+                        66, 67 => { // Down, Right -- Next Slide
+                            if (row < n_rows) {
+                                row += 1;
+                            }
+                        },
+                        65, 68 => { // Up, Left -- Previous Slide
+                            if (row > 0) {
+                                row -= 1;
+                            }
+                        },
+                        else => {},
+                    }
+                }
+            },
+            else => {},
+        }
+    }
+}
+
+/// Split a document into individual lines.
+///
+/// The lines of text are not duplicated; they point within the given text slice.
+fn splitLines(alloc: Allocator, text: []const u8) !std.ArrayList([]const u8) {
+    var lines: std.ArrayList([]const u8) = .empty;
+
+    var line_iter = std.mem.splitScalar(u8, text, '\n');
+    while (line_iter.next()) |line| {
+        try lines.append(alloc, line);
+    }
+
+    return lines;
+}
+
 //////////////////////////////////////////////////////////
 // Tests
 //////////////////////////////////////////////////////////
diff --git a/src/lib/render/render_console.zig b/src/lib/render/render_console.zig
@@ -627,6 +627,10 @@ pub const ConsoleRenderer = struct {
         const ncol = table.content.Table.ncol;
         const col_w = @divFloor(self.opts.width - (2 * self.opts.indent) - (ncol + 1), ncol);
 
+        // The total width of all text to be rendered (removing inter-column spacing)
+        const render_width = self.opts.width - (2 * self.opts.indent) - (ncol + 1);
+        const render_width_f: f32 = @floatFromInt(render_width);
+
         // Create a new renderer to render into a buffer for each cell
         // Use an arena to simplify memory management here
         var arena = std.heap.ArenaAllocator.init(self.alloc);
@@ -639,11 +643,33 @@ pub const ConsoleRenderer = struct {
         };
         var cells = ArrayList(Cell).init(alloc);
 
-        for (table.children.items) |item| {
+        const relative_widths = table.content.Table.relative_width.items;
+        const total_width: usize = blk: {
+            var sum: usize = 0;
+            for (relative_widths) |w| {
+                sum += w;
+            }
+            break :blk sum;
+        };
+        const total_width_f: f32 = @floatFromInt(total_width);
+
+        // Compute & store the (integer) width of each column
+        var col_widths = try ArrayList(u32).initCapacity(alloc, ncol);
+        for (relative_widths) |w| {
+            const rel_width: f32 = @floatFromInt(w);
+            const width_frac: f32 = rel_width / total_width_f;
+            col_widths.appendAssumeCapacity(@intFromFloat(@round(width_frac * render_width_f)));
+        }
+
+        for (table.children.items, 0..) |item, i| {
+            // Compute the width of this cell based on which column it is in
+            const col_idx: usize = @mod(i, ncol);
+            const width: usize = col_widths.items[col_idx];
+
             // Render the table cell into a new buffer
             var alloc_writer = std.Io.Writer.Allocating.init(alloc);
             const sub_opts = Config{
-                .width = col_w - 1,
+                .width = width - 1, // col_w - 1,
                 .indent = 1,
                 .max_image_rows = self.opts.max_image_rows,
                 .max_image_cols = col_w - 2 * self.opts.indent,
@@ -664,7 +690,7 @@ pub const ConsoleRenderer = struct {
         const nrow: usize = @divFloor(cells.items.len, ncol);
         std.debug.assert(cells.items.len == ncol * nrow);
 
-        self.writeTableBorderTop(ncol, col_w);
+        self.writeTableBorderTop(ncol, col_widths.items);
 
         for (0..nrow) |i| {
             // Get the max number of rows of text for any cell in the table row
@@ -683,14 +709,20 @@ pub const ConsoleRenderer = struct {
             // Loop over the # of rows of text in this single row of the table
             for (0..max_rows) |_| {
                 self.writeLeaders();
+                var left_col_idx: usize = self.opts.indent + 2;
                 for (0..ncol) |j| {
                     const cell_idx: usize = i * ncol + j;
                     const cell: *Cell = &cells.items[cell_idx];
 
+                    const rel_width: f32 = @floatFromInt(relative_widths[j]);
+                    const width_f: f32 = (rel_width / total_width_f) * render_width_f;
+                    const width: usize = @intFromFloat(@round(width_f));
+
                     // For each cell in the row...
                     self.write(self.opts.box_style.vb);
                     self.write(" ");
 
+                    // --- TODO --- left/center/right alignment should be handled here
                     if (cell.idx < cell.text.len) {
                         // Write the next line of text from that cell,
                         // then increment the write head index of that cell.
@@ -706,11 +738,14 @@ pub const ConsoleRenderer = struct {
                         cell.idx += text.len + 1;
 
                         // Move the cursor to the start of the next cell
-                        const new_col: usize = self.opts.indent + (j + 2) + (j + 1) * col_w;
+                        // const new_col: usize = self.opts.indent + (j + 2) + (j + 1) * col_w;
+                        left_col_idx += width + 1;
+                        const new_col = left_col_idx;
                         self.printno(cons.set_col, .{new_col});
                         self.column = new_col;
                     } else {
-                        self.writeNTimes(" ", col_w - 1);
+                        // self.writeNTimes(" ", col_w - 1);
+                        self.writeNTimes(" ", width - 1);
                     }
                 }
                 self.write(self.opts.box_style.vb);
@@ -721,16 +756,17 @@ pub const ConsoleRenderer = struct {
             self.writeLeaders();
 
             if (i == nrow - 1) {
-                self.writeTableBorderBottom(ncol, col_w);
+                self.writeTableBorderBottom(ncol, col_widths.items);
             } else {
-                self.writeTableBorderMiddle(ncol, col_w);
+                self.writeTableBorderMiddle(ncol, col_widths.items);
             }
         }
     }
 
-    fn writeTableBorderTop(self: *Self, ncol: usize, col_w: usize) void {
+    fn writeTableBorderTop(self: *Self, ncol: usize, col_widths: []const u32) void {
         self.write(self.opts.box_style.tl);
         for (0..ncol) |i| {
+            const col_w: usize = col_widths[i];
             for (0..col_w) |_| {
                 self.write(self.opts.box_style.hb);
             }
@@ -744,9 +780,10 @@ pub const ConsoleRenderer = struct {
         self.writeLeaders();
     }
 
-    fn writeTableBorderMiddle(self: *Self, ncol: usize, col_w: usize) void {
+    fn writeTableBorderMiddle(self: *Self, ncol: usize, col_widths: []const u32) void {
         self.write(self.opts.box_style.lj);
         for (0..ncol) |i| {
+            const col_w: usize = col_widths[i];
             for (0..col_w) |_| {
                 self.write(self.opts.box_style.hb);
             }
@@ -760,9 +797,10 @@ pub const ConsoleRenderer = struct {
         self.writeLeaders();
     }
 
-    fn writeTableBorderBottom(self: *Self, ncol: usize, col_w: usize) void {
+    fn writeTableBorderBottom(self: *Self, ncol: usize, col_widths: []const u32) void {
         self.write(self.opts.box_style.bl);
         for (0..ncol) |i| {
+            const col_w: usize = col_widths[i];
             for (0..col_w) |_| {
                 self.write(self.opts.box_style.hb);
             }
diff --git a/src/lib/zigdown.zig b/src/lib/zigdown.zig
@@ -22,6 +22,7 @@ pub const blocks = @import("ast/blocks.zig");
 pub const gfx = @import("image.zig");
 pub const ts_queries = @import("ts_queries.zig");
 pub const wasm = @import("wasm.zig");
+pub const RawTTY = @import("RawTTY.zig");
 
 // Global public Zigdown types
 // pub const Markdown = markdown.Markdown;

Original file line number	Diff line number	Diff line change
`@@ -74,6 +74,7 @@ pub fn read(self: Self) u8 {`
`74`	`74`	`}`
`75`	`75`	`}`
`76`	`76`
`77`		`-fn moveCursor(self: Self, row: usize, col: usize) !void {`
	`77`	`+/// Move the cursor to the given (zero-indexed) row and column`
	`78`	`+pub fn moveCursor(self: Self, row: usize, col: usize) !void {`
`78`	`79`	`_ = try self.writer.print("\x1B[{};{}H", .{ row + 1, col + 1 });`
`79`	`80`	`}`