HAXY

▄▄▄▄▀▄ ▄▀▀▀▀▀▀▀▀ ▄▄▄▄ ▀▀▀▀▀▄▀▀▀▀▄ ▄▀▀▀▀▀▄ ▀▀▀▀▀▄▄▄▀▀▀ ▄▀▀▀▀▀▀▀▀ ▀▀▀▀▀▀▀▀▀▀▀ ▀▀▀▀▀▀▀▀▀ ▀▀▀▀▀▀▀▀▀▀▀▀ ▀▀▀▀▀▀▀▀▀ ▀▀▀▀▀▀▀▀▄▀▀▀ ▀▀▀▀▀▀▀▀▀ ▀▀▀▀▀▀▀▀▀▀▀▀ ▀▀▀▀▀▀▀▀▀ ▀▀▀▀▀▀▀▀▀▀▄▀▄▄ ▀▀▀▀▀▀▀▀ ▀▀▀▀▀▀▀▀▀▀▀▄▀▀ ▀▀▀▀▀▀ ▀▀▀▀▀▀▄▀▀▀▀▀▀▀▀▄ ▀▀▀▀▀▀ ▀▀▀▀▀▀▀▀▀▀▀▀▄▀▀▀▀▄ ▀▀▀ ▀▀▀▀▀▄▀▀▀▀▀▀▀▀▀▀▀▀▄ ▀▀▀ ▄▀▀▀▀▄▀▀▀▀▀▀▀▀▀▄▄▀▀▀ ▀▀▀ ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▄▀▄▄▄▄▀ ▀▀ ▀▀▀▀▀▀▀▀▀▄▀▀▀▀▀▄▀▀▀▀ ▀ ▀▀▀▀▄▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ ▀▀ ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ ▄▀▀▀▄ ▄▀▀▀▄▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ ▀▀▀▀▀ ▀▀▄▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▄▀▀▀ ▀▀▀▀▀▀▀▄▀▀▄▀▀▀▀▀▀▀▀▀▀▀▀▀▀▄▀▀▀▀▀▀▀▀▄ ▀▀▀▀▀▀▀▀▄▀▀▀▀▀▀▀▀▀▀▄▀▄▀▀▀▀▀▀▀▀▀▀▀▀▀ ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▄▀▀▀▀▀▀▀▄▀▄▄▀▀▄▀▀ ▀▀▀▀▀▀▄▄▀▀▄▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▄▀▀ ▀▀▀▀▀▀▀▀▀▀▀▀▀▄▀▀▀▀▀▀▀▀▀▀▀▀▀▀▄▀▀▀▀▀ ▀▀▀▀▀▀▀▀▄▀▀▀▀▀▀▀▄▄▄▀▀▀▀▄▀▀▀▄▀▀▀▀▀▀ ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▄▀▀▄▀ ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▄▀▀▀▀ ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▄▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▄▀▄ ▀▀▀▀▀▀▀▀ ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▄▀▀▀ ▀▀▀▀▀▀▀ ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ ▀▀▀▀▀▀ ▀▀▀▀▀▀▀▀▀▀▄▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ ▀▀ ▀▀ ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ ▀▀ ▀▀▀▀▀▀▀▀▀▀▀▀▀▄▀▀▄▄▀▀ ▀▀▀▄▀ ▀ ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ ▀▀▀ ▀ ▀▀▀▀▀▀▀▀▀▄▀▀▀▀▀▀▀▀▀▀ ▀ ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ ▀ ▀▀▀▀▀▀▀▀▀▀▀▀▀▄▀▀▀▀▀▀▀ ▀ ▄▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▄▄▀ ▀▄ ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▄▀▀▀▀▀▀ ▀▀ ▀▀▀▀▀▀▀▄▄▄▀▀▀▀▀▀▀▀▀▀▀▀ ▀ ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀

╭ UserNotifications.zig ────────────────────────────────────────╮ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ ╰───────────────────────────────────────────────────────────────╯

╭────╮ ╭ clone ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─╮ │http│ ssh │ │ ╰────╯ ╰ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─╯

.. Fork/ Home/ Repo/ User/ widget/ Fork.zig Home.zig NewRepo.zig NewUser.zig NotFound.zig Quit.zig Repo.zig SubTitle.zig Title.zig Unauthorized.zig User.zig UserKeys.zig UserLogin.zig ╭─────────────────────────────────╮ │UserNotifications.zig │ ╰─────────────────────────────────╯ UserSettings.zig input.zig timestamp.zig widget.zig

1 const std = @import("std"); 2 const evt = @import("../event.zig"); 3 const notify = @import("../notify.zig"); 4 const ui = @import("../ui.zig"); 5 const inp = @import("./input.zig"); 6 const xit = @import("xit"); 7 const xitui = xit.xitui; 8 const wgt = xitui.widget; 9 const layout = xitui.layout; 10 const Key = xitui.input.Key; 11 const Grid = xitui.grid.Grid; 12 const Focus = xitui.focus.Focus; 13 14 pub const page_size = 20; // how many notifs one window shows 15 16 // a notif as the list shows it 17 pub const Row = struct { 18 title: []const u8, 19 // the thread's url 20 url: []const u8, 21 // the thread's repo, as "owner:name" 22 identity: []const u8, 23 unread: bool, 24 }; 25 26 // the logged-in user's notifications window, empty when logged out 27 rows: []const Row, 28 start: usize, // the window start this page was built with, mirrored into the url 29 next_start: ?usize, // the `start` for the "next" row, or null when this is the last window 30 // the sub tab the route names 31 view: ui.RoutablePage.UserView, 32 ssh_keys: ui.UserKeys = .{}, 33 34 const Self = @This(); 35 36 // also refreshes the session's unread count 37 pub fn init(arena: *std.heap.ArenaAllocator, session: *ui.Session, tab: ui.RoutablePage.UserTab) !Self { 38 var result: Self = .{ .rows = &.{}, .start = tab.start, .next_start = null, .view = tab.view }; 39 // zero until read, so a logout leaves no stale count 40 session.data.unread_notifs = 0; 41 // local mode has no users 42 if (session.data.host_kind != .server) return result; 43 const user_id = session.userId() orelse return result; 44 result.ssh_keys = try ui.UserKeys.init(arena, session, &user_id); 45 const io = session.io orelse return error.NoMoment; 46 const users_dir = session.users_dir orelse return error.NoMoment; 47 const gpa = arena.child_allocator; 48 const aa = arena.allocator(); 49 50 var user_repo = (try evt.openUserRepo(io, gpa, users_dir, &user_id)) orelse return result; 51 defer user_repo.deinit(io, gpa); 52 const moment = (try notify.latestMoment(&user_repo)) orelse return result; 53 session.data.unread_notifs = try notify.unreadCount(moment); 54 55 const items = try notify.readRecent(moment, arena, tab.start, page_size + 1); 56 if (items.len > page_size) result.next_start = tab.start + page_size; 57 const rows = try aa.alloc(Row, @min(items.len, page_size)); 58 for (rows, items[0..rows.len]) |*row, item| { 59 const identity = try aa.print("{s}:{s}", .{ item.notif.owner_name, item.notif.repo_name }); 60 const route = ui.RoutablePage.repoThreadCommentsRoute(item.notif.thread_kind, identity, &std.fmt.bytesToHex(item.notif.thread_id, .lower), 0) orelse return error.RouteTooLong; 61 row.* = .{ .title = item.notif.title, .url = try route.toUrl(arena), .identity = identity, .unread = item.unread }; 62 } 63 result.rows = rows; 64 return result; 65 } 66 67 // a first window without notifs, which shows the empty message 68 fn isEmpty(self: *const Self) bool { 69 return self.rows.len == 0 and self.start == 0; 70 } 71 72 // leave the user tab for the page it belongs to, where the web's logout redirect also lands 73 pub fn logOut(session: *ui.Session) !void { 74 session.logOut(); 75 try session.navigate(session.data.current_page.pageRoot()); 76 } 77 78 const repos_label = "view repos"; 79 const logout_label = "logout"; 80 81 // the notifications, user settings and ssh keys sub tabs over their content, with the logout button across from them 82 pub const View = struct { 83 box: wgt.Box(ui.Widget), 84 data: *const Self, 85 session: *ui.Session, 86 // the sub tabs' ids then the repos and logout buttons', in header order 87 control_ids: [5]usize, 88 // the sub tab whose content shows 89 view_index: usize, 90 91 const header_index = 0; 92 const content_index = 1; 93 // the sub tabs come first in `control_ids` 94 const tab_count = 3; 95 const repos_index = 3; 96 const logout_index = 4; 97 98 // `user_route` is the page's user tab route 99 pub fn init(allocator: std.mem.Allocator, data: *const Self, session: *ui.Session, user_route: ui.RoutablePage) !View { 100 var box = try wgt.Box(ui.Widget).init(allocator, .{ .border = null, .direction = .vert }); 101 errdefer box.deinit(allocator); 102 103 var control_ids: [5]usize = undefined; 104 const settings_route = user_route.withUserTab(.{ .view = .settings }); 105 const keys_route = user_route.withUserTab(.{ .view = .keys }); 106 { 107 var header = try wgt.Box(ui.Widget).init(allocator, .{ .border = null, .direction = .horiz }); 108 errdefer header.deinit(allocator); 109 const on_tab = std.meta.activeTag(session.data.current_page) == std.meta.activeTag(user_route); 110 const routes = [_]ui.RoutablePage{ user_route.withUserTab(.{}), settings_route, keys_route }; 111 for ([_]ui.RoutablePage.UserView{ .notifications, .settings, .keys }, [_][]const u8{ "notifications", "user settings", "ssh keys" }, routes, 0..) |view, label, route, index| { 112 var tab = try wgt.TextBox.init(allocator, label, .{ .border = .hidden, .round_corners = true, .wrap_kind = .none }); 113 errdefer tab.deinit(allocator); 114 tab.getFocus().mode = .all; 115 tab.getFocus().kind = .{ .custom = try ui.inPageTabLink(session, route, on_tab and data.view == view) }; 116 control_ids[index] = tab.getFocus().id; 117 try header.children.put(allocator, tab.getFocus().id, .{ .widget = .{ .text_box = tab }, .rect = null, .min_size = .{ .width = label.len + 2, .height = null } }); 118 } 119 // the spacer pushes the buttons to the right edge 120 { 121 var spacer = try ui.widget.Spacer.init(allocator); 122 errdefer spacer.deinit(allocator); 123 try header.children.put(allocator, spacer.getFocus().id, .{ .widget = .{ .spacer = spacer }, .rect = null, .min_size = null }); 124 } 125 { 126 var button = try wgt.TextBox.init(allocator, repos_label, .{ .border = .single, .round_corners = true, .wrap_kind = .none }); 127 errdefer button.deinit(allocator); 128 button.getFocus().mode = .all; 129 button.getFocus().kind = .{ .custom = try ui.userLink(session.page_arena, session.data.user_name orelse unreachable) }; 130 control_ids[repos_index] = button.getFocus().id; 131 try header.children.put(allocator, button.getFocus().id, .{ .widget = .{ .text_box = button }, .rect = null, .min_size = .{ .width = repos_label.len + 2, .height = 3 } }); 132 } 133 { 134 // the form kind makes the web renderer post the button to the logout route 135 header.getFocus().kind = .{ .custom = try session.page_arena.allocator().print("form:{s}/logout", .{try settings_route.toUrl(session.page_arena)}) }; 136 var button = try wgt.TextBox.init(allocator, logout_label, .{ .border = .single, .round_corners = true, .wrap_kind = .none }); 137 errdefer button.deinit(allocator); 138 button.getFocus().mode = .all; 139 button.getFocus().kind = .{ .custom = "submit" }; 140 control_ids[logout_index] = button.getFocus().id; 141 try header.children.put(allocator, button.getFocus().id, .{ .widget = .{ .text_box = button }, .rect = null, .min_size = .{ .width = logout_label.len + 2, .height = 3 } }); 142 } 143 header.getFocus().child_id = control_ids[@backingInt(data.view)]; 144 // a row taller than the button, leaving a blank line beneath it 145 try box.children.put(allocator, header.getFocus().id, .{ .widget = .{ .box = header }, .rect = null, .min_size = .{ .width = null, .height = 4 } }); 146 } 147 148 { 149 var stack = try wgt.Stack(ui.Widget).init(allocator); 150 errdefer stack.deinit(allocator); 151 // an empty first window has no rows, not even paging ones 152 if (data.isEmpty()) { 153 var center = try ui.widget.initEmpty(allocator); 154 errdefer center.deinit(allocator); 155 try stack.children.put(allocator, center.getFocus().id, .{ .center = center }); 156 } else { 157 var list = try ui.widget.FlowBox.Scroll.init(allocator, .{}, !session.is_terminal); 158 errdefer list.deinit(allocator); 159 160 var arena = std.heap.ArenaAllocator.init(allocator); 161 defer arena.deinit(); 162 const aa = arena.allocator(); 163 164 // a leading "previous" row off the first window, one row per 165 // notif, then a trailing "next" row when more remain 166 var items: std.ArrayList(ui.widget.FlowBox.Item) = .empty; 167 if (data.start > 0) { 168 const prev = user_route.withUserTab(.{ .start = data.start -| page_size }); 169 try items.append(aa, .{ .text = "← previous", .link = try aa.print("a:{s}", .{try prev.toUrl(&arena)}) }); 170 } 171 for (data.rows) |row| try items.append(aa, .{ 172 .text = row.title, 173 .link = try aa.print("a:{s}", .{row.url}), 174 .bottom_label = try aa.print("{s} {s}", .{ if (row.unread) "☐" else "☑", row.identity }), 175 .bold = row.unread, 176 }); 177 if (data.next_start) |next_start| { 178 const next = user_route.withUserTab(.{ .start = next_start }); 179 try items.append(aa, .{ .text = "next →", .link = try aa.print("a:{s}", .{try next.toUrl(&arena)}) }); 180 } 181 try list.setItems(allocator, items.items); 182 try stack.children.put(allocator, list.getFocus().id, .{ .flow_box_scroll = list }); 183 } 184 { 185 var settings = try ui.UserSettings.View.init(allocator, session, settings_route); 186 errdefer settings.deinit(allocator); 187 try stack.children.put(allocator, settings.getFocus().id, .{ .user_settings = settings }); 188 } 189 { 190 var keys = try ui.UserKeys.View.init(allocator, &data.ssh_keys, session, keys_route); 191 errdefer keys.deinit(allocator); 192 try stack.children.put(allocator, keys.getFocus().id, .{ .user_keys = keys }); 193 } 194 stack.getFocus().child_id = stack.children.keys()[@backingInt(data.view)]; 195 try box.children.put(allocator, stack.getFocus().id, .{ .widget = .{ .stack = stack }, .rect = null, .min_size = null }); 196 } 197 box.getFocus().child_id = box.children.keys()[content_index]; 198 return .{ .box = box, .data = data, .session = session, .control_ids = control_ids, .view_index = @backingInt(data.view) }; 199 } 200 201 pub fn deinit(self: *View, allocator: std.mem.Allocator) void { 202 self.box.deinit(allocator); 203 } 204 205 fn headerBox(self: *View) *wgt.Box(ui.Widget) { 206 return &self.box.children.values()[header_index].widget.box; 207 } 208 209 fn contentStack(self: *View) *wgt.Stack(ui.Widget) { 210 return &self.box.children.values()[content_index].widget.stack; 211 } 212 213 fn headerActive(self: *View) bool { 214 return self.box.getFocus().child_id == self.headerBox().getFocus().id; 215 } 216 217 pub fn build(self: *View, allocator: std.mem.Allocator, constraint: layout.Constraint, root_focus: *Focus) !void { 218 self.clearGrid(); 219 const header = self.headerBox(); 220 // focusing a sub tab shows its content, while the logout button leaves it 221 if (header.getFocus().child_id) |child_id| if (std.mem.indexOfScalar(usize, self.control_ids[0..tab_count], child_id)) |index| { 222 self.view_index = index; 223 }; 224 for (self.control_ids[0..tab_count], 0..) |id, index| { 225 const tab = header.children.getPtr(id) orelse unreachable; 226 ui.widget.markSelected(&tab.widget.text_box, index == self.view_index); 227 } 228 self.contentStack().getFocus().child_id = self.contentStack().children.keys()[self.view_index]; 229 // clear the incoming min height so the list scrolls within what's left 230 try self.box.build(allocator, .{ 231 .min_size = .{ .width = null, .height = null }, 232 .max_size = constraint.max_size, 233 }, root_focus); 234 } 235 236 pub fn input(self: *View, allocator: std.mem.Allocator, key: Key, root_focus: *Focus) !void { 237 const logout_id = self.control_ids[logout_index]; 238 if (key == .mouse and inp.leftClickOn(root_focus, logout_id, key.mouse)) return logOut(self.session); 239 const direction = inp.vertDirection(key); 240 if (self.headerActive()) { 241 const focused = root_focus.grandchild_id orelse return; 242 if (key == .enter and focused == logout_id) return logOut(self.session); 243 if (direction == .down) { 244 // the empty message has nothing to focus 245 if (self.view_index == @backingInt(ui.RoutablePage.UserView.notifications) and self.data.isEmpty()) return; 246 root_focus.setFocus(self.contentStack().getFocus().id); 247 } else if (std.mem.indexOfScalar(usize, &self.control_ids, focused)) |current| { 248 if (inp.moveTab(key, current, self.control_ids.len)) |next| root_focus.setFocus(self.control_ids[next]); 249 } 250 return; 251 } 252 if (direction == .up) if (self.contentStack().getSelected()) |selected| if (selected.atTop(root_focus)) { 253 root_focus.setFocus(self.control_ids[self.view_index]); 254 return; 255 }; 256 try self.contentStack().input(allocator, key, root_focus); 257 } 258 259 // moving up from the sub header returns to the page's tabs 260 pub fn atTop(self: *View) bool { 261 return self.headerActive(); 262 } 263 264 // arriving from the page's tabs lands on the sub header, not the content 265 pub fn focusHeader(self: *View, root_focus: *Focus) bool { 266 root_focus.setFocus(self.control_ids[self.view_index]); 267 return true; 268 } 269 270 pub fn clearGrid(self: *View) void { 271 self.box.clearGrid(); 272 } 273 274 pub fn getGrid(self: View) ?Grid { 275 return self.box.getGrid(); 276 } 277 278 pub fn getFocus(self: *View) *Focus { 279 return self.box.getFocus(); 280 } 281 }; 282