diff --git a/build.zig b/build.zig index e7616b9..33a49af 100644 --- a/build.zig +++ b/build.zig @@ -4,21 +4,21 @@ pub fn build(b: *std.Build) void { const target = b.standardTargetOptions(.{}); const optimize = b.standardOptimizeOption(.{}); - const odditui = b.addModule("odditui", .{ .root_source_file = .{ .path = "src/main.zig" } }); + const vaxis = b.addModule("vaxis", .{ .root_source_file = .{ .path = "src/main.zig" } }); const ziglyph = b.dependency("ziglyph", .{ .optimize = optimize, .target = target, }); - odditui.addImport("ziglyph", ziglyph.module("ziglyph")); + vaxis.addImport("ziglyph", ziglyph.module("ziglyph")); const exe = b.addExecutable(.{ - .name = "odditui", + .name = "vaxis", .root_source_file = .{ .path = "examples/main.zig" }, .target = target, .optimize = optimize, }); - exe.root_module.addImport("odditui", odditui); + exe.root_module.addImport("vaxis", vaxis); const run_cmd = b.addRunArtifact(exe); diff --git a/examples/main.zig b/examples/main.zig index 340415d..ce299d0 100644 --- a/examples/main.zig +++ b/examples/main.zig @@ -1,5 +1,5 @@ const std = @import("std"); -const odditui = @import("odditui"); +const vaxis = @import("vaxis"); const log = std.log.scoped(.main); pub fn main() !void { @@ -13,14 +13,14 @@ pub fn main() !void { } const alloc = gpa.allocator(); - var app: odditui.App(Event) = try odditui.App(Event).init(.{}); - defer app.deinit(alloc); + var vx = try vaxis.init(Event, .{}); + defer vx.deinit(alloc); - try app.start(); - defer app.stop(); + try vx.start(); + defer vx.stop(); outer: while (true) { - const event = app.nextEvent(); + const event = vx.nextEvent(); log.debug("event: {}\r\n", .{event}); switch (event) { .key_press => |key| { @@ -29,7 +29,7 @@ pub fn main() !void { } }, .winsize => |ws| { - try app.resize(alloc, ws.rows, ws.cols); + try vx.resize(alloc, ws.rows, ws.cols); }, else => {}, } @@ -37,7 +37,7 @@ pub fn main() !void { } const Event = union(enum) { - key_press: odditui.Key, - winsize: odditui.Winsize, + key_press: vaxis.Key, + winsize: vaxis.Winsize, mouse: u8, }; diff --git a/src/Options.zig b/src/Options.zig new file mode 100644 index 0000000..301afb7 --- /dev/null +++ b/src/Options.zig @@ -0,0 +1,2 @@ +/// Runtime options +const Options = @This(); diff --git a/src/Tty.zig b/src/Tty.zig index c1ac0cb..8c13f50 100644 --- a/src/Tty.zig +++ b/src/Tty.zig @@ -1,9 +1,9 @@ const std = @import("std"); const builtin = @import("builtin"); const os = std.os; -const odditui = @import("main.zig"); -const App = odditui.App; -const Key = odditui.Key; +const vaxis = @import("main.zig"); +const Vaxis = vaxis.Vaxis; +const Key = vaxis.Key; const log = std.log.scoped(.tty); @@ -51,7 +51,7 @@ pub fn stop(self: *Tty) void { pub fn run( self: *Tty, comptime EventType: type, - app: *App(EventType), + vx: *Vaxis(EventType), ) !void { // create a pipe so we can signal to exit the run loop const pipe = try os.pipe(); @@ -71,11 +71,11 @@ pub fn run( const WinchHandler = struct { const Self = @This(); - var winchApp: *App(EventType) = undefined; + var vx_winch: *Vaxis(EventType) = undefined; var fd: os.fd_t = undefined; - fn init(app_arg: *App(EventType), fd_arg: os.fd_t) !void { - winchApp = app_arg; + fn init(vx_arg: *Vaxis(EventType), fd_arg: os.fd_t) !void { + vx_winch = vx_arg; fd = fd_arg; var act = os.Sigaction{ .handler = .{ .handler = Self.handleWinch }, @@ -94,10 +94,10 @@ pub fn run( const ws = getWinsize(fd) catch { return; }; - winchApp.postEvent(.{ .winsize = ws }); + vx_winch.postEvent(.{ .winsize = ws }); } }; - try WinchHandler.init(app, self.fd); + try WinchHandler.init(vx, self.fd); // the state of the parser const State = enum { @@ -157,7 +157,7 @@ pub fn run( else => Key{ .codepoint = b }, }; if (key) |k| { - app.postEvent(.{ .key_press = k }); + vx.postEvent(.{ .key_press = k }); } }, .escape => state = .ground, diff --git a/src/main.zig b/src/main.zig index 2464fdc..cf4e7f0 100644 --- a/src/main.zig +++ b/src/main.zig @@ -1,13 +1,21 @@ -pub const App = @import("app.zig").App; +pub const Vaxis = @import("vaxis.zig").Vaxis; +pub const Options = @import("Options.zig"); + pub const Key = @import("Key.zig"); pub const Winsize = @import("Tty.zig").Winsize; +/// Initialize a Vaxis application. +pub fn init(comptime EventType: type, opts: Options) !Vaxis(EventType) { + return Vaxis(EventType).init(opts); +} + test { _ = @import("Key.zig"); + _ = @import("Options.zig"); _ = @import("Screen.zig"); _ = @import("Tty.zig"); _ = @import("Window.zig"); - _ = @import("app.zig"); _ = @import("cell.zig"); _ = @import("queue.zig"); + _ = @import("vaxis.zig"); } diff --git a/src/app.zig b/src/vaxis.zig similarity index 68% rename from src/app.zig rename to src/vaxis.zig index b1dc72d..fe5a040 100644 --- a/src/app.zig +++ b/src/vaxis.zig @@ -5,25 +5,26 @@ const Tty = @import("Tty.zig"); const Key = @import("Key.zig"); const Screen = @import("Screen.zig"); const Window = @import("Window.zig"); +const Options = @import("Options.zig"); -/// App is the entrypoint for an odditui application. The provided type T should +/// Vaxis is the entrypoint for a Vaxis application. The provided type T should /// be a tagged union which contains all of the events the application will -/// handle. Odditui will look for the following fields on the union and, if +/// handle. Vaxis will look for the following fields on the union and, if /// found, emit them via the "nextEvent" method /// -/// The following events *must* be in your enum +/// The following events are available: /// - `key_press: Key`, for key press events -/// - `winsize: std.os.system.winsize`, for resize events. Must call app.resize -/// when receiving this event -pub fn App(comptime T: type) type { +/// - `winsize: Winsize`, for resize events. Must call app.resize when receiving +/// this event +pub fn Vaxis(comptime T: type) type { return struct { const Self = @This(); - const log = std.log.scoped(.app); + const log = std.log.scoped(.vaxis); pub const EventType = T; - /// the event queue for this App + /// the event queue for Vaxis // // TODO: is 512 ok? queue: queue.Queue(T, 512), @@ -32,10 +33,7 @@ pub fn App(comptime T: type) type { screen: Screen, - /// Runtime options - const Options = struct {}; - - /// Initialize an App with runtime options + /// Initialize Vaxis with runtime options pub fn init(_: Options) !Self { return Self{ .queue = .{}, @@ -44,12 +42,16 @@ pub fn App(comptime T: type) type { }; } - pub fn deinit(self: *Self, alloc: std.mem.Allocator) void { + /// Resets the terminal to it's original state. If an allocator is + /// passed, this will free resources associated with Vaxis. This is left as an + /// optional so applications can choose to not free resources when the + /// application will be exiting anyways + pub fn deinit(self: *Self, alloc: ?std.mem.Allocator) void { if (self.tty) |_| { var tty = &self.tty.?; tty.deinit(); } - self.screen.deinit(alloc); + if (alloc) |a| self.screen.deinit(a); } /// spawns the input thread to start listening to the tty for input @@ -60,6 +62,7 @@ pub fn App(comptime T: type) type { try read_thread.setName("tty"); } + /// stops reading from the tty pub fn stop(self: *Self) void { if (self.tty) |_| { var tty = &self.tty.?; @@ -85,6 +88,7 @@ pub fn App(comptime T: type) type { try self.screen.resize(alloc, w, h); } + /// returns a Window comprising of the entire terminal screen pub fn window(self: *Self) Window { return Window{ .x_off = 0, @@ -98,14 +102,13 @@ pub fn App(comptime T: type) type { }; } -test "App: event queueing" { +test "Vaxis: event queueing" { const Event = union(enum) { key, }; - const alloc = std.testing.allocator; - var app: App(Event) = try App(Event).init(.{}); - defer app.deinit(alloc); - app.postEvent(.key); - const event = app.nextEvent(); + var vx: Vaxis(Event) = try Vaxis(Event).init(.{}); + defer vx.deinit(null); + vx.postEvent(.key); + const event = vx.nextEvent(); try std.testing.expect(event == .key); }