input: starting to work on KeyEncoder, got ctrl sequences

src/input/KeyEncoder.zig

@@ -0,0 +1,131 @@
+/// KeyEncoder is responsible for processing keyboard input and generating
+/// the proper VT sequence for any events.
+///
+/// A new KeyEncoder should be created for each individual key press.
+/// These encoders are not meant to be reused.
+const KeyEncoder = @This();
+
+const std = @import("std");
+const testing = std.testing;
+
+const key = @import("key.zig");
+
+key: key.Key,
+binding_mods: key.Mods,
+
+/// Initialize
+fn init(event: key.Event) KeyEncoder {
+    const effective_mods = event.effectiveMods();
+    const binding_mods = effective_mods.binding();
+
+    return .{
+        .key = event.key,
+        .binding_mods = binding_mods,
+    };
+}
+
+/// Returns the C0 byte for the key event if it should be used.
+/// This converts a key event into the expected terminal behavior
+/// such as Ctrl+C turning into 0x03, amongst many other translations.
+///
+/// This will return null if the key event should not be converted
+/// into a C0 byte. There are many cases for this and you should read
+/// the source code to understand them.
+fn ctrlSeq(self: *const KeyEncoder) ?u8 {
+    // Remove alt from our modifiers because it does not impact whether
+    // we are generating a ctrl sequence.
+    const unalt_mods = unalt_mods: {
+        var unalt_mods = self.binding_mods;
+        unalt_mods.alt = false;
+        break :unalt_mods unalt_mods;
+    };
+
+    // If we have any other modifier key set, then we do not generate
+    // a C0 sequence.
+    const ctrl_only = comptime (key.Mods{ .ctrl = true }).int();
+    if (unalt_mods.int() != ctrl_only) return null;
+
+    // The normal approach to get this value is to make the ascii byte
+    // with 0x1F. However, not all apprt key translation will properly
+    // generate the correct value so we just hardcode this based on
+    // logical key.
+    return switch (self.key) {
+        .space => 0,
+        .slash => 0x1F,
+        .zero => 0x30,
+        .one => 0x31,
+        .two => 0x00,
+        .three => 0x1B,
+        .four => 0x1C,
+        .five => 0x1D,
+        .six => 0x1E,
+        .seven => 0x1F,
+        .eight => 0x7F,
+        .nine => 0x39,
+        .backslash => 0x1C,
+        .left_bracket => 0x1B,
+        .right_bracket => 0x1D,
+        .a => 0x01,
+        .b => 0x02,
+        .c => 0x03,
+        .d => 0x04,
+        .e => 0x05,
+        .f => 0x06,
+        .g => 0x07,
+        .h => 0x08,
+        .i => 0x09,
+        .j => 0x0A,
+        .k => 0x0B,
+        .l => 0x0C,
+        .m => 0x0D,
+        .n => 0x0E,
+        .o => 0x0F,
+        .p => 0x10,
+        .q => 0x11,
+        .r => 0x12,
+        .s => 0x13,
+        .t => 0x14,
+        .u => 0x15,
+        .v => 0x16,
+        .w => 0x17,
+        .x => 0x18,
+        .y => 0x19,
+        .z => 0x1A,
+        else => null,
+    };
+}
+
+test "ctrlseq: normal ctrl c" {
+    const enc = init(.{ .key = .c, .mods = .{ .ctrl = true } });
+    const seq = enc.ctrlSeq();
+    try testing.expectEqual(@as(u8, 0x03), seq.?);
+}
+
+test "ctrlseq: alt should be allowed" {
+    const enc = init(.{ .key = .c, .mods = .{ .alt = true, .ctrl = true } });
+    const seq = enc.ctrlSeq();
+    try testing.expectEqual(@as(u8, 0x03), seq.?);
+}
+
+test "ctrlseq: no ctrl does nothing" {
+    const enc = init(.{ .key = .c, .mods = .{} });
+    try testing.expect(enc.ctrlSeq() == null);
+}
+
+test "ctrlseq: shift does not generate ctrl seq" {
+    {
+        const enc = init(.{
+            .key = .c,
+            .mods = .{ .shift = true },
+        });
+        try testing.expect(enc.ctrlSeq() == null);
+    }
+
+    {
+        const enc = init(.{
+            .key = .c,
+            .mods = .{ .shift = true, .ctrl = true },
+        });
+        try testing.expect(enc.ctrlSeq() == null);
+    }
+}