keyseq 0.8.0

Specify key chords using `Ctrl-A` short-hand
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
79
80
81
82
83
84
85
86
87
88
89
90

//! keyseq macros for winit library
use crate::Modifiers;
use ::winit::keyboard::ModifiersState;

/// Short hand notation describes a logical key chord as `(modifiers:`
/// [Modifiers]`, key: `[winit::keyboard::Key][key]`)`.
///
/// [key]: https://docs.rs/winit/latest/winit/keyboard/enum.Key.html
/// ```
/// use keyseq::{Modifiers, winit::lkey as key};
/// use winit::keyboard::Key;
///
/// assert_eq!(key! { a },          (Modifiers::NONE,    Key::Character('a')));
/// assert_eq!(key! { Ctrl-a },     (Modifiers::CONTROL, Key::Character('a')));
/// assert_eq!(key! { Alt-a },      (Modifiers::ALT,     Key::Character('a')));
/// assert_eq!(key! { Shift-a },    (Modifiers::SHIFT,   Key::Character('a')));
/// assert_eq!(key! { Super-a },    (Modifiers::SUPER,   Key::Character('a')));
/// assert_eq!(key! { Ctrl-Alt-; }, (Modifiers::ALT |
///                                 Modifiers::CONTROL, Key::Character(';')));
/// ```
///
/// This does have a limitation though because the macro does not do reverse look
/// ups from character to name.
///
/// ```compile_fail
/// # use keyseq::{Modifiers, winit::lkey};
/// use winit::keyboard::Key;
/// assert_eq!(lkey! { Ctrl-Semicolon }, (Modifiers::CONTROL, Key::Character(';')));
/// ```
pub use keyseq_macros::winit_lkey as lkey;

/// Short hand notation describes a sequence of logical key chords as `[(modifiers:
/// `[Modifiers]`, key: `[winit::keyboard::Key][key]`)]`.
///
/// [key]: https://docs.rs/winit/latest/winit/keyboard/enum.Key.html
pub use keyseq_macros::winit_lkeyseq as lkeyseq;

/// Short hand notation describes a physical key chord as `(modifiers:`
/// [Modifiers]`, key_code: `[winit::keyboard::KeyCode][keycode]`)`.
///
/// [keycode]: https://docs.rs/winit/latest/winit/keyboard/enum.KeyCode.html
/// ```
/// use keyseq::{Modifiers, winit::pkey as pkey};
/// use winit::keyboard::KeyCode;
/// assert_eq!(pkey! { A }, (Modifiers::NONE, KeyCode::KeyA));
/// ```
pub use keyseq_macros::winit_pkey as pkey;
/// Short hand notation describes a sequence of physical key chords as `[(modifiers:`
/// [Modifiers]`, key_code: `[winit::keyboard::KeyCode][keycode]`)]`.
///
/// [keycode]: https://docs.rs/winit/latest/winit/keyboard/enum.KeyCode.html
pub use keyseq_macros::winit_pkeyseq as pkeyseq;

impl From<ModifiersState> for Modifiers {
    fn from(mods: ModifiersState) -> Self {
        let mut r = Modifiers::NONE;
        if mods.contains(ModifiersState::SHIFT) {
            r |= Modifiers::SHIFT;
        }
        if mods.contains(ModifiersState::CONTROL) {
            r |= Modifiers::CONTROL;
        }
        if mods.contains(ModifiersState::ALT) {
            r |= Modifiers::ALT;
        }
        if mods.contains(ModifiersState::SUPER) {
            r |= Modifiers::SUPER;
        }
        r
    }
}

impl From<Modifiers> for ModifiersState {
    fn from(mods: Modifiers) -> Self {
        let mut r = ModifiersState::empty();
        if mods.contains(Modifiers::CONTROL) {
            r |= ModifiersState::CONTROL;
        }
        if mods.contains(Modifiers::ALT) {
            r |= ModifiersState::ALT;
        }
        if mods.contains(Modifiers::SHIFT) {
            r |= ModifiersState::SHIFT;
        }
        if mods.contains(Modifiers::SUPER) {
            r |= ModifiersState::SUPER;
        }
        r
    }
}