lumecs 0.0.1

Experimental GUI backed by Bevy ECS + usual suspects
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
91
92
93
94
95
96
97

use std::ops::Add;

use winit::keyboard::KeyCode;
use winit::keyboard::ModifiersState;

pub const ALT: Modifier = Modifier(ModifiersState::ALT);
pub const CONTROL: Modifier = Modifier(ModifiersState::CONTROL);
pub const CTRL: Modifier = Modifier(ModifiersState::CONTROL);
pub const META: Modifier = Modifier(ModifiersState::SUPER);
pub const SHIFT: Modifier = Modifier(ModifiersState::SHIFT);
pub const SUPER: Modifier = Modifier(ModifiersState::SUPER);

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct Modifier(ModifiersState);

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct Key {
    key_code: KeyCode,
    modifiers: ModifiersState,
}

impl Add<Modifier> for Key {
    type Output = Key;

    fn add(mut self, rhs: Modifier) -> Self::Output {
        self.modifiers |= rhs.0;
        self
    }
}

impl Add<KeyCode> for Modifier {
    type Output = Key;

    fn add(self, key_code: KeyCode) -> Self::Output {
        Key {
            key_code,
            modifiers: self.0,
        }
    }
}

impl Key {
    pub fn with_shift(mut self) -> Self {
        self.modifiers |= ModifiersState::SHIFT;
        self
    }

    pub fn with_control(mut self) -> Self {
        self.modifiers |= ModifiersState::CONTROL;
        self
    }

    pub fn with_alt(mut self) -> Self {
        self.modifiers |= ModifiersState::ALT;
        self
    }

    pub fn with_super(mut self) -> Self {
        self.modifiers |= ModifiersState::SUPER;
        self
    }

    pub(crate) fn with_modifiers(mut self, modifiers: ModifiersState) -> Self {
        self.modifiers = modifiers;
        self
    }
}

impl From<KeyCode> for Key {
    fn from(key_code: KeyCode) -> Self {
        Self {
            key_code,
            modifiers: ModifiersState::default(),
        }
    }
}

impl From<(KeyCode, ModifiersState)> for Key {
    fn from((key_code, modifiers): (KeyCode, ModifiersState)) -> Self {
        Self {
            key_code,
            modifiers,
        }
    }
}

pub mod prelude {
    pub use super::ALT;
    pub use super::CONTROL;
    pub use super::CTRL;
    pub use super::Key;
    pub use super::META;
    pub use super::SHIFT;
    pub use super::SUPER;

    pub use winit::keyboard::KeyCode;
}