456 lines
16 KiB
Zig
456 lines
16 KiB
Zig
const vaxis = @import("vaxis");
|
|
|
|
const Io = @import("std").Io;
|
|
const meta = @import("std").meta;
|
|
const unicode = @import("std").unicode;
|
|
const FormatOptions = @import("std").fmt.FormatOptions;
|
|
|
|
pub const key = vaxis.Key;
|
|
pub const Key = u21;
|
|
|
|
pub const Mouse = vaxis.Mouse.Button;
|
|
pub const MouseType = @typeInfo(Mouse).@"enum".tag_type;
|
|
|
|
pub const mouse = struct {
|
|
pub const MOTION: Mouse = vaxis.Mouse.Button.none;
|
|
pub const BUTTON1: Mouse = vaxis.Mouse.Button.left;
|
|
pub const BUTTON2: Mouse = vaxis.Mouse.Button.middle;
|
|
pub const BUTTON3: Mouse = vaxis.Mouse.Button.right;
|
|
pub const BUTTON4: Mouse = vaxis.Mouse.Button.wheel_up;
|
|
pub const BUTTON5: Mouse = vaxis.Mouse.Button.wheel_down;
|
|
// pub const BUTTON6: Mouse = vaxis.Mouse.Button.button_6;
|
|
// pub const BUTTON7: Mouse = vaxis.Mouse.Button.button_7;
|
|
pub const BUTTON8: Mouse = vaxis.Mouse.Button.button_8;
|
|
pub const BUTTON9: Mouse = vaxis.Mouse.Button.button_9;
|
|
pub const BUTTON10: Mouse = vaxis.Mouse.Button.button_10;
|
|
pub const BUTTON11: Mouse = vaxis.Mouse.Button.button_11;
|
|
};
|
|
|
|
/// Does this key represent input?
|
|
pub fn is_non_input_key(w: Key) bool {
|
|
return switch (w) {
|
|
vaxis.Key.insert...vaxis.Key.iso_level_5_shift => true,
|
|
vaxis.Key.enter => true,
|
|
vaxis.Key.tab => true,
|
|
vaxis.Key.escape => true,
|
|
vaxis.Key.backspace => true,
|
|
else => false,
|
|
};
|
|
}
|
|
|
|
pub fn is_modifier(w: Key) bool {
|
|
return key.isModifier(.{ .codepoint = w });
|
|
}
|
|
|
|
pub const ModSet = vaxis.Key.Modifiers;
|
|
pub const Mods = u8;
|
|
|
|
pub const mod = struct {
|
|
pub const shift: u8 = @bitCast(ModSet{ .shift = true });
|
|
pub const alt: u8 = @bitCast(ModSet{ .alt = true });
|
|
pub const ctrl: u8 = @bitCast(ModSet{ .ctrl = true });
|
|
pub const super: u8 = @bitCast(ModSet{ .super = true });
|
|
pub const caps_lock: u8 = @bitCast(ModSet{ .caps_lock = true });
|
|
pub const num_lock: u8 = @bitCast(ModSet{ .num_lock = true });
|
|
};
|
|
|
|
pub const Event = u8;
|
|
pub const event = struct {
|
|
pub const press: Event = 1;
|
|
pub const repeat: Event = 2;
|
|
pub const release: Event = 3;
|
|
};
|
|
|
|
pub const KeyEvent = struct {
|
|
event: Event = 0,
|
|
key: Key,
|
|
key_unshifted: Key,
|
|
modifiers: Mods = 0,
|
|
text: []const u8 = "",
|
|
|
|
pub fn eql(self: @This(), other: @This()) bool {
|
|
const self_mods = self.mods_no_shifts();
|
|
const other_mods = other.mods_no_shifts();
|
|
return self.key == other.key and self_mods == other_mods;
|
|
}
|
|
|
|
pub fn eql_unshifted(self: @This(), other: @This()) bool {
|
|
if (self.text.len > 0 or other.text.len > 0) return false;
|
|
const self_mods = self.mods_no_caps();
|
|
const other_mods = other.mods_no_caps();
|
|
return self.key_unshifted == other.key_unshifted and self_mods == other_mods;
|
|
}
|
|
|
|
inline fn mods_no_shifts(self: @This()) Mods {
|
|
return if (self.key != self.key_unshifted) self.modifiers & ~(mod.shift | mod.caps_lock) else self.modifiers;
|
|
}
|
|
|
|
inline fn mods_no_caps(self: @This()) Mods {
|
|
return self.modifiers & ~mod.caps_lock;
|
|
}
|
|
|
|
pub fn format(self: @This(), writer: anytype) !void {
|
|
const mods = self.mods_no_shifts();
|
|
return if (self.event > 0)
|
|
writer.print("{f}:{f}{f}", .{ event_fmt(self.event), mod_fmt(mods), key_fmt(self.key) })
|
|
else
|
|
writer.print("{f}{f}", .{ mod_fmt(mods), key_fmt(self.key) });
|
|
}
|
|
|
|
pub fn from_key(keypress: Key) @This() {
|
|
return .{
|
|
.key = keypress,
|
|
.key_unshifted = keypress,
|
|
};
|
|
}
|
|
|
|
pub fn from_key_mods(keypress: Key, modifiers: Mods) @This() {
|
|
return .{
|
|
.key = keypress,
|
|
.key_unshifted = keypress,
|
|
.modifiers = modifiers,
|
|
};
|
|
}
|
|
|
|
pub fn from_key_modset(keypress: Key, modifiers: ModSet) @This() {
|
|
return from_key_mods(keypress, @bitCast(modifiers));
|
|
}
|
|
|
|
pub fn from_message(
|
|
event_: Event,
|
|
keypress_: Key,
|
|
keypress_shifted_: Key,
|
|
text: []const u8,
|
|
modifiers: Mods,
|
|
) @This() {
|
|
const mods_ = switch (keypress_) {
|
|
key.left_super, key.right_super => modifiers & ~mod.super,
|
|
key.left_shift, key.right_shift => modifiers & ~mod.shift,
|
|
key.left_control, key.right_control => modifiers & ~mod.ctrl,
|
|
key.left_alt, key.right_alt => modifiers & ~mod.alt,
|
|
else => modifiers,
|
|
};
|
|
|
|
var keypress_shifted: Key = keypress_shifted_;
|
|
if (text.len > 0) blk: {
|
|
keypress_shifted = tryUtf8Decode(text) catch break :blk;
|
|
}
|
|
const keypress, const mods = if (keypress_shifted == keypress_)
|
|
map_key_to_unshifed_legacy(keypress_shifted, mods_)
|
|
else
|
|
.{ keypress_, mods_ };
|
|
|
|
return .{
|
|
.event = event_,
|
|
.key = keypress_shifted,
|
|
.key_unshifted = keypress,
|
|
.modifiers = mods,
|
|
.text = text,
|
|
};
|
|
}
|
|
};
|
|
|
|
fn tryUtf8Decode(bytes: []const u8) !u21 {
|
|
return switch (bytes.len) {
|
|
1 => bytes[0],
|
|
2 => blk: {
|
|
if (bytes[0] & 0b11100000 != 0b11000000) break :blk error.Utf8Encoding2Invalid;
|
|
break :blk unicode.utf8Decode2(bytes[0..2].*);
|
|
},
|
|
3 => blk: {
|
|
if (bytes[0] & 0b11110000 != 0b11100000) break :blk error.Utf8Encoding3Invalid;
|
|
break :blk unicode.utf8Decode3(bytes[0..3].*);
|
|
},
|
|
4 => blk: {
|
|
if (bytes[0] & 0b11111000 != 0b11110000) break :blk error.Utf8Encoding4Invalid;
|
|
break :blk unicode.utf8Decode4(bytes[0..4].*);
|
|
},
|
|
else => error.Utf8CodepointLengthInvalid,
|
|
};
|
|
}
|
|
|
|
pub fn ucs32_to_utf8(ucs32: []const u32, utf8: []u8) !usize {
|
|
return @intCast(try unicode.utf8Encode(@intCast(ucs32[0]), utf8));
|
|
}
|
|
|
|
pub const utils = struct {
|
|
pub fn key_id_string(k: Key) []const u8 {
|
|
return switch (k) {
|
|
vaxis.Key.enter => "enter",
|
|
vaxis.Key.tab => "tab",
|
|
vaxis.Key.escape => "escape",
|
|
vaxis.Key.space => "space",
|
|
vaxis.Key.backspace => "backspace",
|
|
vaxis.Key.insert => "insert",
|
|
vaxis.Key.delete => "delete",
|
|
vaxis.Key.left => "left",
|
|
vaxis.Key.right => "right",
|
|
vaxis.Key.up => "up",
|
|
vaxis.Key.down => "down",
|
|
vaxis.Key.page_down => "page_down",
|
|
vaxis.Key.page_up => "page_up",
|
|
vaxis.Key.home => "home",
|
|
vaxis.Key.end => "end",
|
|
vaxis.Key.caps_lock => "caps_lock",
|
|
vaxis.Key.scroll_lock => "scroll_lock",
|
|
vaxis.Key.num_lock => "num_lock",
|
|
vaxis.Key.print_screen => "print_screen",
|
|
vaxis.Key.pause => "pause",
|
|
vaxis.Key.menu => "menu",
|
|
vaxis.Key.f1 => "f1",
|
|
vaxis.Key.f2 => "f2",
|
|
vaxis.Key.f3 => "f3",
|
|
vaxis.Key.f4 => "f4",
|
|
vaxis.Key.f5 => "f5",
|
|
vaxis.Key.f6 => "f6",
|
|
vaxis.Key.f7 => "f7",
|
|
vaxis.Key.f8 => "f8",
|
|
vaxis.Key.f9 => "f9",
|
|
vaxis.Key.f10 => "f10",
|
|
vaxis.Key.f11 => "f11",
|
|
vaxis.Key.f12 => "f12",
|
|
vaxis.Key.f13 => "f13",
|
|
vaxis.Key.f14 => "f14",
|
|
vaxis.Key.f15 => "f15",
|
|
vaxis.Key.f16 => "f16",
|
|
vaxis.Key.f17 => "f17",
|
|
vaxis.Key.f18 => "f18",
|
|
vaxis.Key.f19 => "f19",
|
|
vaxis.Key.f20 => "f20",
|
|
vaxis.Key.f21 => "f21",
|
|
vaxis.Key.f22 => "f22",
|
|
vaxis.Key.f23 => "f23",
|
|
vaxis.Key.f24 => "f24",
|
|
vaxis.Key.f25 => "f25",
|
|
vaxis.Key.f26 => "f26",
|
|
vaxis.Key.f27 => "f27",
|
|
vaxis.Key.f28 => "f28",
|
|
vaxis.Key.f29 => "f29",
|
|
vaxis.Key.f30 => "f30",
|
|
vaxis.Key.f31 => "f31",
|
|
vaxis.Key.f32 => "f32",
|
|
vaxis.Key.f33 => "f33",
|
|
vaxis.Key.f34 => "f34",
|
|
vaxis.Key.f35 => "f35",
|
|
vaxis.Key.kp_decimal => "kp_decimal",
|
|
vaxis.Key.kp_divide => "kp_divide",
|
|
vaxis.Key.kp_multiply => "kp_multiply",
|
|
vaxis.Key.kp_subtract => "kp_subtract",
|
|
vaxis.Key.kp_add => "kp_add",
|
|
vaxis.Key.kp_enter => "kp_enter",
|
|
vaxis.Key.kp_equal => "kp_equal",
|
|
vaxis.Key.kp_separator => "kp_separator",
|
|
vaxis.Key.kp_left => "kp_left",
|
|
vaxis.Key.kp_right => "kp_right",
|
|
vaxis.Key.kp_up => "kp_up",
|
|
vaxis.Key.kp_down => "kp_down",
|
|
vaxis.Key.kp_page_up => "kp_page_up",
|
|
vaxis.Key.kp_page_down => "kp_page_down",
|
|
vaxis.Key.kp_home => "kp_home",
|
|
vaxis.Key.kp_end => "kp_end",
|
|
vaxis.Key.kp_insert => "kp_insert",
|
|
vaxis.Key.kp_delete => "kp_delete",
|
|
vaxis.Key.kp_begin => "kp_begin",
|
|
vaxis.Key.media_play => "media_play",
|
|
vaxis.Key.media_pause => "media_pause",
|
|
vaxis.Key.media_play_pause => "media_play_pause",
|
|
vaxis.Key.media_reverse => "media_reverse",
|
|
vaxis.Key.media_stop => "media_stop",
|
|
vaxis.Key.media_fast_forward => "media_fast_forward",
|
|
vaxis.Key.media_rewind => "media_rewind",
|
|
vaxis.Key.media_track_next => "media_track_next",
|
|
vaxis.Key.media_track_previous => "media_track_previous",
|
|
vaxis.Key.media_record => "media_record",
|
|
vaxis.Key.lower_volume => "lower_volume",
|
|
vaxis.Key.raise_volume => "raise_volume",
|
|
vaxis.Key.mute_volume => "mute_volume",
|
|
vaxis.Key.left_shift => "left_shift",
|
|
vaxis.Key.left_control => "left_control",
|
|
vaxis.Key.left_alt => "left_alt",
|
|
vaxis.Key.left_super => "left_super",
|
|
vaxis.Key.left_hyper => "left_hyper",
|
|
vaxis.Key.left_meta => "left_meta",
|
|
vaxis.Key.right_shift => "right_shift",
|
|
vaxis.Key.right_control => "right_control",
|
|
vaxis.Key.right_alt => "right_alt",
|
|
vaxis.Key.right_super => "right_super",
|
|
vaxis.Key.right_hyper => "right_hyper",
|
|
vaxis.Key.right_meta => "right_meta",
|
|
vaxis.Key.iso_level_3_shift => "iso_level_3_shift",
|
|
vaxis.Key.iso_level_5_shift => "iso_level_5_shift",
|
|
else => "",
|
|
};
|
|
}
|
|
|
|
pub fn key_id_string_short(k: Key) []const u8 {
|
|
return switch (k) {
|
|
vaxis.Key.enter => "ret",
|
|
vaxis.Key.tab => "tab",
|
|
vaxis.Key.escape => "esc",
|
|
vaxis.Key.space => "sp",
|
|
vaxis.Key.backspace => "bs",
|
|
vaxis.Key.insert => "ins",
|
|
vaxis.Key.delete => "del",
|
|
vaxis.Key.left => "←",
|
|
vaxis.Key.right => "→",
|
|
vaxis.Key.up => "↑",
|
|
vaxis.Key.down => "↓",
|
|
vaxis.Key.page_down => "pgdn",
|
|
vaxis.Key.page_up => "pgup",
|
|
vaxis.Key.left_shift => "lshft",
|
|
vaxis.Key.left_control => "lctrl",
|
|
vaxis.Key.left_alt => "lalt",
|
|
vaxis.Key.left_super => "lsuper",
|
|
vaxis.Key.left_hyper => "lhyper",
|
|
vaxis.Key.left_meta => "lmeta",
|
|
vaxis.Key.right_shift => "rshft",
|
|
vaxis.Key.right_control => "rctrl",
|
|
vaxis.Key.right_alt => "ralt",
|
|
vaxis.Key.right_super => "rsuper",
|
|
vaxis.Key.right_hyper => "rhyper",
|
|
vaxis.Key.right_meta => "rmeta",
|
|
vaxis.Key.iso_level_3_shift => "iso3",
|
|
vaxis.Key.iso_level_5_shift => "iso5",
|
|
else => key_id_string(k),
|
|
};
|
|
}
|
|
|
|
pub fn button_id_string(m: Mouse) []const u8 {
|
|
return switch (m) {
|
|
mouse.MOTION => "motion",
|
|
mouse.BUTTON1 => "button1",
|
|
mouse.BUTTON2 => "button2",
|
|
mouse.BUTTON3 => "button3",
|
|
mouse.BUTTON4 => "button4",
|
|
mouse.BUTTON5 => "button5",
|
|
// mouse.BUTTON6 => "button6",
|
|
// mouse.BUTTON7 => "button7",
|
|
mouse.BUTTON8 => "button8",
|
|
mouse.BUTTON9 => "button9",
|
|
mouse.BUTTON10 => "button10",
|
|
mouse.BUTTON11 => "button11",
|
|
else => "",
|
|
};
|
|
}
|
|
};
|
|
|
|
pub fn key_event_short_fmt(ke: KeyEvent) struct {
|
|
ke: KeyEvent,
|
|
pub fn format(self: @This(), writer: anytype) Io.Writer.Error!void {
|
|
return writer.print("{f}{f}", .{ mod_short_fmt(self.ke.modifiers), key_short_fmt(self.ke.key) });
|
|
}
|
|
} {
|
|
return .{ .ke = ke };
|
|
}
|
|
|
|
pub fn event_fmt(evt: Event) struct {
|
|
event: Event,
|
|
pub fn format(self: @This(), writer: anytype) Io.Writer.Error!void {
|
|
return switch (self.event) {
|
|
event.press => writer.writeAll("press"),
|
|
event.repeat => writer.writeAll("repeat"),
|
|
event.release => writer.writeAll("release"),
|
|
else => {},
|
|
};
|
|
}
|
|
} {
|
|
return .{ .event = evt };
|
|
}
|
|
|
|
pub fn event_short_fmt(evt: Event) struct {
|
|
event: Event,
|
|
pub fn format(self: @This(), writer: anytype) Io.Writer.Error!void {
|
|
return switch (self.event) {
|
|
event.press => writer.writeAll("P"),
|
|
event.repeat => writer.writeAll("RP"),
|
|
event.release => writer.writeAll("R"),
|
|
else => {},
|
|
};
|
|
}
|
|
} {
|
|
return .{ .event = evt };
|
|
}
|
|
|
|
pub fn key_fmt(key_: Key) struct {
|
|
key: Key,
|
|
pub fn format(self: @This(), writer: anytype) Io.Writer.Error!void {
|
|
var key_string = utils.key_id_string(self.key);
|
|
var buf: [6]u8 = undefined;
|
|
if (key_string.len == 0) {
|
|
const bytes = ucs32_to_utf8(&[_]u32{self.key}, &buf) catch return error.WriteFailed;
|
|
key_string = buf[0..bytes];
|
|
}
|
|
try writer.writeAll(key_string);
|
|
}
|
|
} {
|
|
return .{ .key = key_ };
|
|
}
|
|
|
|
pub fn key_short_fmt(key_: Key) struct {
|
|
key: Key,
|
|
pub fn format(self: @This(), writer: anytype) Io.Writer.Error!void {
|
|
var key_string = utils.key_id_string_short(self.key);
|
|
var buf: [6]u8 = undefined;
|
|
if (key_string.len == 0) {
|
|
const bytes = try ucs32_to_utf8(&[_]u32{self.key}, &buf);
|
|
key_string = buf[0..bytes];
|
|
}
|
|
try writer.writeAll(key_string);
|
|
}
|
|
} {
|
|
return .{ .key = key_ };
|
|
}
|
|
|
|
pub fn mod_fmt(mods: Mods) struct {
|
|
modifiers: Mods,
|
|
pub fn format(self: @This(), writer: anytype) Io.Writer.Error!void {
|
|
const modset: ModSet = @bitCast(self.modifiers);
|
|
if (modset.super) try writer.writeAll("super+");
|
|
if (modset.ctrl) try writer.writeAll("ctrl+");
|
|
if (modset.alt) try writer.writeAll("alt+");
|
|
if (modset.shift) try writer.writeAll("shift+");
|
|
}
|
|
} {
|
|
return .{ .modifiers = mods };
|
|
}
|
|
|
|
pub fn mod_short_fmt(mods: Mods) struct {
|
|
modifiers: Mods,
|
|
pub fn format(self: @This(), writer: anytype) Io.Writer.Error!void {
|
|
const modset: ModSet = @bitCast(self.modifiers);
|
|
if (modset.super) try writer.writeAll("Super-");
|
|
if (modset.ctrl) try writer.writeAll("C-");
|
|
if (modset.alt) try writer.writeAll("A-");
|
|
if (modset.shift) try writer.writeAll("S-");
|
|
}
|
|
} {
|
|
return .{ .modifiers = mods };
|
|
}
|
|
|
|
fn map_key_to_unshifed_legacy(keypress_shifted: Key, mods: Mods) struct { Key, Mods } {
|
|
return switch (keypress_shifted) {
|
|
'A'...'Z' => .{ keypress_shifted + ('a' - 'A'), mods | mod.shift },
|
|
'!' => .{ '1', mods | mod.shift },
|
|
'@' => .{ '2', mods | mod.shift },
|
|
'#' => .{ '3', mods | mod.shift },
|
|
'$' => .{ '4', mods | mod.shift },
|
|
'%' => .{ '5', mods | mod.shift },
|
|
'^' => .{ '6', mods | mod.shift },
|
|
'&' => .{ '7', mods | mod.shift },
|
|
'*' => .{ '8', mods | mod.shift },
|
|
'(' => .{ '9', mods | mod.shift },
|
|
')' => .{ '0', mods | mod.shift },
|
|
'_' => .{ '-', mods | mod.shift },
|
|
'+' => .{ '=', mods | mod.shift },
|
|
'~' => .{ '`', mods | mod.shift },
|
|
'{' => .{ '[', mods | mod.shift },
|
|
'}' => .{ ']', mods | mod.shift },
|
|
'|' => .{ '\\', mods | mod.shift },
|
|
':' => .{ ';', mods | mod.shift },
|
|
'"' => .{ '\'', mods | mod.shift },
|
|
'<' => .{ ',', mods | mod.shift },
|
|
'>' => .{ '.', mods | mod.shift },
|
|
'?' => .{ '/', mods | mod.shift },
|
|
else => .{ keypress_shifted, mods },
|
|
};
|
|
}
|