From ba8148a5c87f85ff5b46ee7d6782a8c612907168 Mon Sep 17 00:00:00 2001 From: CJ van den Berg Date: Wed, 10 Dec 2025 17:03:54 +0100 Subject: [PATCH 1/3] refactor: format unknown key event values in input module --- src/renderer/vaxis/input.zig | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/renderer/vaxis/input.zig b/src/renderer/vaxis/input.zig index 44f79a2..48f8dc2 100644 --- a/src/renderer/vaxis/input.zig +++ b/src/renderer/vaxis/input.zig @@ -349,7 +349,7 @@ pub fn event_fmt(evt: Event) struct { event.press => writer.writeAll("press"), event.repeat => writer.writeAll("repeat"), event.release => writer.writeAll("release"), - else => {}, + else => writer.print("unknown({d})", .{self.event}), }; } } { @@ -363,7 +363,7 @@ pub fn event_short_fmt(evt: Event) struct { event.press => writer.writeAll("P"), event.repeat => writer.writeAll("RP"), event.release => writer.writeAll("R"), - else => {}, + else => writer.print("U({d})", .{self.event}), }; } } { From fe03d0dab4c2922f529e0c6ad1030b803c1ed0c2 Mon Sep 17 00:00:00 2001 From: CJ van den Berg Date: Wed, 10 Dec 2025 17:19:04 +0100 Subject: [PATCH 2/3] refactor: render event type in keybindview --- src/keybind/keybind.zig | 53 +++++++++++++++++++++++++++++++++-------- src/tui/keybindview.zig | 2 +- 2 files changed, 44 insertions(+), 11 deletions(-) diff --git a/src/keybind/keybind.zig b/src/keybind/keybind.zig index d22c9fb..a2986ca 100644 --- a/src/keybind/keybind.zig +++ b/src/keybind/keybind.zig @@ -675,7 +675,16 @@ const BindingSet = struct { const key_event = input.KeyEvent.from_message(event, keypress, keypress_shifted, text, modifiers); if (self.process_key_event(key_event) catch |e| return tp.exit_error(e, @errorReturnTrace())) |binding| { if (enable_match_events) - self.send_match_event(key_event, binding); + self.send_match_event(if (key_event.event != input.event.release) + globals.current_sequence.items + else + &[_]KeyEvent{key_event}, binding.commands); + + if (key_event.event != input.event.release) { + globals.current_sequence.clearRetainingCapacity(); + globals.current_sequence_egc.clearRetainingCapacity(); + } + for (binding.commands) |*cmd| try cmd.execute(); } } else if (try m.match(.{"F"})) { @@ -727,11 +736,7 @@ const BindingSet = struct { for (self.press.items) |*binding| { switch (binding.match(globals.current_sequence.items)) { - .matched => { - globals.current_sequence.clearRetainingCapacity(); - globals.current_sequence_egc.clearRetainingCapacity(); - return binding; - }, + .matched => return binding, .match_possible => { all_matches_impossible = false; }, @@ -774,21 +779,21 @@ const BindingSet = struct { } } - fn send_match_event(self: *const @This(), key_event: KeyEvent, binding: *const Binding) void { + fn send_match_event(self: *const @This(), key_events: []const KeyEvent, cmds: []Command) void { var buf: [tp.max_message_size]u8 = undefined; var stream: std.Io.Writer = .fixed(&buf); var key_event_buf: [256]u8 = undefined; var key_event_str: std.Io.Writer = .fixed(&key_event_buf); - key_event_str.print("{f}", .{key_event}) catch return; + key_event_str.print("{f}", .{key_event_sequence_long_fmt(key_events)}) catch return; cbor.writeArrayHeader(&stream, 5) catch return; cbor.writeValue(&stream, "K") catch return; cbor.writeValue(&stream, get_namespace()) catch return; cbor.writeValue(&stream, self.config_section) catch return; cbor.writeValue(&stream, key_event_str.buffered()) catch return; - cbor.writeArrayHeader(&stream, binding.commands.len) catch return; - for (binding.commands) |cmd| { + cbor.writeArrayHeader(&stream, cmds.len) catch return; + for (cmds) |cmd| { cbor.writeArrayHeader(&stream, 2) catch return; cbor.writeValue(&stream, cmd.command) catch return; stream.writeAll(cmd.args) catch return; @@ -921,14 +926,42 @@ const KeyEventSequenceFmt = struct { } }; +const KeyEventSequenceLongFmt = struct { + key_events: []const KeyEvent, + + pub fn format(self: @This(), writer: anytype) !void { + var first = true; + for (self.key_events) |key_event| { + if (first) { + first = false; + } else { + try writer.print(" ", .{}); + } + if (key_event.event == input.event.press) { + try writer.print("{f}", .{input.key_event_short_fmt(key_event)}); + } else { + try writer.print("{f}:{f}", .{ input.event_fmt(key_event.event), input.key_event_short_fmt(key_event) }); + } + } + } +}; + pub fn key_event_sequence_fmt(key_events: []const KeyEvent) KeyEventSequenceFmt { return .{ .key_events = key_events }; } +pub fn key_event_sequence_long_fmt(key_events: []const KeyEvent) KeyEventSequenceLongFmt { + return .{ .key_events = key_events }; +} + pub fn current_key_event_sequence_fmt() KeyEventSequenceFmt { return .{ .key_events = globals.current_sequence.items }; } +pub fn current_key_event_sequence_long_fmt() KeyEventSequenceLongFmt { + return .{ .key_events = globals.current_sequence.items }; +} + pub fn current_integer_argument() ?usize { return integer_argument; } diff --git a/src/tui/keybindview.zig b/src/tui/keybindview.zig index 4e2f532..51362d3 100644 --- a/src/tui/keybindview.zig +++ b/src/tui/keybindview.zig @@ -95,7 +95,7 @@ fn keybind_match(self: *Self, _: tp.pid_ref, m: tp.message) MessageFilter.Error! defer result.deinit(); const writer = &result.writer; - writer.print("{s}:{s} {s} -> ", .{ namespace, section, key_event }) catch return true; + writer.print("{s}:{s} {s} => ", .{ namespace, section, key_event }) catch return true; cbor.toJsonWriter(cmds, writer, .{}) catch return true; const ts = time.microTimestamp(); From b08b162a10c85d6db3e28af3a9c1bc8e670eee75 Mon Sep 17 00:00:00 2001 From: CJ van den Berg Date: Wed, 10 Dec 2025 17:39:14 +0100 Subject: [PATCH 3/3] refactor: add insert events to keybindview --- src/keybind/keybind.zig | 7 +++++++ src/tui/keybindview.zig | 33 ++++++++++++++++++++++++--------- src/tui/tui.zig | 5 +++++ 3 files changed, 36 insertions(+), 9 deletions(-) diff --git a/src/keybind/keybind.zig b/src/keybind/keybind.zig index a2986ca..0143f97 100644 --- a/src/keybind/keybind.zig +++ b/src/keybind/keybind.zig @@ -25,6 +25,7 @@ const builtin_keybinds = std.StaticStringMap([]const u8).initComptime(.{ }); pub var enable_match_events: bool = false; +pub var enable_insert_events: bool = false; var integer_argument: ?usize = null; var mode_flag: KeybindMode = .normal; @@ -647,6 +648,8 @@ const BindingSet = struct { globals.insert_command = self.insert_command; globals.insert_command_id = null; } + if (enable_insert_events) + self.send_insert_event(globals.insert_command, globals.input_buffer.items); const id = globals.insert_command_id orelse command.get_id_cache(globals.insert_command, &globals.insert_command_id) orelse { return tp.exit_error(error.InputTargetNotFound, null); @@ -801,6 +804,10 @@ const BindingSet = struct { _ = tp.self_pid().send_raw(.{ .buf = stream.buffered() }) catch {}; } + fn send_insert_event(self: *const @This(), insert_cmd: []const u8, bytes: []const u8) void { + _ = tp.self_pid().send(.{ "N", get_namespace(), self.config_section, insert_cmd, bytes }) catch {}; + } + fn log_keyhints_message() void { for (globals.current_sequence.items) |item| switch (item.key) { input.key.left_control, input.key.right_control => return, diff --git a/src/tui/keybindview.zig b/src/tui/keybindview.zig index 51362d3..fe5a875 100644 --- a/src/tui/keybindview.zig +++ b/src/tui/keybindview.zig @@ -3,6 +3,7 @@ const time = @import("std").time; const Allocator = @import("std").mem.Allocator; const ArrayList = @import("std").ArrayList; const Writer = @import("std").Io.Writer; +const hexEscape = @import("std").ascii.hexEscape; const tp = @import("thespian"); const cbor = @import("cbor"); @@ -89,23 +90,37 @@ fn keybind_match(self: *Self, _: tp.pid_ref, m: tp.message) MessageFilter.Error! var section: []const u8 = undefined; var key_event: []const u8 = undefined; var cmds: []const u8 = undefined; - if (!(m.match(.{ "K", tp.extract(&namespace), tp.extract(§ion), tp.extract(&key_event), tp.extract_cbor(&cmds) }) catch false)) return false; + var insert_cmd: []const u8 = undefined; + var bytes: []const u8 = undefined; - var result: Writer.Allocating = .init(self.allocator); - defer result.deinit(); - const writer = &result.writer; + if (m.match(.{ "K", tp.extract(&namespace), tp.extract(§ion), tp.extract(&key_event), tp.extract_cbor(&cmds) }) catch false) { + var result: Writer.Allocating = .init(self.allocator); + defer result.deinit(); + const writer = &result.writer; - writer.print("{s}:{s} {s} => ", .{ namespace, section, key_event }) catch return true; - cbor.toJsonWriter(cmds, writer, .{}) catch return true; + writer.print("{s}:{s} {s} => ", .{ namespace, section, key_event }) catch return true; + cbor.toJsonWriter(cmds, writer, .{}) catch return true; + self.append(result.toOwnedSlice() catch return true); + return true; + } else if (m.match(.{ "N", tp.extract(&namespace), tp.extract(§ion), tp.extract(&insert_cmd), tp.extract(&bytes) }) catch false) { + var result: Writer.Allocating = .init(self.allocator); + defer result.deinit(); + result.writer.print("{s}:{s} insert => [\"{s}\", \"{f}\"] ", .{ namespace, section, insert_cmd, hexEscape(bytes, .lower) }) catch return true; + self.append(result.toOwnedSlice() catch return true); + return true; + } + return false; +} + +pub fn append(self: *Self, msg: []const u8) void { const ts = time.microTimestamp(); const tdiff = if (self.buffer.items.len > 0) ts -| self.buffer.items[self.buffer.items.len - 1].time else 0; - (try self.buffer.addOne(self.allocator)).* = .{ + (self.buffer.addOne(self.allocator) catch return).* = .{ .time = ts, .tdiff = tdiff, - .msg = result.toOwnedSlice() catch return true, + .msg = msg, }; - return true; } pub fn receive(_: *Self, _: tp.pid_ref, _: tp.message) error{Exit}!bool { diff --git a/src/tui/tui.zig b/src/tui/tui.zig index b23d803..60c75c2 100644 --- a/src/tui/tui.zig +++ b/src/tui/tui.zig @@ -503,6 +503,9 @@ fn receive_safe(self: *Self, from: tp.pid_ref, m: tp.message) !void { if (try m.match(.{ "K", tp.more })) return; + if (try m.match(.{ "N", tp.more })) + return; + if (try self.send_widgets(from, m)) return; @@ -2363,8 +2366,10 @@ pub fn set_last_palette(type_: PaletteType, ctx: command.Context) void { pub fn enable_match_events() void { keybind.enable_match_events = true; + keybind.enable_insert_events = true; } pub fn disable_match_events() void { keybind.enable_match_events = false; + keybind.enable_insert_events = false; }