initial commit

src/main.zig

@@ -0,0 +1,90 @@
+const std = @import("std");
+const zterm = @import("zterm");
+
+const App = zterm.App(
+    union(enum) {},
+    zterm.Renderer.Plain,
+    true,
+);
+const Key = zterm.Key;
+
+const log = std.log.scoped(.default);
+
+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 = .{};
+
+    const mainFile = try std.fs.cwd().openFile("./src/main.zig", .{});
+    var mainFileText = App.Widget.RawText.init(allocator, mainFile);
+    mainFile.close();
+
+    const appFile = try std.fs.cwd().openFile("./src/app.zig", .{});
+    var appFileText = App.Widget.RawText.init(allocator, appFile);
+    appFile.close();
+
+    var framing = App.Layout.Framing.init(allocator, .{
+        .widget = App.Widget.createFrom(&mainFileText),
+    });
+    var hstack = App.Layout.HStack.init(allocator, .{
+        App.Layout.createFrom(&framing),
+    });
+    var vstack = App.Layout.VStack.init(allocator, .{
+        App.Widget.createFrom(&appFileText),
+        App.Layout.createFrom(&hstack),
+    });
+    var layout = App.Layout.createFrom(&vstack);
+    defer layout.deinit();
+
+    try app.start();
+    defer app.stop() catch unreachable;
+
+    // App.Event loop
+    while (true) {
+        const event = app.nextEvent();
+
+        switch (event) {
+            .quit => break,
+            .key => |key| {
+                // ctrl+c to quit
+                if (Key.matches(key, .{ .cp = 'c', .mod = .{ .ctrl = true } })) {
+                    app.quit();
+                }
+                if (Key.matches(key, .{ .cp = 'n', .mod = .{ .ctrl = true } })) {
+                    try app.interrupt();
+                    defer app.start() catch @panic("could not start app event loop");
+                    var child = std.process.Child.init(&.{"hx"}, allocator);
+                    _ = child.spawnAndWait() catch |err| {
+                        app.postEvent(.{
+                            .err = .{
+                                .err = err,
+                                .msg = "Spawning Helix failed",
+                            },
+                        });
+                    };
+                }
+            },
+            .err => |err| {
+                log.err("Received {any} with message: {s}", .{ err.err, err.msg });
+            },
+            else => {},
+        }
+        // NOTE: this currently re-renders the screen for every key-press -> which might be a bit of an overkill
+        const events = try layout.handle(event);
+        for (events.items) |e| {
+            app.postEvent(e);
+        }
+        try renderer.render(try layout.content());
+    }
+}