+31

src/app.zig

··· 16 16 const Image = @import("./image.zig"); 17 17 const List = @import("./list.zig").List; 18 18 const Notification = @import("./notification.zig"); 19 19 + const Preview = @import("./preview.zig"); 19 20 20 21 const config = &@import("./config.zig").config; 21 22 const help_menu_items = [_][]const u8{ ··· 113 114 yanked: ?struct { dir: []const u8, entry: std.fs.Dir.Entry } = null, 114 115 last_known_height: usize, 115 116 117 117 + // Used to detect whether to re-render an image. 118 118 + current_item_path_buf: [std.fs.max_path_bytes]u8 = undefined, 119 119 + current_item_path: []u8 = "", 120 120 + last_item_path_buf: [std.fs.max_path_bytes]u8 = undefined, 121 121 + last_item_path: []u8 = "", 122 122 + 116 123 images: Image.Cache, 124 124 + preview_cache: Preview.PreviewCache, 117 125 118 126 pub fn init(alloc: std.mem.Allocator, entry_dir: ?[]const u8) !App { 119 127 var vx = try vaxis.init(alloc, .{ ··· 139 147 .actions = CircStack(Action, actions_len).init(), 140 148 .last_known_height = vx.window().height, 141 149 .images = .{ .cache = .init(alloc) }, 150 150 + .preview_cache = Preview.PreviewCache.init(alloc), 142 151 }; 143 152 app.tty = try vaxis.Tty.init(&app.tty_buffer); 144 153 app.loop = vaxis.Loop(Event){ ··· 184 193 img.value_ptr.deinit(self.alloc, self.vx, &self.tty); 185 194 } 186 195 self.images.cache.deinit(); 196 196 + self.preview_cache.deinit(); 187 197 } 188 198 189 199 /// Reads the current text input without consuming it. ··· 227 237 while (!self.should_quit) { 228 238 self.loop.pollEvent(); 229 239 while (self.loop.tryEvent()) |event| { 240 240 + if (self.directories.getSelected()) |entry| err: { 241 241 + @memcpy(&self.last_item_path_buf, &self.current_item_path_buf); 242 242 + self.last_item_path = self.last_item_path_buf[0..self.current_item_path.len]; 243 243 + self.current_item_path = try std.fmt.bufPrint( 244 244 + &self.current_item_path_buf, 245 245 + "{s}/{s}", 246 246 + .{ self.directories.fullPath(".") catch { 247 247 + const message = try std.fmt.allocPrint(self.alloc, "Can not display file - unable to retrieve directory path.", .{}); 248 248 + defer self.alloc.free(message); 249 249 + self.notification.write(message, .err) catch {}; 250 250 + if (self.file_logger) |file_logger| file_logger.write(message, .err) catch {}; 251 251 + break :err; 252 252 + }, entry.?.name }, 253 253 + ); 254 254 + } else |err| { 255 255 + const message = try std.fmt.allocPrint(self.alloc, "Can not display file - {}", .{err}); 256 256 + defer self.alloc.free(message); 257 257 + self.notification.write(message, .err) catch {}; 258 258 + if (self.file_logger) |file_logger| file_logger.write(message, .err) catch {}; 259 259 + } 260 260 + 230 261 // Global keybinds. 231 262 try EventHandlers.handleGlobalEvent(self, event); 232 263

+5 -1

src/directories.zig

··· 14 14 alloc: std.mem.Allocator, 15 15 dir: std.fs.Dir, 16 16 path_buf: [std.fs.max_path_bytes]u8 = undefined, 17 17 - file_contents: [4096]u8 = undefined, 17 17 + file: struct { 18 18 + handle: ?std.fs.File = null, 19 19 + data: [4096]u8 = undefined, 20 20 + bytes_read: usize = 0, 21 21 + } = .{}, 18 22 pdf_contents: ?[]u8 = null, 19 23 entries: List(std.fs.Dir.Entry), 20 24 history: CircStack(usize, history_len),

+29 -91

src/drawer.zig

··· 19 19 const top_div: u16 = 1; 20 20 const info_div: u16 = 1; 21 21 22 22 - // Used to detect whether to re-render an image. 23 23 - current_item_path_buf: [std.fs.max_path_bytes]u8 = undefined, 24 24 - current_item_path: []u8 = "", 25 25 - last_item_path_buf: [std.fs.max_path_bytes]u8 = undefined, 26 26 - last_item_path: []u8 = "", 27 22 file_info_buf: [std.fs.max_path_bytes]u8 = undefined, 28 23 file_name_buf: [std.fs.max_path_bytes + 2]u8 = undefined, // +2 to accomodate for [<file_name>] 29 24 git_branch: [1024]u8 = undefined, ··· 64 59 65 60 if (config.preview_file) { 66 61 const file_name_bar = try self.drawFileName(&app.directories, win); 67 67 - try self.drawFilePreview(app, win, file_name_bar); 62 62 + try drawFilePreview(app, win, file_name_bar); 68 63 } 69 64 70 65 const input = app.readInput(); ··· 98 93 } 99 94 100 95 fn drawFilePreview( 101 101 - self: *Drawer, 102 96 app: *App, 103 97 win: vaxis.Window, 104 98 file_name_win: vaxis.Window, ··· 119 113 if (entry) |e| break :lbl e else return; 120 114 }; 121 115 122 122 - @memcpy(&self.last_item_path_buf, &self.current_item_path_buf); 123 123 - self.last_item_path = self.last_item_path_buf[0..self.current_item_path.len]; 124 124 - self.current_item_path = try std.fmt.bufPrint( 125 125 - &self.current_item_path_buf, 126 126 - "{s}/{s}", 127 127 - .{ app.directories.fullPath(".") catch { 128 128 - const message = try std.fmt.allocPrint(app.alloc, "Can not display file - unable to retrieve directory path.", .{}); 129 129 - defer app.alloc.free(message); 130 130 - app.notification.write(message, .err) catch {}; 131 131 - if (app.file_logger) |file_logger| file_logger.write(message, .err) catch {}; 132 132 - 133 133 - _ = preview_win.print(&.{ 134 134 - .{ .text = "Can not display file - unable to retrieve directory path. No preview available." }, 135 135 - }, .{}); 136 136 - return; 137 137 - }, entry.name }, 138 138 - ); 139 139 - 140 116 switch (entry.kind) { 141 117 .directory => { 142 142 - app.directories.clearChildEntries(); 143 143 - app.directories.populateChildEntries(entry.name) catch |err| { 144 144 - const message = try std.fmt.allocPrint(app.alloc, "Failed to populate child directory entries - {}.", .{err}); 145 145 - defer app.alloc.free(message); 146 146 - app.notification.write(message, .err) catch {}; 147 147 - if (app.file_logger) |file_logger| file_logger.write(message, .err) catch {}; 148 148 - 149 149 - _ = preview_win.print(&.{ 150 150 - .{ .text = "Failed to populate child directory entries. No preview available." }, 151 151 - }, .{}); 152 152 - 153 153 - return; 154 154 - }; 155 155 - 156 118 for (app.directories.child_entries.all(), 0..) |item, i| { 157 119 if (std.mem.startsWith(u8, item, ".") and config.show_hidden == false) { 158 120 continue; ··· 164 126 } 165 127 }, 166 128 .file => file: { 167 167 - var file = app.directories.dir.openFile( 168 168 - entry.name, 169 169 - .{ .mode = .read_only }, 170 170 - ) catch |err| { 171 171 - const message = try std.fmt.allocPrint(app.alloc, "Failed to open file - {}.", .{err}); 172 172 - defer app.alloc.free(message); 173 173 - app.notification.write(message, .err) catch {}; 174 174 - if (app.file_logger) |file_logger| file_logger.write(message, .err) catch {}; 175 175 - 176 176 - _ = preview_win.print(&.{ 177 177 - .{ .text = "Failed to open file. No preview available." }, 178 178 - }, .{}); 179 179 - 180 180 - break :file; 181 181 - }; 182 182 - defer file.close(); 183 183 - const bytes = file.readAll(&app.directories.file_contents) catch |err| { 184 184 - const message = try std.fmt.allocPrint(app.alloc, "Failed to read file contents - {}.", .{err}); 185 185 - defer app.alloc.free(message); 186 186 - app.notification.write(message, .err) catch {}; 187 187 - if (app.file_logger) |file_logger| file_logger.write(message, .err) catch {}; 188 188 - 189 189 - _ = preview_win.print(&.{ 190 190 - .{ .text = "Failed to read file contents. No preview available." }, 191 191 - }, .{}); 192 192 - 193 193 - break :file; 194 194 - }; 195 195 - 196 129 // Handle image. 197 130 if (config.show_images == true) unsupported: { 198 131 var match = false; ··· 205 138 app.images.mutex.lock(); 206 139 defer app.images.mutex.unlock(); 207 140 208 208 - if (app.images.cache.getPtr(self.current_item_path)) |cache_entry| { 141 141 + if (app.images.cache.getPtr(app.current_item_path)) |cache_entry| { 209 142 if (cache_entry.status == .processing) { 210 143 _ = preview_win.print(&.{ 211 144 .{ .text = "Image still processing." }, ··· 235 168 }; 236 169 } else { 237 170 if (cache_entry.data == null) { 238 238 - const path = try app.alloc.dupe(u8, self.current_item_path); 171 171 + const path = try app.alloc.dupe(u8, app.current_item_path); 239 172 Image.processImage(app.alloc, app, path) catch { 240 173 app.alloc.free(path); 241 174 break :unsupported; ··· 275 208 .{ .text = "Processing image." }, 276 209 }, .{}); 277 210 278 278 - const path = try app.alloc.dupe(u8, self.current_item_path); 211 211 + const path = try app.alloc.dupe(u8, app.current_item_path); 279 212 Image.processImage(app.alloc, app, path) catch { 280 213 app.alloc.free(path); 281 214 break :unsupported; ··· 295 228 "0", 296 229 "-l", 297 230 "5", 298 298 - self.current_item_path, 231 231 + app.current_item_path, 299 232 "-", 300 233 }, 301 234 .cwd_dir = app.directories.dir, ··· 331 264 app.archive_files = null; 332 265 } 333 266 334 334 - app.archive_files = Archive.listArchiveContents( 335 335 - app.alloc, 336 336 - file, 337 337 - archive_type, 338 338 - config.archive_traversal_limit, 339 339 - ) catch |err| { 340 340 - const message = try std.fmt.allocPrint(app.alloc, "Failed to read archive: {s}", .{@errorName(err)}); 341 341 - defer app.alloc.free(message); 342 342 - app.notification.write(message, .err) catch {}; 343 343 - if (app.file_logger) |file_logger| file_logger.write(message, .err) catch {}; 344 344 - _ = preview_win.print(&.{.{ .text = "Failed to read archive." }}, .{}); 345 345 - break :file; 346 346 - }; 267 267 + if (app.directories.file.handle) |file| { 268 268 + app.archive_files = Archive.listArchiveContents( 269 269 + app.alloc, 270 270 + file, 271 271 + archive_type, 272 272 + config.archive_traversal_limit, 273 273 + ) catch |err| { 274 274 + const message = try std.fmt.allocPrint(app.alloc, "Failed to read archive: {s}", .{@errorName(err)}); 275 275 + defer app.alloc.free(message); 276 276 + app.notification.write(message, .err) catch {}; 277 277 + if (app.file_logger) |file_logger| file_logger.write(message, .err) catch {}; 278 278 + _ = preview_win.print(&.{.{ .text = "Failed to read archive." }}, .{}); 279 279 + break :file; 280 280 + }; 281 281 + } 347 282 348 283 if (config.sort_dirs) { 349 284 std.mem.sort([]const u8, app.archive_files.?.entries.items, {}, sort.string); ··· 359 294 } 360 295 361 296 // Handle utf-8. 362 362 - if (std.unicode.utf8ValidateSlice(app.directories.file_contents[0..bytes])) { 363 363 - _ = preview_win.print(&.{ 364 364 - .{ .text = app.directories.file_contents[0..bytes] }, 365 365 - }, .{}); 366 366 - break :file; 297 297 + if (app.directories.file.bytes_read > 0) { 298 298 + const file_contents = app.directories.file.data[0..app.directories.file.bytes_read]; 299 299 + if (std.unicode.utf8ValidateSlice(file_contents)) { 300 300 + _ = preview_win.print(&.{ 301 301 + .{ .text = file_contents }, 302 302 + }, .{}); 303 303 + break :file; 304 304 + } 367 305 } 368 306 369 307 // Fallback to no preview. ··· 371 309 }, 372 310 else => { 373 311 _ = preview_win.print(&.{ 374 374 - vaxis.Segment{ .text = self.current_item_path }, 312 312 + vaxis.Segment{ .text = app.current_item_path }, 375 313 }, .{}); 376 314 }, 377 315 }

+57 -2

src/event_handlers.zig

··· 11 11 const events = @import("./events.zig"); 12 12 13 13 const config = &@import("./config.zig").config; 14 14 + 14 15 pub fn handleGlobalEvent( 15 16 app: *App, 16 17 event: App.Event, ··· 128 129 switch (key.codepoint) { 129 130 '-', 'h', Key.left => try events.traverseLeft(app), 130 131 Key.enter, 'l', Key.right => try events.traverseRight(app), 131 131 - 'j', Key.down => app.directories.entries.next(), 132 132 - 'k', Key.up => app.directories.entries.previous(), 132 132 + 'j', 'k', Key.down, Key.up => { 133 133 + switch (key.codepoint) { 134 134 + 'j', Key.down => app.directories.entries.next(), 135 135 + 'k', Key.up => app.directories.entries.previous(), 136 136 + else => {}, 137 137 + } 138 138 + 139 139 + if (app.directories.entries.len() == 0 or !config.preview_file) return; 140 140 + const entry = (app.directories.getSelected() catch |err| { 141 141 + const message = try std.fmt.allocPrint(app.alloc, "Failed to read directory entries - {}.", .{err}); 142 142 + defer app.alloc.free(message); 143 143 + app.notification.write(message, .err) catch {}; 144 144 + if (app.file_logger) |file_logger| file_logger.write(message, .err) catch {}; 145 145 + return; 146 146 + }) orelse return; 147 147 + 148 148 + switch (entry.kind) { 149 149 + .directory => { 150 150 + app.directories.clearChildEntries(); 151 151 + app.directories.populateChildEntries(entry.name) catch |err| { 152 152 + const message = try std.fmt.allocPrint(app.alloc, "Failed to read directory entries - {}.", .{err}); 153 153 + defer app.alloc.free(message); 154 154 + app.notification.write(message, .err) catch {}; 155 155 + if (app.file_logger) |file_logger| file_logger.write(message, .err) catch {}; 156 156 + }; 157 157 + }, 158 158 + .file => { 159 159 + if (!std.mem.eql(u8, app.last_item_path, app.current_item_path)) { 160 160 + if (app.directories.file.handle) |*previous_file| { 161 161 + previous_file.close(); 162 162 + } 163 163 + 164 164 + var file = app.directories.dir.openFile( 165 165 + entry.name, 166 166 + .{ .mode = .read_only }, 167 167 + ) catch |err| { 168 168 + const message = try std.fmt.allocPrint(app.alloc, "Failed to open file - {}.", .{err}); 169 169 + defer app.alloc.free(message); 170 170 + app.notification.write("Failed to open file. No preview available.", .err) catch {}; 171 171 + if (app.file_logger) |file_logger| file_logger.write(message, .err) catch {}; 172 172 + return; 173 173 + }; 174 174 + const bytes = file.readAll(&app.directories.file.data) catch |err| { 175 175 + const message = try std.fmt.allocPrint(app.alloc, "Failed to read file contents - {}.", .{err}); 176 176 + defer app.alloc.free(message); 177 177 + app.notification.write("Failed to read file contents. No preview available.", .err) catch {}; 178 178 + if (app.file_logger) |file_logger| file_logger.write(message, .err) catch {}; 179 179 + return; 180 180 + }; 181 181 + app.directories.file.handle = file; 182 182 + app.directories.file.bytes_read = bytes; 183 183 + } 184 184 + }, 185 185 + else => {}, 186 186 + } 187 187 + }, 133 188 'u' => try events.undo(app), 134 189 else => {}, 135 190 }

+3 -3

src/notification.zig

··· 30 30 self.timer = std.time.timestamp(); 31 31 self.style = style; 32 32 33 33 - if (self.loop) |loop| { 34 34 - loop.postEvent(.notification); 35 35 - } 33 33 + // if (self.loop) |loop| { 34 34 + // loop.postEvent(.notification); 35 35 + // } 36 36 } 37 37 38 38 pub fn reset(self: *Self) void {

+92

src/preview.zig

··· 1 1 + const std = @import("std"); 2 2 + 3 3 + pub const PreviewType = enum { 4 4 + none, 5 5 + text, 6 6 + image, 7 7 + pdf, 8 8 + archive, 9 9 + directory, 10 10 + }; 11 11 + 12 12 + pub const PreviewData = union(PreviewType) { 13 13 + none: void, 14 14 + text: []const u8, 15 15 + image: ImageInfo, 16 16 + pdf: []const u8, 17 17 + archive: std.ArrayList([]const u8), 18 18 + directory: std.ArrayList([]const u8), 19 19 + }; 20 20 + 21 21 + pub const ImageInfo = struct { 22 22 + cache_path: []const u8, 23 23 + }; 24 24 + 25 25 + pub const CacheEntry = struct { 26 26 + file_path: []const u8, 27 27 + preview: PreviewData, 28 28 + is_valid: bool, 29 29 + 30 30 + pub fn deinit(self: *CacheEntry, alloc: std.mem.Allocator) void { 31 31 + alloc.free(self.file_path); 32 32 + switch (self.preview) { 33 33 + .text, .pdf => |data| alloc.free(data), 34 34 + .archive, .directory => |*list| { 35 35 + for (list.items) |item| alloc.free(item); 36 36 + list.deinit(alloc); 37 37 + }, 38 38 + .image => |img| alloc.free(img.cache_path), 39 39 + .none => {}, 40 40 + } 41 41 + } 42 42 + }; 43 43 + 44 44 + pub const PreviewCache = struct { 45 45 + alloc: std.mem.Allocator, 46 46 + current: ?CacheEntry, 47 47 + 48 48 + pub fn init(alloc: std.mem.Allocator) PreviewCache { 49 49 + return .{ 50 50 + .alloc = alloc, 51 51 + .current = null, 52 52 + }; 53 53 + } 54 54 + 55 55 + pub fn deinit(self: *PreviewCache) void { 56 56 + if (self.current) |*entry| { 57 57 + entry.deinit(self.alloc); 58 58 + } 59 59 + } 60 60 + 61 61 + pub fn invalidate(self: *PreviewCache) void { 62 62 + if (self.current) |*entry| { 63 63 + entry.is_valid = false; 64 64 + } 65 65 + } 66 66 + 67 67 + pub fn clear(self: *PreviewCache) void { 68 68 + if (self.current) |*entry| { 69 69 + entry.deinit(self.alloc); 70 70 + } 71 71 + self.current = null; 72 72 + } 73 73 + 74 74 + pub fn get(self: *PreviewCache, path: []const u8) ?*const PreviewData { 75 75 + if (self.current) |*entry| { 76 76 + if (entry.is_valid and std.mem.eql(u8, entry.file_path, path)) { 77 77 + return &entry.preview; 78 78 + } 79 79 + } 80 80 + return null; 81 81 + } 82 82 + 83 83 + pub fn set(self: *PreviewCache, path: []const u8, preview: PreviewData) !void { 84 84 + self.clear(); 85 85 + 86 86 + self.current = .{ 87 87 + .file_path = try self.alloc.dupe(u8, path), 88 88 + .preview = preview, 89 89 + .is_valid = true, 90 90 + }; 91 91 + } 92 92 + };