ashlar-native 0.2.0

Native OS features behind one API: dialogs, menus, clipboard, power, notifications, secrets
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78

//! Menu key equivalents. Shortcut text is parsed by [`ashlar_command::shortcut::Chord`] (the one
//! parser) and [`to_muda`] maps a chord onto the menu backend's accelerator. `Mod` is ⌘ on macOS
//! and Ctrl elsewhere.

use ashlar_command::shortcut::{Chord, Mods};

/// Deprecated: accelerators are [`Chord`]s (`Chord::parse`, `Chord::is_menu_safe`,
/// `Chord::portable`).
#[deprecated(note = "use ashlar_command::shortcut::Chord")]
pub type Accelerator = Chord;

/// Deprecated: modifiers are [`Mods`] (`command` is `Mod`).
#[deprecated(note = "use ashlar_command::shortcut::Mods")]
pub type Modifiers = Mods;

/// Deprecated: use [`ashlar_command::menu::menu_chord`].
#[deprecated(note = "use ashlar_command::menu::menu_chord")]
pub fn menu_accelerator(text: &str) -> Option<Chord> {
    ashlar_command::menu::menu_chord(text)
}

/// The menu backend's accelerator for `chord`; `None` for keys it cannot show.
#[cfg(any(target_os = "macos", target_os = "windows"))]
pub fn to_muda(chord: &Chord) -> Option<muda::accelerator::Accelerator> {
    use muda::accelerator::{CMD_OR_CTRL, Code, Modifiers as M};
    let code: Code = crate::key_code::code_name(chord)?.parse().ok()?;
    let mut mods = M::empty();
    for (on, m) in [(chord.mods.command, CMD_OR_CTRL), (chord.mods.ctrl, M::CONTROL), (chord.mods.alt, M::ALT), (chord.mods.shift, M::SHIFT)] {
        if on {
            mods |= m;
        }
    }
    Some(muda::accelerator::Accelerator::new(mods, code))
}

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

    fn chord(text: &str) -> Chord {
        Chord::parse(text).unwrap_or_else(|e| panic!("{e}"))
    }

    #[test]
    fn chords_map_to_physical_key_codes() {
        let cases = [
            ("Mod+Shift+S", "KeyS"),
            ("Mod+0", "Digit0"),
            ("Mod++", "Equal"),
            ("Mod+=", "Equal"),
            ("Mod+Alt+;", "Semicolon"),
            ("F5", "F5"),
            ("Mod+Left", "ArrowLeft"),
            ("Option+Return", "Enter"),
            ("Mod+`", "Backquote"),
            ("Mod+PageDown", "PageDown"),
            ("⌘⇧[", "BracketLeft"),
        ];
        for (text, code) in cases {
            assert_eq!(crate::key_code::code_name(&chord(text)).as_deref(), Some(code), "{text}");
        }
        assert_eq!(crate::key_code::code_name(&chord("Mod+é")), None);
    }

    #[cfg(any(target_os = "macos", target_os = "windows"))]
    #[test]
    fn chords_become_muda_accelerators() {
        use muda::accelerator::{Accelerator as A, CMD_OR_CTRL, Code, Modifiers as M};
        assert_eq!(to_muda(&chord("Mod+Shift+S")), Some(A::new(CMD_OR_CTRL | M::SHIFT, Code::KeyS)));
        assert_eq!(to_muda(&chord("Ctrl+Alt+Delete")), Some(A::new(M::CONTROL | M::ALT, Code::Delete)));
        assert_eq!(to_muda(&chord("F12")), Some(A::new(M::empty(), Code::F12)));
        // Every chord the parser accepts either maps or is refused; none panics.
        for text in ["Mod+F24", "Mod+Insert", "Mod+Space", "Mod+Tab", "Mod+Escape", "Mod+/", "Mod+'", "Mod+\\", "Mod+,", "Mod+."] {
            assert!(to_muda(&chord(text)).is_some(), "{text}");
        }
        assert!(to_muda(&chord("Mod+é")).is_none());
    }
}