Skip to content

armgit / qm

Public Imported from GitHub
0

Multiplayer agent harness for work.

13.5 KB
Raw Blame
pub const SHIFT: u64 = 1 << 17;
pub const CONTROL: u64 = 1 << 18;
pub const OPTION: u64 = 1 << 19;
pub const COMMAND: u64 = 1 << 20;
pub const KEYPAD: u64 = 1 << 21;
pub const FUNCTION: u64 = 1 << 23;

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Chord {
    pub code: u16,
    pub flags: u64,
    pub character: Option<char>,
    pub modifiers: Vec<u16>,
}

impl Chord {
    pub fn remap(&mut self, stroke: crate::text::Stroke) {
        self.code = stroke.code;
        if !self.modifiers.iter().any(|code| modifier(*code) == Some(SHIFT)) {
            self.flags &= !SHIFT;
        }
        if stroke.shift {
            self.flags |= SHIFT;
        }
        if stroke.option {
            self.flags |= OPTION;
        }
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct Event {
    pub code: u16,
    pub flags: u64,
    pub down: bool,
    pub modifier: bool,
    pub release: bool,
}

#[derive(Default)]
pub struct Pressed(Vec<u16>);

impl Pressed {
    pub fn record(&mut self, event: Event) -> bool {
        if event.release {
            let Some(at) = self.0.iter().position(|code| *code == event.code) else { return false };
            self.0.remove(at);
        } else {
            self.0.push(event.code);
        }
        true
    }
}

fn modifier(code: u16) -> Option<u64> {
    match code {
        54 | 55 => Some(COMMAND),
        56 | 60 => Some(SHIFT),
        58 | 61 => Some(OPTION),
        59 | 62 => Some(CONTROL),
        63 => Some(FUNCTION),
        _ => None,
    }
}

fn modifier_code(name: &str) -> Option<u16> {
    match name {
        "cmd" | "command" | "meta" | "super" | "super_l" | "meta_l" => Some(55),
        "super_r" | "meta_r" | "rightcommand" => Some(54),
        "shift" | "shift_l" => Some(56),
        "shift_r" | "rightshift" => Some(60),
        "opt" | "option" | "alt" | "alt_l" => Some(58),
        "alt_r" | "rightoption" => Some(61),
        "ctrl" | "control" | "control_l" => Some(59),
        "control_r" | "rightcontrol" => Some(62),
        "fn" | "function" => Some(63),
        _ => None,
    }
}

pub fn parse(input: &str) -> Option<Chord> {
    let (mods, last) = match input.rsplit_once('+') {
        Some((m, "")) => (m.strip_suffix('+').unwrap_or(m), "+"),
        Some((m, last)) => (m, last),
        None => ("", input),
    };
    let mut flags = 0;
    let mut modifiers = Vec::new();
    for name in mods.split('+').filter(|m| !m.is_empty()) {
        let code = modifier_code(&name.to_ascii_lowercase())?;
        let flag = modifier(code)?;
        if flags & flag == 0 {
            modifiers.push(code);
        }
        flags |= flag;
    }
    let name = last.to_ascii_lowercase();
    if let Some(code) = modifier_code(&name) {
        return Some(Chord { code, flags, character: None, modifiers });
    }
    let single = (name.chars().count() == 1).then(|| name.chars().next().unwrap()).or_else(|| symbol(&name));
    let symbol = single.and_then(|c| "~!@#$%^&*()_+{}|:\"<>?".chars().position(|x| x == c));
    let normalized = if let Some(i) = symbol {
        flags |= SHIFT;
        "`1234567890-=[]\\;',./".chars().nth(i)?.to_string()
    } else {
        name.clone()
    };
    let code = code(&single.filter(|_| symbol.is_none()).map(|c| c.to_ascii_lowercase().to_string()).unwrap_or(normalized))?;
    if name.starts_with("kp_") || name.starts_with("keypad") {
        flags |= KEYPAD;
    }
    Some(Chord { code, flags, character: single.filter(|c| c.is_ascii() && !c.is_control()), modifiers })
}

pub fn events(code: u16, flags: u64) -> Vec<Event> {
    events_with_modifiers(code, flags, &[])
}

pub fn events_with_modifiers(code: u16, flags: u64, requested: &[u16]) -> Vec<Event> {
    let modifiers = [(59, CONTROL), (58, OPTION), (56, SHIFT), (55, COMMAND), (63, FUNCTION)];
    let key_modifier = modifier(code);
    let held: Vec<_> = modifiers
        .into_iter()
        .filter(|(_, f)| flags & f != 0 && Some(*f) != key_modifier)
        .map(|(default, flag)| (requested.iter().copied().find(|c| modifier(*c) == Some(flag)).unwrap_or(default), flag))
        .collect();
    let mut active = 0;
    let mut out = Vec::new();
    for &(code, flag) in &held {
        active |= flag;
        out.push(Event { code, flags: active, down: true, modifier: true, release: false });
    }
    out.push(Event { code, flags: flags | key_modifier.unwrap_or(0), down: true, modifier: key_modifier.is_some(), release: false });
    out.push(Event { code, flags: flags & !key_modifier.unwrap_or(0), down: false, modifier: key_modifier.is_some(), release: true });
    for &(code, flag) in held.iter().rev() {
        active &= !flag;
        out.push(Event { code, flags: active, down: false, modifier: true, release: true });
    }
    out
}

const SYMBOLS: &[(&str, char)] = &[
    ("comma", ','),
    ("period", '.'),
    ("slash", '/'),
    ("backslash", '\\'),
    ("semicolon", ';'),
    ("colon", ':'),
    ("apostrophe", '\''),
    ("quoteright", '\''),
    ("quotedbl", '"'),
    ("grave", '`'),
    ("quoteleft", '`'),
    ("asciitilde", '~'),
    ("minus", '-'),
    ("underscore", '_'),
    ("equal", '='),
    ("plus", '+'),
    ("bracketleft", '['),
    ("bracketright", ']'),
    ("braceleft", '{'),
    ("braceright", '}'),
    ("parenleft", '('),
    ("parenright", ')'),
    ("less", '<'),
    ("greater", '>'),
    ("question", '?'),
    ("exclam", '!'),
    ("at", '@'),
    ("numbersign", '#'),
    ("dollar", '$'),
    ("percent", '%'),
    ("asciicircum", '^'),
    ("ampersand", '&'),
    ("asterisk", '*'),
    ("bar", '|'),
];
fn symbol(name: &str) -> Option<char> {
    SYMBOLS.iter().find(|(n, _)| *n == name).map(|(_, c)| *c)
}

fn code(k: &str) -> Option<u16> {
    const KEYS: &[(&str, u16)] = &[
        ("a", 0),
        ("s", 1),
        ("d", 2),
        ("f", 3),
        ("h", 4),
        ("g", 5),
        ("z", 6),
        ("x", 7),
        ("c", 8),
        ("v", 9),
        ("b", 11),
        ("q", 12),
        ("w", 13),
        ("e", 14),
        ("r", 15),
        ("y", 16),
        ("t", 17),
        ("1", 18),
        ("2", 19),
        ("3", 20),
        ("4", 21),
        ("6", 22),
        ("5", 23),
        ("=", 24),
        ("9", 25),
        ("7", 26),
        ("-", 27),
        ("8", 28),
        ("0", 29),
        ("]", 30),
        ("o", 31),
        ("u", 32),
        ("[", 33),
        ("i", 34),
        ("p", 35),
        ("return", 36),
        ("enter", 36),
        ("l", 37),
        ("j", 38),
        ("'", 39),
        ("k", 40),
        (";", 41),
        ("\\", 42),
        (",", 43),
        ("/", 44),
        ("n", 45),
        ("m", 46),
        (".", 47),
        ("tab", 48),
        ("space", 49),
        ("`", 50),
        ("delete", 51),
        ("backspace", 51),
        ("escape", 53),
        ("esc", 53),
        ("f5", 96),
        ("f6", 97),
        ("f7", 98),
        ("f3", 99),
        ("f8", 100),
        ("f9", 101),
        ("f11", 103),
        ("f10", 109),
        ("f12", 111),
        ("home", 115),
        ("pageup", 116),
        ("forwarddelete", 117),
        ("f4", 118),
        ("end", 119),
        ("f2", 120),
        ("pagedown", 121),
        ("f1", 122),
        ("left", 123),
        ("right", 124),
        ("down", 125),
        ("up", 126),
    ];
    let extra = match k {
        "f13" => 105,
        "f14" => 107,
        "f15" => 113,
        "f16" => 106,
        "f17" => 64,
        "f18" => 79,
        "f19" => 80,
        "f20" => 90,
        "kp_decimal" | "kp_separator" | "keypaddecimal" => 65,
        "kp_multiply" | "keypadmultiply" => 67,
        "kp_add" | "keypadadd" => 69,
        "kp_clear" | "clear" | "numlock" | "num_lock" => 71,
        "kp_divide" | "keypaddivide" => 75,
        "kp_enter" | "keypadenter" => 76,
        "kp_subtract" | "keypadsubtract" => 78,
        "kp_equal" | "keypadequal" => 81,
        "kp_0" | "kp_insert" | "keypad0" => 82,
        "kp_1" | "kp_end" | "keypad1" => 83,
        "kp_2" | "kp_down" | "keypad2" => 84,
        "kp_3" | "kp_next" | "keypad3" => 85,
        "kp_4" | "kp_left" | "keypad4" => 86,
        "kp_5" | "kp_begin" | "keypad5" => 87,
        "kp_6" | "kp_right" | "keypad6" => 88,
        "kp_7" | "kp_home" | "keypad7" => 89,
        "kp_8" | "kp_up" | "keypad8" => 91,
        "kp_9" | "kp_prior" | "keypad9" => 92,
        "linefeed" => 36,
        "prior" | "page_up" => 116,
        "next" | "page_down" => 121,
        "forward_delete" | "kp_delete" => 117,
        "help" | "insert" => 114,
        "minus" => 27,
        "equal" => 24,
        "bracketleft" => 33,
        "bracketright" => 30,
        "backslash" => 42,
        "semicolon" => 41,
        "apostrophe" => 39,
        "comma" => 43,
        "period" => 47,
        "slash" => 44,
        "grave" => 50,
        _ => return KEYS.iter().find(|(n, _)| *n == k).map(|(_, c)| *c),
    };
    Some(extra)
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn interrupted_chords_release_only_posted_down_events() {
        let events = events(17, COMMAND | SHIFT);
        for (downs, expected) in [(0, vec![]), (1, vec![56, 56]), (2, vec![56, 55, 55, 56]), (3, vec![56, 55, 17, 17, 55, 56])] {
            let mut pressed = Pressed::default();
            let sent: Vec<_> = events
                .iter()
                .filter(|event| !event.release)
                .take(downs)
                .chain(events.iter().filter(|event| event.release))
                .filter(|event| pressed.record(**event))
                .collect();
            assert_eq!(sent.iter().map(|event| event.code).collect::<Vec<_>>(), expected);
            assert_eq!(sent.iter().filter(|event| event.down).count(), sent.iter().filter(|event| !event.down).count());
            assert!(sent.last().is_none_or(|event| event.flags == 0));
        }
    }

    #[test]
    fn named_key_coverage() {
        for (key, code) in [("F13", 105), ("f20", 90), ("KP_Enter", 76), ("KP_9", 92), ("Page_Down", 121), ("BackSpace", 51)] {
            assert_eq!(parse(key).unwrap().code, code);
        }
        assert_eq!(parse("KP_Enter").unwrap().flags, KEYPAD);
        assert!(parse("f21").is_none());
        assert!(parse("hyper+a").is_none());
    }

    #[test]
    fn punctuation_and_modifier_aliases() {
        assert_eq!(parse("ctrl+alt+Delete").unwrap().flags, CONTROL | OPTION);
        assert_eq!(parse("cmd++").unwrap(), Chord { code: 24, flags: COMMAND | SHIFT, character: Some('+'), modifiers: vec![55] });
        assert_eq!(parse("+").unwrap().code, 24);
        assert_eq!(parse("?").unwrap().code, 44);
        assert_eq!(parse("cmd+plus").unwrap().flags, COMMAND | SHIFT);
        assert_eq!(parse("question").unwrap().code, 44);
        let right = parse("Control_R+a").unwrap();
        assert_eq!(events_with_modifiers(right.code, right.flags, &right.modifiers)[0].code, 62);
        assert_eq!(parse("Super_L+Shift_L+t").unwrap().flags, COMMAND | SHIFT);
        assert_eq!(parse("Control_R").unwrap().code, 62);
    }

    #[test]
    fn layout_mapping_replaces_implicit_shift_but_preserves_explicit_modifiers() {
        let stroke = crate::text::Stroke { code: 30, shift: false, option: false };
        let mut chord = parse("cmd+plus").unwrap();
        chord.remap(stroke);
        let events = events_with_modifiers(chord.code, chord.flags, &chord.modifiers);
        assert_eq!(events.iter().map(|event| event.code).collect::<Vec<_>>(), [55, 30, 30, 55]);
        assert_eq!(events.iter().map(|event| event.flags).collect::<Vec<_>>(), [COMMAND, COMMAND, COMMAND, 0]);
        let mut explicit = parse("cmd+Shift_R+plus").unwrap();
        explicit.remap(stroke);
        let events = events_with_modifiers(explicit.code, explicit.flags, &explicit.modifiers);
        assert_eq!(events[0].code, 60);
        assert_eq!(events[2].flags, COMMAND | SHIFT);
        let mut option = parse("cmd+numbersign").unwrap();
        option.remap(crate::text::Stroke { code: 20, shift: false, option: true });
        assert_eq!(option.flags, COMMAND | OPTION);
    }

    #[test]
    fn letter_key_names_are_case_insensitive_before_layout_mapping() {
        let layout = std::collections::HashMap::from([
            ('z', crate::text::Stroke { code: 6, shift: false, option: false }),
            ('Z', crate::text::Stroke { code: 6, shift: true, option: false }),
        ]);
        let emitted = |name| {
            let mut chord = parse(name).unwrap();
            chord.remap(layout[&chord.character.unwrap()]);
            events_with_modifiers(chord.code, chord.flags, &chord.modifiers)
        };
        let plain = emitted("cmd+z");
        assert_eq!(emitted("cmd+Z"), plain);
        assert_eq!(plain.iter().map(|event| event.code).collect::<Vec<_>>(), [55, 6, 6, 55]);
        let shifted = emitted("cmd+Shift_R+z");
        assert_eq!(emitted("cmd+Shift_R+Z"), shifted);
        assert_eq!(shifted.iter().map(|event| event.code).collect::<Vec<_>>(), [60, 55, 6, 6, 55, 60]);
        assert_eq!(shifted[2].flags, COMMAND | SHIFT);
    }

    #[test]
    fn chords_press_and_release_modifiers_in_reverse_order() {
        let events = events(17, COMMAND | SHIFT);
        assert_eq!(events.iter().map(|e| e.code).collect::<Vec<_>>(), [56, 55, 17, 17, 55, 56]);
        assert_eq!(
            events.iter().map(|e| e.flags).collect::<Vec<_>>(),
            [SHIFT, SHIFT | COMMAND, SHIFT | COMMAND, SHIFT | COMMAND, SHIFT, 0]
        );
        assert!(events[..2].iter().all(|e| e.modifier && e.down && !e.release));
        assert!(events[3..].iter().all(|e| e.release));
    }

    #[test]
    fn standalone_modifier_is_a_flags_pair() {
        let events = events(62, 0);
        assert_eq!(events.len(), 2);
        assert_eq!(events[0].flags, CONTROL);
        assert_eq!(events[1].flags, 0);
        assert!(events.iter().all(|e| e.modifier));
    }
}