espanso/espanso-inject/src/keys.rs

360 lines
8.5 KiB
Rust
Raw Normal View History

2021-02-14 20:02:50 +00:00
/*
* This file is part of espanso.
*
* Copyright (C) 2019-2021 Federico Terzi
*
* espanso is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* espanso is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with espanso. If not, see <https://www.gnu.org/licenses/>.
*/
use std::fmt::Display;
use regex::Regex;
lazy_static! {
static ref RAW_PARSER: Regex = Regex::new(r"^RAW\((\d+)\)$").unwrap();
}
#[derive(Debug, Clone)]
pub enum Key {
// Modifiers
Alt,
CapsLock,
Control,
Meta,
NumLock,
Shift,
// Whitespace
Enter,
Tab,
Space,
// Navigation
ArrowDown,
ArrowLeft,
ArrowRight,
ArrowUp,
End,
Home,
PageDown,
PageUp,
// UI
Escape,
// Editing keys
Backspace,
Insert,
Delete,
// Function keys
F1,
F2,
F3,
F4,
F5,
F6,
F7,
F8,
F9,
F10,
F11,
F12,
F13,
F14,
F15,
F16,
F17,
F18,
F19,
F20,
// Alphabet
A,
B,
C,
D,
E,
F,
G,
H,
I,
J,
K,
L,
M,
N,
O,
P,
Q,
R,
S,
T,
U,
V,
W,
X,
Y,
Z,
// Numbers
N0,
N1,
N2,
N3,
N4,
N5,
N6,
N7,
N8,
N9,
// Numpad
Numpad0,
Numpad1,
Numpad2,
Numpad3,
Numpad4,
Numpad5,
Numpad6,
Numpad7,
Numpad8,
Numpad9,
// Specify the raw platform-specific virtual key code.
Raw(i32),
}
impl Display for Key {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match *self {
Key::Alt => write!(f, "ALT"),
Key::CapsLock => write!(f, "CAPSLOCK"),
Key::Control => write!(f, "CTRL"),
Key::Meta => write!(f, "META"),
Key::NumLock => write!(f, "NUMLOCK"),
Key::Shift => write!(f, "SHIFT"),
Key::Enter => write!(f, "ENTER"),
Key::Tab => write!(f, "TAB"),
Key::Space => write!(f, "SPACE"),
Key::ArrowDown => write!(f, "DOWN"),
Key::ArrowLeft => write!(f, "LEFT"),
Key::ArrowRight => write!(f, "RIGHT"),
Key::ArrowUp => write!(f, "UP"),
Key::End => write!(f, "END"),
Key::Home => write!(f, "HOME"),
Key::PageDown => write!(f, "PAGEDOWN"),
Key::PageUp => write!(f, "PAGEUP"),
Key::Escape => write!(f, "ESC"),
Key::Backspace => write!(f, "BACKSPACE"),
Key::Insert => write!(f, "INSERT"),
Key::Delete => write!(f, "DELETE"),
Key::F1 => write!(f, "F1"),
Key::F2 => write!(f, "F2"),
Key::F3 => write!(f, "F3"),
Key::F4 => write!(f, "F4"),
Key::F5 => write!(f, "F5"),
Key::F6 => write!(f, "F6"),
Key::F7 => write!(f, "F7"),
Key::F8 => write!(f, "F8"),
Key::F9 => write!(f, "F9"),
Key::F10 => write!(f, "F10"),
Key::F11 => write!(f, "F11"),
Key::F12 => write!(f, "F12"),
Key::F13 => write!(f, "F13"),
Key::F14 => write!(f, "F14"),
Key::F15 => write!(f, "F15"),
Key::F16 => write!(f, "F16"),
Key::F17 => write!(f, "F17"),
Key::F18 => write!(f, "F18"),
Key::F19 => write!(f, "F19"),
Key::F20 => write!(f, "F20"),
Key::A => write!(f, "A"),
Key::B => write!(f, "B"),
Key::C => write!(f, "C"),
Key::D => write!(f, "D"),
Key::E => write!(f, "E"),
Key::F => write!(f, "F"),
Key::G => write!(f, "G"),
Key::H => write!(f, "H"),
Key::I => write!(f, "I"),
Key::J => write!(f, "J"),
Key::K => write!(f, "K"),
Key::L => write!(f, "L"),
Key::M => write!(f, "M"),
Key::N => write!(f, "N"),
Key::O => write!(f, "O"),
Key::P => write!(f, "P"),
Key::Q => write!(f, "Q"),
Key::R => write!(f, "R"),
Key::S => write!(f, "S"),
Key::T => write!(f, "T"),
Key::U => write!(f, "U"),
Key::V => write!(f, "V"),
Key::W => write!(f, "W"),
Key::X => write!(f, "X"),
Key::Y => write!(f, "Y"),
Key::Z => write!(f, "Z"),
Key::N0 => write!(f, "0"),
Key::N1 => write!(f, "1"),
Key::N2 => write!(f, "2"),
Key::N3 => write!(f, "3"),
Key::N4 => write!(f, "4"),
Key::N5 => write!(f, "5"),
Key::N6 => write!(f, "6"),
Key::N7 => write!(f, "7"),
Key::N8 => write!(f, "8"),
Key::N9 => write!(f, "9"),
Key::Numpad0 => write!(f, "NUMPAD0"),
Key::Numpad1 => write!(f, "NUMPAD1"),
Key::Numpad2 => write!(f, "NUMPAD2"),
Key::Numpad3 => write!(f, "NUMPAD3"),
Key::Numpad4 => write!(f, "NUMPAD4"),
Key::Numpad5 => write!(f, "NUMPAD5"),
Key::Numpad6 => write!(f, "NUMPAD6"),
Key::Numpad7 => write!(f, "NUMPAD7"),
Key::Numpad8 => write!(f, "NUMPAD8"),
Key::Numpad9 => write!(f, "NUMPAD9"),
Key::Raw(code) => write!(f, "RAW({})", code),
}
}
}
impl Key {
pub fn parse(key: &str) -> Option<Key> {
let parsed = match key {
2021-03-14 14:50:54 +00:00
"ALT" | "OPTION" => Some(Key::Alt),
"CAPSLOCK" => Some(Key::CapsLock),
"CTRL" => Some(Key::Control),
2021-03-14 14:50:54 +00:00
"META" | "CMD" => Some(Key::Meta),
"NUMLOCK" => Some(Key::NumLock),
"SHIFT" => Some(Key::Shift),
"ENTER" => Some(Key::Enter),
"TAB" => Some(Key::Tab),
"SPACE" => Some(Key::Space),
"DOWN" => Some(Key::ArrowDown),
"LEFT" => Some(Key::ArrowLeft),
"RIGHT" => Some(Key::ArrowRight),
"UP" => Some(Key::ArrowUp),
"END" => Some(Key::End),
"HOME" => Some(Key::Home),
"PAGEDOWN" => Some(Key::PageDown),
"PAGEUP" => Some(Key::PageUp),
"ESC" => Some(Key::Escape),
"BACKSPACE" => Some(Key::Backspace),
"INSERT" => Some(Key::Insert),
"DELETE" => Some(Key::Delete),
"F1" => Some(Key::F1),
"F2" => Some(Key::F2),
"F3" => Some(Key::F3),
"F4" => Some(Key::F4),
"F5" => Some(Key::F5),
"F6" => Some(Key::F6),
"F7" => Some(Key::F7),
"F8" => Some(Key::F8),
"F9" => Some(Key::F9),
"F10" => Some(Key::F10),
"F11" => Some(Key::F11),
"F12" => Some(Key::F12),
"F13" => Some(Key::F13),
"F14" => Some(Key::F14),
"F15" => Some(Key::F15),
"F16" => Some(Key::F16),
"F17" => Some(Key::F17),
"F18" => Some(Key::F18),
"F19" => Some(Key::F19),
"F20" => Some(Key::F20),
"A" => Some(Key::A),
"B" => Some(Key::B),
"C" => Some(Key::C),
"D" => Some(Key::D),
"E" => Some(Key::E),
"F" => Some(Key::F),
"G" => Some(Key::G),
"H" => Some(Key::H),
"I" => Some(Key::I),
"J" => Some(Key::J),
"K" => Some(Key::K),
"L" => Some(Key::L),
"M" => Some(Key::M),
"N" => Some(Key::N),
"O" => Some(Key::O),
"P" => Some(Key::P),
"Q" => Some(Key::Q),
"R" => Some(Key::R),
"S" => Some(Key::S),
"T" => Some(Key::T),
"U" => Some(Key::U),
"V" => Some(Key::V),
"W" => Some(Key::W),
"X" => Some(Key::X),
"Y" => Some(Key::Y),
"Z" => Some(Key::Z),
"0" => Some(Key::N0),
"1" => Some(Key::N1),
"2" => Some(Key::N2),
"3" => Some(Key::N3),
"4" => Some(Key::N4),
"5" => Some(Key::N5),
"6" => Some(Key::N6),
"7" => Some(Key::N7),
"8" => Some(Key::N8),
"9" => Some(Key::N9),
"NUMPAD0" => Some(Key::Numpad0),
"NUMPAD1" => Some(Key::Numpad1),
"NUMPAD2" => Some(Key::Numpad2),
"NUMPAD3" => Some(Key::Numpad3),
"NUMPAD4" => Some(Key::Numpad4),
"NUMPAD5" => Some(Key::Numpad5),
"NUMPAD6" => Some(Key::Numpad6),
"NUMPAD7" => Some(Key::Numpad7),
"NUMPAD8" => Some(Key::Numpad8),
"NUMPAD9" => Some(Key::Numpad9),
_ => None,
};
if parsed.is_none() {
// Attempt to parse raw keys
if RAW_PARSER.is_match(key) {
if let Some(caps) = RAW_PARSER.captures(key) {
let code_str = caps.get(1).map_or("", |m| m.as_str());
let code = code_str.parse::<i32>();
if let Ok(code) = code {
return Some(Key::Raw(code));
}
}
}
}
parsed
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn parse_works_correctly() {
assert!(matches!(Key::parse("ALT").unwrap(), Key::Alt));
assert!(matches!(Key::parse("RAW(1234)").unwrap(), Key::Raw(1234)));
}
#[test]
fn parse_invalid_keys() {
assert!(Key::parse("INVALID").is_none());
assert!(Key::parse("RAW(a)").is_none());
}
2021-03-09 15:06:50 +00:00
}