a lot, again

src/main.zig

@@ -5,6 +5,7 @@ const fs = std.fs;
 const mem = std.mem;
 const heap = std.heap;
 const fmt = std.fmt;
+const posix = std.posix;
 
 pub fn main() !void {
     var gpa = heap.GeneralPurposeAllocator(.{}){};
@@ -15,15 +16,29 @@ pub fn main() !void {
     defer term.deinit();
     try term.clearScreen();
 
-    var box = Terminal.Box.init(allocator);
+    // var box1 = Terminal.Box.init(allocator);
-    defer box.deinit();
+    // defer box1.deinit();
-    box.content = "hi";
+    // box1.content = "hi";
-    box.border = true;
+    // box1.top = 0;
+    // box1.bottom = 0;
+    // box1.left = 0;
+    // box1.right = 0;
 
-    try term.box.addChild(&box);
+    // var box2 = Terminal.Box.init(allocator);
-    term.box.border = true;
+    // defer box2.deinit();
+    // box2.content = "hi";
+    // box2.left = 80;
 
-    try term.draw();
+    // try term.box.addChild(&box1);
+    // try term.box.addChild(&box2);
+
+    while (true) {
+        const events = try term.getEvents();
+        _ = events;
+        // for (events) |ev| if (ev.system == .winch) std.debug.print("hii\n", .{});
+        try term.draw();
+        std.time.sleep(1000);
+    }
 
     // var box = Terminal.Box{
     //     .x = 0,
@@ -62,6 +77,8 @@ pub const Terminal = struct {
 
     box: Box,
 
+    events: std.ArrayList(Event),
+
     pub fn init(allocator: mem.Allocator) !Terminal {
         var term = Terminal{
             .tty = try fs.openFileAbsolute("/dev/tty", .{ .mode = .read_write }),
@@ -69,29 +86,33 @@ pub const Terminal = struct {
             .info = try Info.init(allocator),
             .allocator = allocator,
             .box = Box.init(allocator),
+            .events = std.ArrayList(Event).init(allocator),
         };
         errdefer term.tty.close();
         errdefer term.info.deinit();
-        term.uncook();
+        term.box.position = .{ .x = 0, .y = 0, .width = 50, .height = 20 };
+        try term.uncook();
+        try attachSignalHandlers();
+        try term.updateWinSize();
         return term;
     }
 
     pub fn deinit(self: *Terminal) void {
+        self.events.deinit();
         self.box.deinit();
-        self.cook();
+        self.cook() catch @panic("failed to restore termios");
         self.tty.close();
         self.info.deinit();
     }
 
-    // pub fn poll(self: *Terminal) void {}
+    fn uncook(self: *Terminal) !void {
-
+        self.original_termios = try posix.tcgetattr(self.tty.handle);
-    fn uncook(self: *Terminal) void {
-        _ = os.linux.tcgetattr(self.tty.handle, &self.original_termios);
         var raw = self.original_termios;
 
         raw.lflag.ECHO = false;
         raw.lflag.ICANON = false;
-        raw.lflag.ISIG = false;
+        // raw.lflag.ISIG = false;
+        raw.lflag.ISIG = true;
         raw.lflag.IEXTEN = false;
 
         raw.iflag.IXON = false;
@@ -105,11 +126,76 @@ pub const Terminal = struct {
         raw.cc[@intFromEnum(os.linux.V.TIME)] = 0;
         raw.cc[@intFromEnum(os.linux.V.MIN)] = 1;
 
-        _ = os.linux.tcsetattr(self.tty.handle, .FLUSH, &raw);
+        try posix.tcsetattr(self.tty.handle, .FLUSH, raw);
     }
 
-    fn cook(self: *Terminal) void {
+    fn cook(self: *Terminal) !void {
-        _ = os.linux.tcsetattr(self.tty.handle, .FLUSH, &self.original_termios);
+        try posix.tcsetattr(self.tty.handle, .FLUSH, self.original_termios);
+    }
+
+    fn attachSignalHandlers() !void {
+        var act = posix.Sigaction{
+            .handler = .{ .handler = &S.handlerFn },
+            .mask = posix.empty_sigset,
+            .flags = 0,
+        };
+        // try posix.sigaction(posix.SIG.INT, &act, null);
+        try posix.sigaction(posix.SIG.USR1, &act, null);
+        try posix.sigaction(posix.SIG.USR2, &act, null);
+        try posix.sigaction(posix.SIG.WINCH, &act, null);
+    }
+
+    pub fn getEvents(self: *Terminal) ![]Event {
+        if (S.ev) |ev| {
+            switch (ev) {
+                Event.system => {
+                    switch (ev.system) {
+                        .winch => try self.updateWinSize(),
+                        else => try self.events.append(ev),
+                    }
+                },
+                // else => try self.events.append(ev);
+            }
+            S.ev = null;
+        }
+        return try self.events.toOwnedSlice();
+    }
+
+    const S = struct {
+        var ev: ?Event = null;
+
+        fn handlerFn(sig: i32) callconv(.C) void {
+            switch (sig) {
+                // posix.SIG.INT => ev = Event{ .system = .int },
+                posix.SIG.USR1 => ev = Event{ .system = .usr1 },
+                posix.SIG.USR2 => ev = Event{ .system = .usr2 },
+                posix.SIG.WINCH => ev = Event{ .system = .winch },
+                else => {},
+            }
+        }
+    };
+
+    pub const Event = union(enum) {
+        system: enum {
+            // int,
+            usr1,
+            usr2,
+            winch,
+        },
+    };
+
+    fn updateWinSize(self: *Terminal) !void {
+        var sz: os.linux.winsize = undefined;
+        const ret = os.linux.ioctl(0, os.linux.T.IOCGWINSZ, @intFromPtr(&sz));
+        // std.debug.print("ret: {d}, {any}\r\n", .{ ret, sz });
+        if (ret == 0) {
+            self.box.position = .{
+                .x = 0,
+                .y = 0,
+                .height = @intCast(sz.ws_row),
+                .width = @intCast(sz.ws_col),
+            };
+        } else unreachable; // TODO: handle else case
     }
 
     pub fn draw(self: *Terminal) !void {
@@ -178,29 +264,29 @@ pub const Terminal = struct {
         try self.info.writeString(.clear_screen, self.tty.writer(), &[_]u32{});
     }
 
-    pub const Info = @import("terminfo.zig");
+    // pub fn clearRegion(self: *Terminal, x: u32, y: u32, width: u32, height: u32) !void {
+    //     var row = y;
+    //     var i: u32 = 0;
+    //     while (i < height) {
 
-    pub const SpecialKey = enum(u16) {
+    //         i += 1;
-        home,
+    //         row += 1;
-        end,
+    //     }
-        page_up,
+    // }
-        page_down,
+
-        delete,
+    pub const Info = @import("terminfo.zig");
-        backspace,
-        arrow_left,
-        arrow_right,
-        arrow_up,
-        arrow_down,
-    };
 
     pub const Box = struct {
         parent: ?*Box,
         children: std.ArrayList(*Box),
 
-        // x: u32,
+        position: ?struct {
-        // y: u32,
+            x: u32,
-        // width: u32,
+            y: u32,
-        // height: u32,
+            width: u32,
+            height: u32,
+        } = null,
+        dirty: bool = true,
 
         left: u32,
         right: u32,
@@ -213,16 +299,15 @@ pub const Terminal = struct {
         border_fg: i16 = -1,
 
         content: []const u8 = "",
-        border: bool = false,
 
         pub fn init(allocator: mem.Allocator) Box {
             return .{
                 .parent = null,
                 .children = std.ArrayList(*Box).init(allocator),
-                .x = 0,
+                .left = 2,
-                .y = 0,
+                .right = 2,
-                .width = 20,
+                .top = 1,
-                .height = 8,
+                .bottom = 1,
             };
         }
 
@@ -231,79 +316,95 @@ pub const Terminal = struct {
             self.children.deinit();
         }
 
-        pub fn draw(self: *Box, term: *Terminal) !void {
-            var x: u32 = 0;
-            var y: u32 = 0;
-            try term.cursorSet(self.x, self.y);
-
-            switch (self.border_type) {
-                .line => {
-                    try term.print("", .{});
-                    while (x < self.width) : (x += 1) try term.print("", .{});
-                    try term.print("", .{});
-
-                    y += 1;
-                    while (y <= self.height) : (y += 1) {
-                        try term.cursorSet(self.x, self.y + y);
-                        try term.print("", .{});
-                        try term.cursorSet(self.x + self.width + 1, self.y + y);
-                        try term.print("", .{});
-                    }
-
-                    try term.cursorSet(self.x, self.y + y);
-                },
-                .bg => {},
-            }
-
-            // if (self.border) {
-            //     try term.print("┌", .{});
-            //     // x += 1;
-            //     while (x < self.width) : (x += 1) try term.print("─", .{});
-            //     try term.print("┐", .{});
-            //     // x += 1;
-            //     y += 1;
-            //     while (y <= self.height) : (y += 1) {
-            //         try term.cursorSet(self.x, self.y + y);
-            //         try term.print("│", .{});
-            //         try term.cursorSet(self.x + self.width + 1, self.y + y);
-            //         try term.print("│", .{});
-            //     }
-            //     x = 0;
-            //     try term.cursorSet(self.x + x, self.y + y);
-            //     try term.print("└", .{});
-            //     while (x < self.width) : (x += 1) try term.print("─", .{});
-            //     try term.print("┘", .{});
-            // }
-
-            // x = self.x + 2;
-            // y = self.y + 1;
-            // try term.cursorSet(x, y);
-            // if (self.content.len < self.width) {
-            //     try term.print("{s}", .{self.content});
-            //     x += @intCast(self.content.len);
-            // } else {
-            //     const space = mem.indexOfScalar(u8, self.content, ' ');
-            //     if (space) |sp| {
-            //         try term.print("{s}", .{self.content[0..sp]});
-            //         y += 1;
-            //         try term.cursorSet(x, y);
-            //         try term.print("{s}", .{self.content[sp + 1 ..]});
-            //     }
-            // }
-
-            for (self.children.items) |child| try child.draw(term);
-
-            try term.cursorSet(self.x + self.width + 2, self.y + self.height + 1);
-        }
-
         pub fn addChild(self: *Box, child: *Box) !void {
             std.debug.assert(child.parent == null);
             child.parent = self;
-            child.x = self.x + 2;
+
-            child.y = self.y + 2;
+            std.debug.assert(self.position != null);
-            child.width = self.width - 4;
+            child.position = if (self.border_type == .line) .{
-            child.height = self.height - 4;
+                .x = self.position.?.x + child.left,
+                .y = self.position.?.y + child.top,
+                .width = self.position.?.width - child.right - child.left,
+                .height = self.position.?.height - 2,
+            } else .{
+                .x = self.position.?.x + child.left,
+                .y = self.position.?.y + child.top,
+                .width = self.position.?.width,
+                .height = self.position.?.height,
+            };
+
             try self.children.append(child);
         }
+
+        pub fn removeChild(self: *Box, child: *Box) !void {
+            _ = self;
+            _ = child;
+        }
+
+        pub fn removeChildByIndex(self: *Box, child: usize) !void {
+            _ = self;
+            _ = child;
+        }
+
+        pub fn moveChild(self: *Box, child: *Box, idx: usize) !void {
+            _ = self;
+            _ = child;
+            _ = idx;
+        }
+
+        pub fn moveChildByIndex(self: *Box, child: usize, idx: usize) !void {
+            _ = self;
+            _ = child;
+            _ = idx;
+        }
+
+        pub fn draw(self: *Box, term: *Terminal) !void {
+            if (self.dirty) {
+                const rect = self.getRect();
+                switch (self.border_type) {
+                    .line => {
+                        var x = rect.x;
+                        var y = rect.y;
+                        try term.cursorSet(x, y);
+                        try term.print("┌", .{});
+                        while (x < rect.x + rect.w - 2) : (x += 1) try term.print("─", .{});
+                        try term.print("┐", .{});
+                        y += 1;
+                        while (y < rect.h - 1) : (y += 1) {
+                            try term.cursorSet(rect.x, rect.y + y);
+                            try term.print("│", .{});
+                            try term.cursorSet(rect.x + rect.w + 1, rect.y + y);
+                            try term.print("│", .{});
+                        }
+                        x = rect.x;
+                        try term.cursorSet(rect.x, rect.h);
+                        try term.print("└", .{});
+                        while (x < rect.x + rect.w - 2) : (x += 1) try term.print("─", .{});
+                        try term.print("┘", .{});
+                    },
+                    .bg => {},
+                }
+                self.dirty = false;
+            }
+            for (self.children.items) |child| try child.draw(term);
+        }
+
+        fn getRect(self: *Box) Rect {
+            if (self.parent) |parent| {
+                if (parent.border_type == .line) return .{
+                    .x = self.position.?.x + 1,
+                    .y = self.position.?.y + 1,
+                    .w = self.position.?.width - 2,
+                    .h = self.position.?.height - 2,
+                };
+            }
+            return .{
+                .x = self.position.?.x,
+                .y = self.position.?.y,
+                .w = self.position.?.width,
+                .h = self.position.?.height,
+            };
+        }
+        const Rect = struct { x: u32, y: u32, w: u32, h: u32 };
     };
 };