684 lines
25 KiB
Zig
684 lines
25 KiB
Zig
//! Tally TUI - interactive calculator interface.
|
|
//!
|
|
//! Split into sub-modules:
|
|
//! - draw.zig: shared drawing primitives and color palette
|
|
//! - tui/programmer.zig: programmer mode layout
|
|
//! - tui/help.zig: help overlay
|
|
|
|
const std = @import("std");
|
|
const vaxis = @import("vaxis");
|
|
const vxfw = vaxis.vxfw;
|
|
const engine = @import("engine");
|
|
const draw = @import("tui/draw.zig");
|
|
const programmer_view = @import("tui/programmer.zig");
|
|
const help_view = @import("tui/help.zig");
|
|
const C = draw.C;
|
|
|
|
const Allocator = std.mem.Allocator;
|
|
|
|
const Mode = enum { standard, programmer };
|
|
|
|
pub const App = struct {
|
|
allocator: Allocator,
|
|
io: std.Io,
|
|
env: engine.evaluator.Environment,
|
|
input: vxfw.TextField,
|
|
history: std.ArrayList(HistoryEntry),
|
|
show_help: bool,
|
|
history_browse_idx: ?usize,
|
|
saved_input: ?[]const u8,
|
|
mode: Mode,
|
|
// Programmer mode state
|
|
prog_value: u128,
|
|
prog_config: engine.types.ProgrammerConfig,
|
|
bit_cursor: u7,
|
|
prog_field: ProgField,
|
|
value_zone_active: bool, // true = cursor in value display, false = in input
|
|
|
|
pub const ProgField = enum {
|
|
bits,
|
|
dec_signed,
|
|
dec_unsigned,
|
|
hex,
|
|
oct,
|
|
bin,
|
|
expression,
|
|
|
|
pub fn next(self: ProgField) ProgField {
|
|
return switch (self) {
|
|
.bits => .dec_signed,
|
|
.dec_signed => .dec_unsigned,
|
|
.dec_unsigned => .hex,
|
|
.hex => .oct,
|
|
.oct => .bin,
|
|
.bin => .expression,
|
|
.expression => .bits,
|
|
};
|
|
}
|
|
|
|
pub fn prev(self: ProgField) ProgField {
|
|
return switch (self) {
|
|
.bits => .expression,
|
|
.dec_signed => .bits,
|
|
.dec_unsigned => .dec_signed,
|
|
.hex => .dec_unsigned,
|
|
.oct => .hex,
|
|
.bin => .oct,
|
|
.expression => .bin,
|
|
};
|
|
}
|
|
|
|
pub fn label(self: ProgField) []const u8 {
|
|
return switch (self) {
|
|
.bits => "BITS",
|
|
.dec_signed => "DEC(s)",
|
|
.dec_unsigned => "DEC(u)",
|
|
.hex => "HEX",
|
|
.oct => "OCT",
|
|
.bin => "BIN",
|
|
.expression => "EXPR",
|
|
};
|
|
}
|
|
};
|
|
|
|
pub const HistoryEntry = struct {
|
|
expr: []const u8,
|
|
result: []const u8,
|
|
is_error: bool,
|
|
/// Optional pre-labeled detail lines (e.g. "hex: 01 F0") for
|
|
/// standard-mode results that used non-decimal literals.
|
|
details: ?[3][]const u8 = null,
|
|
};
|
|
|
|
pub fn init(allocator: Allocator, io: std.Io) App {
|
|
var text_field = vxfw.TextField.init(allocator);
|
|
text_field.style = .{ .fg = C.fg };
|
|
return .{
|
|
.allocator = allocator,
|
|
.io = io,
|
|
.env = engine.evaluator.Environment.init(allocator, .standard),
|
|
.input = text_field,
|
|
.history = .empty,
|
|
.show_help = false,
|
|
.history_browse_idx = null,
|
|
.saved_input = null,
|
|
.mode = .standard,
|
|
.prog_value = 0,
|
|
.prog_config = .{},
|
|
.bit_cursor = 0,
|
|
.prog_field = .bits,
|
|
.value_zone_active = false,
|
|
};
|
|
}
|
|
|
|
pub fn deinit(self: *App) void {
|
|
self.input.deinit();
|
|
self.env.deinit();
|
|
for (self.history.items) |entry| {
|
|
self.allocator.free(entry.expr);
|
|
self.allocator.free(entry.result);
|
|
if (entry.details) |details| {
|
|
for (details) |d| self.allocator.free(d);
|
|
}
|
|
}
|
|
self.history.deinit(self.allocator);
|
|
if (self.saved_input) |s| self.allocator.free(s);
|
|
}
|
|
|
|
pub fn widget(self: *App) vxfw.Widget {
|
|
return .{
|
|
.userdata = self,
|
|
.eventHandler = typeErasedEventHandler,
|
|
.drawFn = typeErasedDrawFn,
|
|
};
|
|
}
|
|
|
|
fn typeErasedEventHandler(ptr: *anyopaque, ctx: *vxfw.EventContext, event: vxfw.Event) anyerror!void {
|
|
const self: *App = @ptrCast(@alignCast(ptr));
|
|
switch (event) {
|
|
.key_press => |key| try self.handleKey(ctx, key),
|
|
.init => ctx.redraw = true,
|
|
else => {},
|
|
}
|
|
}
|
|
|
|
fn handleKey(self: *App, ctx: *vxfw.EventContext, key: vaxis.Key) !void {
|
|
if (key.matches('c', .{ .ctrl = true }) or key.matches('d', .{ .ctrl = true })) {
|
|
ctx.quit = true;
|
|
return;
|
|
}
|
|
|
|
if (self.show_help) {
|
|
self.show_help = false;
|
|
ctx.redraw = true;
|
|
return;
|
|
}
|
|
|
|
if (key.matches('?', .{}) and !self.value_zone_active) {
|
|
self.show_help = true;
|
|
ctx.redraw = true;
|
|
return;
|
|
}
|
|
|
|
// Tab: switch between Standard and Programmer mode
|
|
if (key.matches(vaxis.Key.tab, .{})) {
|
|
self.mode = if (self.mode == .standard) .programmer else .standard;
|
|
self.env.mode = if (self.mode == .standard) .standard else .programmer;
|
|
if (self.mode == .programmer) {
|
|
const ans = self.env.ans;
|
|
if (ans >= 0 and ans == @trunc(ans) and ans < 18446744073709551616.0) {
|
|
self.prog_value = @intFromFloat(ans);
|
|
} else if (ans < 0 and ans == @trunc(ans) and ans >= -9223372036854775808.0) {
|
|
const signed: i128 = @intFromFloat(ans);
|
|
self.prog_value = @bitCast(signed);
|
|
}
|
|
self.prog_value &= self.prog_config.bit_width.mask();
|
|
}
|
|
self.value_zone_active = false;
|
|
ctx.redraw = true;
|
|
return;
|
|
}
|
|
|
|
// Backtick: toggle between input zone and value zone (programmer mode only)
|
|
if (self.mode == .programmer and key.matches('`', .{})) {
|
|
self.value_zone_active = !self.value_zone_active;
|
|
ctx.redraw = true;
|
|
return;
|
|
}
|
|
|
|
// Ctrl-W: cycle bit width (programmer mode)
|
|
if (self.mode == .programmer and key.matches('w', .{ .ctrl = true })) {
|
|
self.prog_config.bit_width = switch (self.prog_config.bit_width) {
|
|
.bits8 => .bits16,
|
|
.bits16 => .bits32,
|
|
.bits32 => .bits64,
|
|
.bits64 => .bits128,
|
|
.bits128 => .bits8,
|
|
};
|
|
// NOTE: prog_value is intentionally NOT masked here. Width is a
|
|
// display lens over the full value, so narrowing then widening
|
|
// restores the hidden upper bits. The display masks to width and
|
|
// a warning is shown while the value does not fit (see
|
|
// drawProgrammerMode). Explicit value edits still commit to width.
|
|
if (self.bit_cursor >= self.prog_config.bit_width.bits()) {
|
|
self.bit_cursor = @intCast(self.prog_config.bit_width.bits() - 1);
|
|
}
|
|
ctx.redraw = true;
|
|
return;
|
|
}
|
|
|
|
// Ctrl-E: toggle display endianness (programmer mode)
|
|
if (self.mode == .programmer and key.matches('e', .{ .ctrl = true })) {
|
|
self.prog_config.display_endian = switch (self.prog_config.display_endian) {
|
|
.little => .big,
|
|
.big => .little,
|
|
};
|
|
ctx.redraw = true;
|
|
return;
|
|
}
|
|
|
|
// VALUE ZONE key handling
|
|
if (self.value_zone_active) {
|
|
self.handleValueZoneKey(key);
|
|
ctx.redraw = true;
|
|
return;
|
|
}
|
|
|
|
// INPUT ZONE below
|
|
|
|
if (key.matches(vaxis.Key.enter, .{})) {
|
|
try self.submitExpression();
|
|
ctx.redraw = true;
|
|
return;
|
|
}
|
|
|
|
if (key.matches('l', .{ .ctrl = true })) {
|
|
for (self.history.items) |entry| {
|
|
self.allocator.free(entry.expr);
|
|
self.allocator.free(entry.result);
|
|
if (entry.details) |details| {
|
|
for (details) |d| self.allocator.free(d);
|
|
}
|
|
}
|
|
self.history.clearRetainingCapacity();
|
|
self.history_browse_idx = null;
|
|
if (self.saved_input) |s| {
|
|
self.allocator.free(s);
|
|
self.saved_input = null;
|
|
}
|
|
ctx.redraw = true;
|
|
return;
|
|
}
|
|
|
|
// Up/Down: history browsing
|
|
if (key.matches(vaxis.Key.up, .{})) {
|
|
if (self.history.items.len == 0) return;
|
|
if (self.history_browse_idx) |idx| {
|
|
if (idx + 1 < self.history.items.len) {
|
|
self.history_browse_idx = idx + 1;
|
|
self.setInputFromHistory(idx + 1);
|
|
}
|
|
} else {
|
|
try self.saveCurrentInput();
|
|
self.history_browse_idx = 0;
|
|
self.setInputFromHistory(0);
|
|
}
|
|
ctx.redraw = true;
|
|
return;
|
|
}
|
|
if (key.matches(vaxis.Key.down, .{})) {
|
|
if (self.history_browse_idx) |idx| {
|
|
if (idx == 0) {
|
|
self.history_browse_idx = null;
|
|
self.restoreSavedInput();
|
|
} else {
|
|
self.history_browse_idx = idx - 1;
|
|
self.setInputFromHistory(idx - 1);
|
|
}
|
|
ctx.redraw = true;
|
|
}
|
|
return;
|
|
}
|
|
|
|
// Pass to text field
|
|
try self.input.handleEvent(ctx, .{ .key_press = key });
|
|
self.history_browse_idx = null;
|
|
ctx.redraw = true;
|
|
}
|
|
|
|
fn handleValueZoneKey(self: *App, key: vaxis.Key) void {
|
|
// Up/Down: move between fields
|
|
if (key.matches(vaxis.Key.up, .{})) {
|
|
if (self.prog_field == .bits) {
|
|
const width = self.prog_config.bit_width.bits();
|
|
const bits_per_row: u8 = if (width > 32) 32 else width;
|
|
if (@as(u8, self.bit_cursor) + bits_per_row < width) {
|
|
self.bit_cursor += @intCast(bits_per_row);
|
|
return;
|
|
}
|
|
}
|
|
self.prog_field = self.prog_field.prev();
|
|
self.alignCursorToField();
|
|
return;
|
|
}
|
|
if (key.matches(vaxis.Key.down, .{})) {
|
|
if (self.prog_field == .bits) {
|
|
const width = self.prog_config.bit_width.bits();
|
|
const bits_per_row: u8 = if (width > 32) 32 else width;
|
|
if (self.bit_cursor >= bits_per_row) {
|
|
self.bit_cursor -= @intCast(bits_per_row);
|
|
return;
|
|
}
|
|
}
|
|
self.prog_field = self.prog_field.next();
|
|
self.alignCursorToField();
|
|
return;
|
|
}
|
|
|
|
// Left/Right
|
|
if (key.matches(vaxis.Key.left, .{})) {
|
|
const step = self.fieldBitStep();
|
|
if (step > 0) {
|
|
const width = self.prog_config.bit_width.bits();
|
|
if (@as(u16, self.bit_cursor) + step < width) {
|
|
self.bit_cursor += @intCast(step);
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
if (key.matches(vaxis.Key.right, .{})) {
|
|
const step = self.fieldBitStep();
|
|
if (step > 0) {
|
|
if (self.bit_cursor >= step) {
|
|
self.bit_cursor -= @intCast(step);
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
// Space: toggle bit
|
|
if (key.matches(' ', .{})) {
|
|
if (self.prog_field == .bits) {
|
|
self.prog_value ^= @as(u128, 1) << self.bit_cursor;
|
|
self.prog_value &= self.prog_config.bit_width.mask();
|
|
}
|
|
return;
|
|
}
|
|
|
|
// Typing digits to edit the focused field's value
|
|
const cp = key.codepoint;
|
|
if (cp >= 0x20 and cp < 0x7F) {
|
|
self.handleValueInput(@intCast(cp));
|
|
}
|
|
}
|
|
|
|
fn handleValueInput(self: *App, char: u8) void {
|
|
switch (self.prog_field) {
|
|
.hex => {
|
|
const nibble: ?u4 = if (char >= '0' and char <= '9')
|
|
@intCast(char - '0')
|
|
else if (char >= 'a' and char <= 'f')
|
|
@intCast(char - 'a' + 10)
|
|
else if (char >= 'A' and char <= 'F')
|
|
@intCast(char - 'A' + 10)
|
|
else
|
|
null;
|
|
if (nibble) |n| {
|
|
// Replace the nibble at bit_cursor position
|
|
const shift: u7 = self.bit_cursor & 0x7C; // round down to nibble boundary
|
|
const mask = ~(@as(u128, 0xF) << shift);
|
|
self.prog_value = (self.prog_value & mask) | (@as(u128, n) << shift);
|
|
self.prog_value &= self.prog_config.bit_width.mask();
|
|
// Move cursor right (toward LSB)
|
|
if (shift >= 4) self.bit_cursor -= 4;
|
|
}
|
|
},
|
|
.oct => {
|
|
if (char >= '0' and char <= '7') {
|
|
const digit: u3 = @intCast(char - '0');
|
|
// Replace the octal digit at bit_cursor position
|
|
const shift: u7 = (self.bit_cursor / 3) * 3; // round down to octal boundary
|
|
const mask = ~(@as(u128, 0x7) << shift);
|
|
self.prog_value = (self.prog_value & mask) | (@as(u128, digit) << shift);
|
|
self.prog_value &= self.prog_config.bit_width.mask();
|
|
if (shift >= 3) self.bit_cursor -= 3;
|
|
}
|
|
},
|
|
.bin, .bits => {
|
|
if (char == '0') {
|
|
self.prog_value &= ~(@as(u128, 1) << self.bit_cursor);
|
|
if (self.bit_cursor > 0) self.bit_cursor -= 1;
|
|
} else if (char == '1') {
|
|
self.prog_value |= @as(u128, 1) << self.bit_cursor;
|
|
self.prog_value &= self.prog_config.bit_width.mask();
|
|
if (self.bit_cursor > 0) self.bit_cursor -= 1;
|
|
}
|
|
},
|
|
.dec_unsigned, .dec_signed => {
|
|
if (char >= '0' and char <= '9') {
|
|
// Operate on the in-width portion so hidden upper bits do
|
|
// not corrupt the arithmetic; the edit commits to width.
|
|
const m = self.prog_config.bit_width.mask();
|
|
self.prog_value = (((self.prog_value & m) *% 10) +% (char - '0')) & m;
|
|
}
|
|
},
|
|
.expression => {},
|
|
}
|
|
}
|
|
|
|
/// How many bits the cursor moves per left/right step in the current field.
|
|
fn fieldBitStep(self: *App) u8 {
|
|
return switch (self.prog_field) {
|
|
.bits, .bin => 1,
|
|
.hex => 4,
|
|
.oct => 3,
|
|
else => 0, // dec fields don't have positional cursor
|
|
};
|
|
}
|
|
|
|
/// Snap bit_cursor to the nearest boundary for the current field.
|
|
fn alignCursorToField(self: *App) void {
|
|
const step = self.fieldBitStep();
|
|
if (step > 1) {
|
|
// Round down to nearest boundary
|
|
self.bit_cursor = @intCast((@as(u8, self.bit_cursor) / step) * step);
|
|
}
|
|
}
|
|
|
|
fn submitExpression(self: *App) !void {
|
|
const first = self.input.buf.firstHalf();
|
|
const second = self.input.buf.secondHalf();
|
|
const expr_text = try self.allocator.alloc(u8, first.len + second.len);
|
|
@memcpy(expr_text[0..first.len], first);
|
|
@memcpy(expr_text[first.len..], second);
|
|
|
|
if (expr_text.len == 0) {
|
|
self.allocator.free(expr_text);
|
|
return;
|
|
}
|
|
|
|
if (self.mode == .programmer) {
|
|
try self.submitProgrammer(expr_text);
|
|
} else {
|
|
try self.submitStandard(expr_text);
|
|
}
|
|
|
|
self.input.clearRetainingCapacity();
|
|
self.history_browse_idx = null;
|
|
if (self.saved_input) |s| {
|
|
self.allocator.free(s);
|
|
self.saved_input = null;
|
|
}
|
|
}
|
|
|
|
fn submitStandard(self: *App, expr_text: []const u8) !void {
|
|
const info = engine.evalStringInfo(&self.env, self.allocator, expr_text) catch |err| {
|
|
const msg = try self.allocator.dupe(u8, errorStr(err));
|
|
try self.history.append(self.allocator, .{ .expr = expr_text, .result = msg, .is_error = true });
|
|
return;
|
|
};
|
|
|
|
var fmt_buf: [4096]u8 = undefined;
|
|
const formatted = engine.formatter.formatFloat(&fmt_buf, info.value);
|
|
const result_copy = try self.allocator.dupe(u8, formatted.display);
|
|
|
|
var details: ?[3][]const u8 = null;
|
|
if (info.has_nondecimal_literal and info.value >= 0 and
|
|
info.value == @trunc(info.value) and
|
|
info.value < 340282366920938463463374607431768211456.0)
|
|
{
|
|
const int_val: u128 = @intFromFloat(info.value);
|
|
const bw = engine.types.BitWidth.smallestFor(int_val);
|
|
var hex_buf: [256]u8 = undefined;
|
|
var oct_buf: [256]u8 = undefined;
|
|
var bin_buf: [512]u8 = undefined;
|
|
const hex = engine.formatter.formatHex(&hex_buf, int_val, bw, .big);
|
|
const oct = engine.formatter.formatOctal(&oct_buf, int_val, bw);
|
|
const bin = engine.formatter.formatBinary(&bin_buf, int_val, bw);
|
|
details = .{
|
|
try std.fmt.allocPrint(self.allocator, "hex: {s}", .{hex.display}),
|
|
try std.fmt.allocPrint(self.allocator, "oct: {s}", .{oct.display}),
|
|
try std.fmt.allocPrint(self.allocator, "bin: {s}", .{bin.display}),
|
|
};
|
|
}
|
|
|
|
try self.history.append(self.allocator, .{
|
|
.expr = expr_text,
|
|
.result = result_copy,
|
|
.is_error = false,
|
|
.details = details,
|
|
});
|
|
}
|
|
|
|
fn submitProgrammer(self: *App, expr_text: []const u8) !void {
|
|
const is_error, const display_text = if (engine.evalProgrammerString(self.allocator, expr_text, self.prog_config)) |int| blk: {
|
|
self.prog_value = int.unsignedValue();
|
|
var buf: [256]u8 = undefined;
|
|
const dec = engine.formatter.formatDecimalUnsigned(&buf, int.unsignedValue());
|
|
break :blk .{ false, try self.allocator.dupe(u8, dec.display) };
|
|
} else |err| blk: {
|
|
break :blk .{ true, try self.allocator.dupe(u8, errorStr(err)) };
|
|
};
|
|
|
|
try self.history.append(self.allocator, .{ .expr = expr_text, .result = display_text, .is_error = is_error });
|
|
}
|
|
|
|
fn saveCurrentInput(self: *App) !void {
|
|
if (self.saved_input) |s| self.allocator.free(s);
|
|
const first = self.input.buf.firstHalf();
|
|
const second = self.input.buf.secondHalf();
|
|
const text = try self.allocator.alloc(u8, first.len + second.len);
|
|
@memcpy(text[0..first.len], first);
|
|
@memcpy(text[first.len..], second);
|
|
self.saved_input = text;
|
|
}
|
|
|
|
fn setInputFromHistory(self: *App, browse_idx: usize) void {
|
|
const actual_idx = self.history.items.len - 1 - browse_idx;
|
|
const entry = self.history.items[actual_idx];
|
|
self.input.clearRetainingCapacity();
|
|
self.input.insertSliceAtCursor(entry.expr) catch return;
|
|
}
|
|
|
|
fn restoreSavedInput(self: *App) void {
|
|
self.input.clearRetainingCapacity();
|
|
if (self.saved_input) |s| {
|
|
self.input.insertSliceAtCursor(s) catch return;
|
|
self.allocator.free(s);
|
|
self.saved_input = null;
|
|
}
|
|
}
|
|
|
|
// -- Drawing --
|
|
|
|
fn typeErasedDrawFn(ptr: *anyopaque, ctx: vxfw.DrawContext) Allocator.Error!vxfw.Surface {
|
|
const self: *App = @ptrCast(@alignCast(ptr));
|
|
const width = ctx.max.width orelse 80;
|
|
const height = ctx.max.height orelse 24;
|
|
|
|
var surface = try vxfw.Surface.init(ctx.arena, self.widget(), .{ .width = width, .height = height });
|
|
|
|
if (self.show_help) {
|
|
help_view.drawHelp(&surface, width, height);
|
|
return surface;
|
|
}
|
|
|
|
// Title bar
|
|
draw.fillRow(&surface, 0, ' ', .{ .fg = C.cyan, .bg = C.bg, .bold = true });
|
|
draw.writeStr(&surface, 0, 1, "Tally", .{ .fg = C.cyan, .bg = C.bg, .bold = true });
|
|
|
|
// Mode tabs
|
|
const std_style: vaxis.Style = if (self.mode == .standard)
|
|
.{ .fg = C.bg, .bg = C.green, .bold = true }
|
|
else
|
|
.{ .fg = C.muted, .bg = C.bg };
|
|
const prog_style: vaxis.Style = if (self.mode == .programmer)
|
|
.{ .fg = C.bg, .bg = C.orange, .bold = true }
|
|
else
|
|
.{ .fg = C.muted, .bg = C.bg };
|
|
const tab_col = width -| 26;
|
|
draw.writeStr(&surface, 0, tab_col, " Standard ", std_style);
|
|
draw.writeStr(&surface, 0, tab_col + 10, " Programmer ", prog_style);
|
|
|
|
if (self.mode == .programmer) {
|
|
programmer_view.drawProgrammerMode(self, &surface, width, height);
|
|
} else {
|
|
self.drawStandardMode(&surface, width, height);
|
|
}
|
|
|
|
return surface;
|
|
}
|
|
|
|
fn drawStandardMode(self: *App, surface: *vxfw.Surface, width: u16, height: u16) void {
|
|
_ = width;
|
|
drawHistory(self.history.items, surface, 2, height -| 4);
|
|
draw.fillRow(surface, height -| 3, '-', .{ .fg = C.dim });
|
|
self.drawInput(surface, height -| 2);
|
|
draw.fillRow(surface, height -| 1, ' ', .{ .fg = C.muted, .bg = C.bg });
|
|
draw.writeStr(surface, height -| 1, 1, "?:help | Tab:mode | Enter:eval | Ctrl-L:clear | Ctrl-C:quit", .{ .fg = C.muted, .bg = C.bg });
|
|
}
|
|
|
|
pub fn drawInput(self: *App, surface: *vxfw.Surface, row: u16) void {
|
|
const input_focused = !self.value_zone_active;
|
|
const prompt_style: vaxis.Style = if (input_focused)
|
|
.{ .fg = C.pink, .bold = true }
|
|
else
|
|
.{ .fg = C.dim };
|
|
|
|
draw.writeStr(surface, row, 1, "> ", prompt_style);
|
|
|
|
const first = self.input.buf.firstHalf();
|
|
const second = self.input.buf.secondHalf();
|
|
var col: u16 = 3;
|
|
for (first) |byte| {
|
|
draw.writeChar(surface, row, col, byte, .{ .fg = C.fg });
|
|
col += 1;
|
|
}
|
|
for (second) |byte| {
|
|
draw.writeChar(surface, row, col, byte, .{ .fg = C.fg });
|
|
col += 1;
|
|
}
|
|
|
|
if (input_focused) {
|
|
const cursor_col: u16 = 3 + @as(u16, @intCast(self.input.buf.cursor));
|
|
surface.cursor = .{ .col = cursor_col, .row = row, .shape = .block };
|
|
}
|
|
}
|
|
};
|
|
|
|
pub fn drawHistory(items: []const App.HistoryEntry, surface: *vxfw.Surface, start: u16, end: u16) void {
|
|
if (items.len == 0) return;
|
|
if (end <= start) return;
|
|
const capacity: usize = end - start;
|
|
|
|
const LineKind = enum { expr, result, result_err, detail };
|
|
const Line = struct { text: []const u8, kind: LineKind };
|
|
|
|
// Flatten all entries into a line list (oldest first).
|
|
var lines: [512]Line = undefined;
|
|
var n: usize = 0;
|
|
for (items) |entry| {
|
|
if (n < lines.len) {
|
|
lines[n] = .{ .text = entry.expr, .kind = .expr };
|
|
n += 1;
|
|
}
|
|
if (n < lines.len) {
|
|
lines[n] = .{ .text = entry.result, .kind = if (entry.is_error) .result_err else .result };
|
|
n += 1;
|
|
}
|
|
if (entry.details) |details| {
|
|
for (details) |d| {
|
|
if (n < lines.len) {
|
|
lines[n] = .{ .text = d, .kind = .detail };
|
|
n += 1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Render only the last `capacity` lines (newest anchored at bottom).
|
|
const first_visible = if (n > capacity) n - capacity else 0;
|
|
var row: u16 = start;
|
|
for (lines[first_visible..n]) |line| {
|
|
if (row >= end) break;
|
|
switch (line.kind) {
|
|
.expr => draw.writeStr(surface, row, 2, line.text, .{ .fg = C.muted }),
|
|
.result => {
|
|
draw.writeStr(surface, row, 4, "= ", .{ .fg = C.green, .bold = true });
|
|
draw.writeStr(surface, row, 6, line.text, .{ .fg = C.green, .bold = true });
|
|
},
|
|
.result_err => {
|
|
draw.writeStr(surface, row, 4, "= ", .{ .fg = C.pink });
|
|
draw.writeStr(surface, row, 6, line.text, .{ .fg = C.pink });
|
|
},
|
|
.detail => draw.writeStr(surface, row, 6, line.text, .{ .fg = C.muted }),
|
|
}
|
|
row += 1;
|
|
}
|
|
}
|
|
|
|
fn errorStr(err: engine.CalcError) []const u8 {
|
|
return switch (err) {
|
|
engine.CalcError.DivisionByZero => "error: division by zero",
|
|
engine.CalcError.UnknownFunction => "error: unknown function",
|
|
engine.CalcError.UnknownVariable => "error: unknown variable",
|
|
engine.CalcError.UnmatchedParen => "error: unmatched parenthesis",
|
|
engine.CalcError.UnexpectedToken => "error: unexpected token",
|
|
engine.CalcError.UnexpectedEnd => "error: unexpected end of expression",
|
|
engine.CalcError.InvalidNumber => "error: invalid number",
|
|
engine.CalcError.DomainError => "error: domain error",
|
|
engine.CalcError.Overflow => "error: overflow",
|
|
else => "error: evaluation error",
|
|
};
|
|
}
|
|
|
|
pub fn run(allocator: Allocator, io: std.Io, environ_map: *std.process.Environ.Map) !void {
|
|
var app = App.init(allocator, io);
|
|
defer app.deinit();
|
|
|
|
var vx_buf: [4096]u8 = undefined;
|
|
var vx_app = try vxfw.App.init(io, allocator, environ_map, &vx_buf);
|
|
defer vx_app.deinit();
|
|
|
|
try vx_app.run(app.widget(), .{});
|
|
}
|