Yves Biener
f775a6ab2d
Some checks failed
Zig Project Action / Lint, Spell-check and test zig project (push) Failing after 13s
441 lines
23 KiB
Zig
441 lines
23 KiB
Zig
//! Application type for TUI-applications
|
|
|
|
/// Create the App Type with the associated user events _E_ which describes
|
|
/// an tagged union for all the user events that can be send through the
|
|
/// applications event loop.
|
|
///
|
|
/// # Example
|
|
///
|
|
/// Create an `App` which renders using the `PlainRenderer` in fullscreen with
|
|
/// an empty user Event:
|
|
///
|
|
/// ```zig
|
|
/// const zterm = @import("zterm");
|
|
/// const App = zterm.App(
|
|
/// union(enum) {},
|
|
/// );
|
|
/// // later on create an `App` instance and start the event loop
|
|
/// var app: App = .init;
|
|
/// try app.start();
|
|
/// defer app.stop() catch unreachable;
|
|
/// ```
|
|
pub fn App(comptime E: type) type {
|
|
if (!isTaggedUnion(E)) {
|
|
@compileError("Provided user event `E` for `App(comptime E: type)` is not of type `union(enum)`.");
|
|
}
|
|
return struct {
|
|
queue: Queue,
|
|
thread: ?Thread = null,
|
|
quit_event: Thread.ResetEvent,
|
|
termios: ?posix.termios = null,
|
|
winch_registered: bool = false,
|
|
|
|
// global variable for the registered handler for WINCH
|
|
var handler_ctx: *anyopaque = undefined;
|
|
/// registered WINCH handler to report resize events
|
|
fn handleWinch(_: c_int) callconv(.C) void {
|
|
const this: *@This() = @ptrCast(@alignCast(handler_ctx));
|
|
// NOTE this does not have to be done if in-band resize events are supported
|
|
// -> the signal might not work correctly when hosting the application over ssh!
|
|
this.postEvent(.resize);
|
|
}
|
|
|
|
pub const init: @This() = .{
|
|
.queue = .{},
|
|
.quit_event = .{},
|
|
};
|
|
|
|
pub fn start(this: *@This()) !void {
|
|
if (this.thread) |_| return;
|
|
|
|
// post init event (as the very first element to be in the queue - event loop)
|
|
this.postEvent(.init);
|
|
|
|
if (!this.winch_registered) {
|
|
handler_ctx = this;
|
|
var act = posix.Sigaction{
|
|
.handler = .{ .handler = handleWinch },
|
|
.mask = posix.sigemptyset(),
|
|
.flags = 0,
|
|
};
|
|
posix.sigaction(posix.SIG.WINCH, &act, null);
|
|
this.winch_registered = true;
|
|
}
|
|
|
|
this.quit_event.reset();
|
|
this.thread = try Thread.spawn(.{}, @This().run, .{this});
|
|
|
|
var termios: posix.termios = undefined;
|
|
try terminal.enableRawMode(&termios);
|
|
if (this.termios) |_| {} else this.termios = termios;
|
|
|
|
try terminal.saveScreen();
|
|
try terminal.enterAltScreen();
|
|
try terminal.hideCursor();
|
|
try terminal.enableMouseSupport();
|
|
}
|
|
|
|
pub fn interrupt(this: *@This()) !void {
|
|
this.quit_event.set();
|
|
try terminal.disableMouseSupport();
|
|
try terminal.exitAltScreen();
|
|
try terminal.restoreScreen();
|
|
if (this.thread) |thread| {
|
|
thread.join();
|
|
this.thread = null;
|
|
}
|
|
}
|
|
|
|
pub fn stop(this: *@This()) !void {
|
|
try this.interrupt();
|
|
if (this.termios) |*termios| {
|
|
try terminal.disableMouseSupport();
|
|
try terminal.showCursor();
|
|
try terminal.exitAltScreen();
|
|
try terminal.disableRawMode(termios);
|
|
try terminal.restoreScreen();
|
|
}
|
|
this.termios = null;
|
|
}
|
|
|
|
/// Quit the application loop.
|
|
/// This will stop the internal input thread and post a **.quit** `Event`.
|
|
pub fn quit(this: *@This()) void {
|
|
this.quit_event.set();
|
|
this.postEvent(.quit);
|
|
}
|
|
|
|
/// Returns the next available event, blocking until one is available.
|
|
pub fn nextEvent(this: *@This()) Event {
|
|
return this.queue.pop();
|
|
}
|
|
|
|
/// Post an `Event` into the queue. Blocks if there is no capacity for the `Event`.
|
|
pub fn postEvent(this: *@This(), e: Event) void {
|
|
this.queue.push(e);
|
|
}
|
|
|
|
fn run(this: *@This()) !void {
|
|
// thread to read user inputs
|
|
var buf: [256]u8 = undefined;
|
|
while (true) {
|
|
// FIX I still think that there is a race condition (I'm just waiting 'long' enough)
|
|
this.quit_event.timedWait(20 * std.time.ns_per_ms) catch {
|
|
// FIX in case the queue is full -> the next user input should panic and quit the application? because something seems to clock up the event queue
|
|
const read_bytes = try terminal.read(buf[0..]);
|
|
// TODO `break` should not terminate the reading of the user inputs, but instead only the received faulty input!
|
|
// escape key presses
|
|
if (buf[0] == 0x1b and read_bytes > 1) {
|
|
switch (buf[1]) {
|
|
0x4F => { // ss3
|
|
if (read_bytes < 3) continue;
|
|
|
|
const key: Key = switch (buf[2]) {
|
|
'A' => .{ .cp = input.Up },
|
|
'B' => .{ .cp = input.Down },
|
|
'C' => .{ .cp = input.Right },
|
|
'D' => .{ .cp = input.Left },
|
|
'E' => .{ .cp = input.KpBegin },
|
|
'F' => .{ .cp = input.End },
|
|
'H' => .{ .cp = input.Home },
|
|
'P' => .{ .cp = input.F1 },
|
|
'Q' => .{ .cp = input.F2 },
|
|
'R' => .{ .cp = input.F3 },
|
|
'S' => .{ .cp = input.F4 },
|
|
else => continue,
|
|
};
|
|
this.postEvent(.{ .key = key });
|
|
},
|
|
0x5B => { // csi
|
|
if (read_bytes < 3) continue;
|
|
|
|
// We start iterating at index 2 to get past the '['
|
|
const sequence = for (buf[2..], 2..) |b, i| {
|
|
switch (b) {
|
|
0x40...0xFF => break buf[0 .. i + 1],
|
|
else => continue,
|
|
}
|
|
} else continue;
|
|
|
|
const final = sequence[sequence.len - 1];
|
|
switch (final) {
|
|
'A', 'B', 'C', 'D', 'E', 'F', 'H', 'P', 'Q', 'R', 'S' => {
|
|
// Legacy keys
|
|
// CSI {ABCDEFHPQS}
|
|
// CSI 1 ; modifier:event_type {ABCDEFHPQS}
|
|
var field_iter = std.mem.splitScalar(u8, sequence[2 .. sequence.len - 1], ';');
|
|
_ = field_iter.next(); // skip first field
|
|
|
|
const key: Key = .{
|
|
.cp = switch (final) {
|
|
'A' => input.Up,
|
|
'B' => input.Down,
|
|
'C' => input.Right,
|
|
'D' => input.Left,
|
|
'E' => input.KpBegin,
|
|
'F' => input.End,
|
|
'H' => input.Home,
|
|
'P' => input.F1,
|
|
'Q' => input.F2,
|
|
'R' => input.F3,
|
|
'S' => input.F4,
|
|
else => unreachable,
|
|
},
|
|
.mod = blk: {
|
|
// modifier_mask:event_type
|
|
var mod: Key.Modifier = .{};
|
|
const field_buf = field_iter.next() orelse break :blk mod;
|
|
var param_iter = std.mem.splitScalar(u8, field_buf, ':');
|
|
const modifier_buf = param_iter.next() orelse unreachable;
|
|
const modifier_mask = fmt.parseUnsigned(u8, modifier_buf, 10) catch break :blk mod;
|
|
if ((modifier_mask -| 1) & 1 != 0) mod.shift = true;
|
|
if ((modifier_mask -| 1) & 2 != 0) mod.alt = true;
|
|
if ((modifier_mask -| 1) & 4 != 0) mod.ctrl = true;
|
|
break :blk mod;
|
|
},
|
|
};
|
|
this.postEvent(.{ .key = key });
|
|
},
|
|
'Z' => this.postEvent(.{ .key = .{ .cp = input.Tab, .mod = .{ .shift = true } } }),
|
|
'~' => {
|
|
// Legacy keys
|
|
// CSI number ~
|
|
// CSI number ; modifier ~
|
|
// CSI number ; modifier:event_type ; text_as_codepoint ~
|
|
var field_iter = mem.splitScalar(u8, sequence[2 .. sequence.len - 1], ';');
|
|
|
|
const key: Key = .{
|
|
.cp = blk: {
|
|
const number_buf = field_iter.next() orelse unreachable; // always will have one field
|
|
const number = fmt.parseUnsigned(u16, number_buf, 10) catch break;
|
|
break :blk switch (number) {
|
|
2 => input.Insert,
|
|
3 => input.Delete,
|
|
5 => input.PageUp,
|
|
6 => input.PageDown,
|
|
7 => input.Home,
|
|
8 => input.End,
|
|
11 => input.F1,
|
|
12 => input.F2,
|
|
13 => input.F3,
|
|
14 => input.F4,
|
|
15 => input.F5,
|
|
17 => input.F6,
|
|
18 => input.F7,
|
|
19 => input.F8,
|
|
20 => input.F9,
|
|
21 => input.F10,
|
|
23 => input.F11,
|
|
24 => input.F12,
|
|
25 => input.F13,
|
|
26 => input.F14,
|
|
28 => input.F15,
|
|
29 => input.F16,
|
|
31 => input.F17,
|
|
32 => input.F18,
|
|
33 => input.F19,
|
|
34 => input.F20,
|
|
// 200 => return .{ .event = .paste_start, .n = sequence.len },
|
|
// 201 => return .{ .event = .paste_end, .n = sequence.len },
|
|
57399...57454 => |code| code,
|
|
else => unreachable,
|
|
};
|
|
},
|
|
.mod = blk: {
|
|
// modifier_mask:event_type
|
|
var mod: Key.Modifier = .{};
|
|
const field_buf = field_iter.next() orelse break :blk mod;
|
|
var param_iter = std.mem.splitScalar(u8, field_buf, ':');
|
|
const modifier_buf = param_iter.next() orelse unreachable;
|
|
const modifier_mask = fmt.parseUnsigned(u8, modifier_buf, 10) catch break :blk mod;
|
|
if ((modifier_mask -| 1) & 1 != 0) mod.shift = true;
|
|
if ((modifier_mask -| 1) & 2 != 0) mod.alt = true;
|
|
if ((modifier_mask -| 1) & 4 != 0) mod.ctrl = true;
|
|
break :blk mod;
|
|
},
|
|
};
|
|
this.postEvent(.{ .key = key });
|
|
},
|
|
// TODO focus usage? should this even be in the default event system?
|
|
'I' => this.postEvent(.{ .focus = true }),
|
|
'O' => this.postEvent(.{ .focus = false }),
|
|
'M', 'm' => {
|
|
assert(sequence.len >= 4);
|
|
if (sequence[2] != '<') break;
|
|
|
|
const delim1 = mem.indexOfScalarPos(u8, sequence, 3, ';') orelse break;
|
|
const button_mask = fmt.parseUnsigned(u16, sequence[3..delim1], 10) catch break;
|
|
const delim2 = mem.indexOfScalarPos(u8, sequence, delim1 + 1, ';') orelse break;
|
|
const px = fmt.parseUnsigned(u16, sequence[delim1 + 1 .. delim2], 10) catch break;
|
|
const py = fmt.parseUnsigned(u16, sequence[delim2 + 1 .. sequence.len - 1], 10) catch break;
|
|
|
|
const mouse_bits = packed struct {
|
|
const motion: u8 = 0b00100000;
|
|
const buttons: u8 = 0b11000011;
|
|
const shift: u8 = 0b00000100;
|
|
const alt: u8 = 0b00001000;
|
|
const ctrl: u8 = 0b00010000;
|
|
};
|
|
|
|
const button: Mouse.Button = @enumFromInt(button_mask & mouse_bits.buttons);
|
|
const motion = button_mask & mouse_bits.motion > 0;
|
|
// const shift = button_mask & mouse_bits.shift > 0;
|
|
// const alt = button_mask & mouse_bits.alt > 0;
|
|
// const ctrl = button_mask & mouse_bits.ctrl > 0;
|
|
|
|
const mouse: Mouse = .{
|
|
.button = button,
|
|
.x = px -| 1,
|
|
.y = py -| 1,
|
|
.kind = blk: {
|
|
if (motion and button != Mouse.Button.none) break :blk .drag;
|
|
if (motion and button == Mouse.Button.none) break :blk .motion;
|
|
if (sequence[sequence.len - 1] == 'm') break :blk .release;
|
|
break :blk .press;
|
|
},
|
|
};
|
|
this.postEvent(.{ .mouse = mouse });
|
|
},
|
|
'c' => {
|
|
// Primary DA (CSI ? Pm c)
|
|
},
|
|
'n' => {
|
|
// Device Status Report
|
|
// CSI Ps n
|
|
// CSI ? Ps n
|
|
assert(sequence.len >= 3);
|
|
},
|
|
't' => {
|
|
// XTWINOPS
|
|
// Split first into fields delimited by ';'
|
|
var iter = mem.splitScalar(u8, sequence[2 .. sequence.len - 1], ';');
|
|
const ps = iter.first();
|
|
if (mem.eql(u8, "48", ps)) {
|
|
// in band window resize
|
|
// CSI 48 ; height ; width ; height_pix ; width_pix t
|
|
const width_char = iter.next() orelse break;
|
|
const height_char = iter.next() orelse break;
|
|
|
|
_ = width_char;
|
|
_ = height_char;
|
|
this.postEvent(.resize);
|
|
// this.postEvent(.{ .size = .{
|
|
// .x = fmt.parseUnsigned(u16, width_char, 10) catch break,
|
|
// .y = fmt.parseUnsigned(u16, height_char, 10) catch break,
|
|
// } });
|
|
}
|
|
},
|
|
'u' => {
|
|
// Kitty keyboard
|
|
// CSI unicode-key-code:alternate-key-codes ; modifiers:event-type ; text-as-codepoints u
|
|
// Not all fields will be present. Only unicode-key-code is
|
|
// mandatory
|
|
},
|
|
'y' => {
|
|
// DECRPM (CSI ? Ps ; Pm $ y)
|
|
},
|
|
else => {},
|
|
}
|
|
},
|
|
0x50 => {
|
|
// DCS
|
|
},
|
|
0x58 => {
|
|
// SOS
|
|
},
|
|
0x5D => {
|
|
// OSC
|
|
},
|
|
// TODO parse corresponding codes
|
|
0x5F => {
|
|
// APC
|
|
// parse for kitty graphics capabilities
|
|
},
|
|
else => {
|
|
// alt + <char> keypress
|
|
this.postEvent(.{
|
|
.key = .{
|
|
.cp = buf[1],
|
|
.mod = .{ .alt = true },
|
|
},
|
|
});
|
|
},
|
|
}
|
|
} else {
|
|
const b = buf[0];
|
|
const key: Key = switch (b) {
|
|
0x00 => .{ .cp = '@', .mod = .{ .ctrl = true } },
|
|
0x08 => .{ .cp = input.Backspace },
|
|
0x09 => .{ .cp = input.Tab },
|
|
0x0a => .{ .cp = 'j', .mod = .{ .ctrl = true } },
|
|
0x0d => .{ .cp = input.Enter },
|
|
0x01...0x07, 0x0b...0x0c, 0x0e...0x1a => .{ .cp = b + 0x60, .mod = .{ .ctrl = true } },
|
|
0x1b => escape: {
|
|
assert(read_bytes == 1);
|
|
break :escape .{ .cp = input.Escape };
|
|
},
|
|
0x7f => .{ .cp = input.Backspace },
|
|
else => {
|
|
var iter = code_point.Iterator{ .bytes = buf[0..read_bytes] };
|
|
while (iter.next()) |cp| this.postEvent(.{ .key = .{ .cp = cp.code } });
|
|
continue;
|
|
},
|
|
};
|
|
this.postEvent(.{ .key = key });
|
|
}
|
|
continue;
|
|
};
|
|
break;
|
|
}
|
|
}
|
|
|
|
pub fn panic_handler(msg: []const u8, _: ?*std.builtin.StackTrace, ret_addr: ?usize) noreturn {
|
|
terminal.disableMouseSupport() catch {};
|
|
terminal.exitAltScreen() catch {};
|
|
terminal.showCursor() catch {};
|
|
var termios: posix.termios = .{
|
|
.iflag = .{},
|
|
.lflag = .{},
|
|
.cflag = .{},
|
|
.oflag = .{},
|
|
.cc = undefined,
|
|
.line = 0,
|
|
.ispeed = undefined,
|
|
.ospeed = undefined,
|
|
};
|
|
terminal.disableRawMode(&termios) catch {};
|
|
terminal.restoreScreen() catch {};
|
|
std.debug.defaultPanic(msg, ret_addr);
|
|
}
|
|
|
|
const element = @import("element.zig");
|
|
pub const Event = mergeTaggedUnions(event.SystemEvent, E);
|
|
pub const Container = @import("container.zig").Container(Event);
|
|
pub const Element = element.Element(Event);
|
|
pub const Alignment = element.Alignment(Event);
|
|
pub const Button = element.Button(Event, Queue);
|
|
pub const Input = element.Input(Event, Queue);
|
|
pub const Scrollable = element.Scrollable(Event);
|
|
pub const Queue = queue.Queue(Event, 256);
|
|
};
|
|
}
|
|
|
|
const log = std.log.scoped(.app);
|
|
|
|
const std = @import("std");
|
|
const mem = std.mem;
|
|
const fmt = std.fmt;
|
|
const posix = std.posix;
|
|
const Thread = std.Thread;
|
|
const assert = std.debug.assert;
|
|
const code_point = @import("code_point");
|
|
const event = @import("event.zig");
|
|
const input = @import("input.zig");
|
|
const terminal = @import("terminal.zig");
|
|
const queue = @import("queue.zig");
|
|
const mergeTaggedUnions = event.mergeTaggedUnions;
|
|
const isTaggedUnion = event.isTaggedUnion;
|
|
const Mouse = input.Mouse;
|
|
const Key = input.Key;
|
|
const Point = @import("point.zig").Point;
|