218 lines
7.6 KiB
Zig
218 lines
7.6 KiB
Zig
const std = @import("std");
|
|
const Allocator = std.mem.Allocator;
|
|
const nc = @import("notcurses");
|
|
const tp = @import("thespian");
|
|
const tracy = @import("tracy");
|
|
const root = @import("root");
|
|
|
|
const Widget = @import("../Widget.zig");
|
|
const command = @import("../command.zig");
|
|
const tui = @import("../tui.zig");
|
|
|
|
a: Allocator,
|
|
parent: nc.Plane,
|
|
plane: nc.Plane,
|
|
name: []const u8,
|
|
name_buf: [512]u8 = undefined,
|
|
title: []const u8 = "",
|
|
title_buf: [512]u8 = undefined,
|
|
file_type: []const u8,
|
|
file_type_buf: [64]u8 = undefined,
|
|
file_icon: [:0]const u8 = "",
|
|
file_icon_buf: [6]u8 = undefined,
|
|
file_color: u24 = 0,
|
|
line: usize,
|
|
lines: usize,
|
|
column: usize,
|
|
file_exists: bool,
|
|
file_dirty: bool = false,
|
|
detailed: bool = false,
|
|
|
|
const Self = @This();
|
|
|
|
pub fn create(a: Allocator, parent: nc.Plane) !Widget {
|
|
const self: *Self = try a.create(Self);
|
|
self.* = try init(a, parent);
|
|
self.show_cwd();
|
|
return Widget.to(self);
|
|
}
|
|
|
|
fn init(a: Allocator, parent: nc.Plane) !Self {
|
|
var n = try nc.Plane.init(&(Widget.Box{}).opts(@typeName(Self)), parent);
|
|
errdefer n.deinit();
|
|
|
|
return .{
|
|
.a = a,
|
|
.parent = parent,
|
|
.plane = n,
|
|
.name = "",
|
|
.file_type = "",
|
|
.lines = 0,
|
|
.line = 0,
|
|
.column = 0,
|
|
.file_exists = true,
|
|
};
|
|
}
|
|
|
|
pub fn deinit(self: *Self, a: Allocator) void {
|
|
self.plane.deinit();
|
|
a.destroy(self);
|
|
}
|
|
|
|
pub fn render(self: *Self, theme: *const Widget.Theme) bool {
|
|
const frame = tracy.initZone(@src(), .{ .name = @typeName(@This()) ++ " render" });
|
|
defer frame.deinit();
|
|
tui.set_base_style(&self.plane, " ", theme.statusbar);
|
|
self.plane.erase();
|
|
self.plane.home();
|
|
if (tui.current().mini_mode) |_|
|
|
self.render_mini_mode(theme)
|
|
else if (self.detailed)
|
|
self.render_detailed(theme)
|
|
else
|
|
self.render_normal(theme);
|
|
self.render_terminal_title();
|
|
return false;
|
|
}
|
|
|
|
fn render_mini_mode(self: *Self, theme: *const Widget.Theme) void {
|
|
self.plane.off_styles(nc.style.italic);
|
|
const mini_mode = if (tui.current().mini_mode) |m| m else return;
|
|
_ = self.plane.print(" {s}", .{mini_mode.text}) catch {};
|
|
if (mini_mode.cursor) |cursor| {
|
|
const pos: c_int = @intCast(cursor);
|
|
self.plane.cursor_move_yx(0, pos + 1) catch return;
|
|
var cell = self.plane.cell_init();
|
|
_ = self.plane.at_cursor_cell(&cell) catch return;
|
|
tui.set_cell_style(&cell, theme.editor_cursor);
|
|
_ = self.plane.putc(&cell) catch {};
|
|
}
|
|
return;
|
|
}
|
|
|
|
// Content save
|
|
// Content save alert
|
|
// Content save edit
|
|
// Content save settings
|
|
// Content save off
|
|
// Content save check
|
|
// Content save cog
|
|
// Content save all
|
|
fn render_normal(self: *Self, theme: *const Widget.Theme) void {
|
|
self.plane.on_styles(nc.style.italic);
|
|
_ = self.plane.putstr(" ") catch {};
|
|
if (self.file_icon.len > 0) {
|
|
self.render_file_icon(theme);
|
|
_ = self.plane.print(" ", .{}) catch {};
|
|
}
|
|
_ = self.plane.putstr(if (!self.file_exists) " " else if (self.file_dirty) " " else "") catch {};
|
|
_ = self.plane.print("{s}", .{self.name}) catch {};
|
|
return;
|
|
}
|
|
|
|
fn render_detailed(self: *Self, theme: *const Widget.Theme) void {
|
|
self.plane.on_styles(nc.style.italic);
|
|
_ = self.plane.putstr(" ") catch {};
|
|
if (self.file_icon.len > 0) {
|
|
self.render_file_icon(theme);
|
|
_ = self.plane.print(" ", .{}) catch {};
|
|
}
|
|
_ = self.plane.putstr(if (!self.file_exists) "" else if (self.file_dirty) "" else "") catch {};
|
|
_ = self.plane.print(" {s}:{d}:{d}", .{ self.name, self.line + 1, self.column + 1 }) catch {};
|
|
_ = self.plane.print(" of {d} lines", .{self.lines}) catch {};
|
|
if (self.file_type.len > 0)
|
|
_ = self.plane.print(" ({s})", .{self.file_type}) catch {};
|
|
return;
|
|
}
|
|
|
|
fn render_terminal_title(self: *Self) void {
|
|
const file_name = if (std.mem.lastIndexOfScalar(u8, self.name, '/')) |pos|
|
|
self.name[pos + 1 ..]
|
|
else if (self.name.len == 0)
|
|
root.application_name
|
|
else
|
|
self.name;
|
|
var new_title_buf: [512]u8 = undefined;
|
|
const new_title = std.fmt.bufPrint(&new_title_buf, "{s}{s}", .{ if (!self.file_exists) "◌ " else if (self.file_dirty) " " else "", file_name }) catch return;
|
|
if (std.mem.eql(u8, self.title, new_title)) return;
|
|
@memcpy(self.title_buf[0..new_title.len], new_title);
|
|
self.title = self.title_buf[0..new_title.len];
|
|
tui.set_terminal_title(self.title);
|
|
}
|
|
|
|
pub fn receive(self: *Self, _: tp.pid_ref, m: tp.message) error{Exit}!bool {
|
|
var file_path: []const u8 = undefined;
|
|
var file_type: []const u8 = undefined;
|
|
var file_icon: []const u8 = undefined;
|
|
var file_dirty: bool = undefined;
|
|
if (try m.match(.{ "E", "pos", tp.extract(&self.lines), tp.extract(&self.line), tp.extract(&self.column) }))
|
|
return false;
|
|
if (try m.match(.{ "E", "dirty", tp.extract(&file_dirty) })) {
|
|
self.file_dirty = file_dirty;
|
|
} else if (try m.match(.{ "E", "save", tp.extract(&file_path) })) {
|
|
@memcpy(self.name_buf[0..file_path.len], file_path);
|
|
self.name = self.name_buf[0..file_path.len];
|
|
self.file_exists = true;
|
|
self.file_dirty = false;
|
|
self.abbrv_home();
|
|
} else if (try m.match(.{ "E", "open", tp.extract(&file_path), tp.extract(&self.file_exists), tp.extract(&file_type), tp.extract(&file_icon), tp.extract(&self.file_color) })) {
|
|
@memcpy(self.name_buf[0..file_path.len], file_path);
|
|
self.name = self.name_buf[0..file_path.len];
|
|
@memcpy(self.file_type_buf[0..file_type.len], file_type);
|
|
self.file_type = self.file_type_buf[0..file_type.len];
|
|
@memcpy(self.file_icon_buf[0..file_icon.len], file_icon);
|
|
self.file_icon_buf[file_icon.len] = 0;
|
|
self.file_icon = self.file_icon_buf[0..file_icon.len :0];
|
|
self.file_dirty = false;
|
|
self.abbrv_home();
|
|
} else if (try m.match(.{ "E", "close" })) {
|
|
self.name = "";
|
|
self.lines = 0;
|
|
self.line = 0;
|
|
self.column = 0;
|
|
self.file_exists = true;
|
|
self.show_cwd();
|
|
}
|
|
if (try m.match(.{ "B", nc.event_type.PRESS, nc.key.BUTTON1, tp.any, tp.any, tp.any, tp.any, tp.any })) {
|
|
self.detailed = !self.detailed;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
fn render_file_icon(self: *Self, _: *const Widget.Theme) void {
|
|
var cell = self.plane.cell_init();
|
|
_ = self.plane.at_cursor_cell(&cell) catch return;
|
|
if (self.file_color != 0x000001) {
|
|
nc.channels_set_fg_rgb(&cell.channels, self.file_color) catch {};
|
|
nc.channels_set_fg_alpha(&cell.channels, nc.ALPHA_OPAQUE) catch {};
|
|
}
|
|
_ = self.plane.cell_load(&cell, self.file_icon) catch {};
|
|
_ = self.plane.putc(&cell) catch {};
|
|
self.plane.cursor_move_rel(0, 1) catch {};
|
|
}
|
|
|
|
fn show_cwd(self: *Self) void {
|
|
self.file_icon = "";
|
|
self.file_color = 0x000001;
|
|
self.name = std.fs.cwd().realpath(".", &self.name_buf) catch "(none)";
|
|
self.abbrv_home();
|
|
}
|
|
|
|
fn abbrv_home(self: *Self) void {
|
|
if (std.fs.path.isAbsolute(self.name)) {
|
|
if (std.os.getenv("HOME")) |homedir| {
|
|
const homerelpath = std.fs.path.relative(self.a, homedir, self.name) catch return;
|
|
if (homerelpath.len == 0) {
|
|
self.name = "~";
|
|
} else if (homerelpath.len > 3 and std.mem.eql(u8, homerelpath[0..3], "../")) {
|
|
return;
|
|
} else {
|
|
self.name_buf[0] = '~';
|
|
self.name_buf[1] = '/';
|
|
@memcpy(self.name_buf[2 .. homerelpath.len + 2], homerelpath);
|
|
self.name = self.name_buf[0 .. homerelpath.len + 2];
|
|
}
|
|
}
|
|
}
|
|
}
|