zterm/examples/tabs.zig

const std = @import("std");
const zterm = @import("zterm");

const App = zterm.App(
    union(enum) {},
    zterm.Renderer.Direct,
    true,
);
const Key = zterm.Key;
const Cell = zterm.Cell;
const Layout = App.Layout;
const Widget = App.Widget;

const log = std.log.scoped(.tabs);

pub fn main() !void {
    errdefer |err| log.err("Application Error: {any}", .{err});

    var gpa: std.heap.GeneralPurposeAllocator(.{}) = .{};
    defer {
        const deinit_status = gpa.deinit();
        // fail test; can't try in defer as defer is executed after we return
        if (deinit_status == .leak) {
            log.err("memory leak", .{});
        }
    }
    const allocator = gpa.allocator();

    var app: App = .{};
    var renderer: App.Renderer = .{};
    // TODO: when not running fullscreen, the application needs to screen down accordingly to display the contents
    // -> size hint how much should it use?

    var layout = Layout.createFrom(Layout.Tab.init(allocator, .{}, .{
        .{
            Layout.createFrom(Layout.Margin.init(allocator, .{ .margin = 10 }, .{
                .widget = Widget.createFrom(blk: {
                    const file = try std.fs.cwd().openFile("./examples/tabs.zig", .{});
                    defer file.close();
                    break :blk Widget.RawText.init(allocator, file);
                }),
            })),
            "Tab 2",
            Cell.Style.Color{ .index = 6 },
        },
        .{
            Layout.createFrom(Layout.Framing.init(
                allocator,
                .{
                    .frame = .round,
                    .title = .{
                        .str = "Content in Margin",
                        .style = .{
                            .ul_style = .single,
                            .ul = .{ .index = 4 },
                            .bold = true,
                        },
                    },
                },
                .{
                    .layout = Layout.createFrom(Layout.Margin.init(allocator, .{ .margin = 10 }, .{
                        .widget = Widget.createFrom(Widget.List.init(allocator, .ordered, .{
                            &[_]Cell{.{ .content = "First entry" }},
                            &[_]Cell{.{ .content = "Second entry" }},
                            &[_]Cell{.{ .content = "Third entry" }},
                        })),
                    })),
                },
            )),
            "Tab 1",
            Cell.Style.Color{ .index = 4 },
        },
    }));
    defer layout.deinit();

    try app.start(null);
    defer app.stop() catch unreachable;

    // App.Event loop
    while (true) {
        const event = app.nextEvent();
        log.debug("received event: {s}", .{@tagName(event)});

        switch (event) {
            .quit => break,
            .resize => |size| {
                renderer.resize(size);
            },
            .key => |key| {
                // ctrl+c to quit
                if (Key.matches(key, .{ .cp = 'c', .mod = .{ .ctrl = true } })) {
                    app.quit();
                }
            },
            .err => |err| {
                log.err("Received {any} with message: {s}", .{ err.err, err.msg });
            },
            else => {},
        }
        const events = try layout.handle(event);
        for (events.items) |e| {
            app.postEvent(e);
        }
        try layout.render(&renderer);
    }
}