input/
button.rs

1use crate::{Button, Event, Input};
2
3/// Stores button state.
4#[derive(Copy, Clone, Deserialize, Serialize, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
5pub enum ButtonState {
6    /// Button was pressed.
7    Press,
8    /// Button was released.
9    Release,
10}
11
12/// Button arguments.
13#[derive(Copy, Clone, Deserialize, Serialize, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
14pub struct ButtonArgs {
15    /// New state of the button.
16    pub state: ButtonState,
17    /// The button that changed state.
18    pub button: Button,
19    /// An optional scancode that tells the physical layout of a keyboard key.
20    /// For other devices than keyboard, this is set to `None`.
21    ///
22    /// Scancode follows SDL (https://wiki.libsdl.org/SDL_Scancode).
23    ///
24    /// This is stored here to make `Button` equality check work with keyboard layouts.
25    ///
26    /// Some window backends might not support scancodes.
27    /// To test a window backend, use https://github.com/PistonDevelopers/piston-examples/tree/master/user_input
28    pub scancode: Option<i32>,
29}
30
31/// Changed button state.
32pub trait ButtonEvent: Sized {
33    /// Creates a button event.
34    ///
35    /// Preserves time stamp from original input event, if any.
36    fn from_button_args(args: ButtonArgs, old_event: &Self) -> Option<Self>;
37    /// Calls closure if this is a button event.
38    fn button<U, F>(&self, f: F) -> Option<U>
39    where
40        F: FnMut(ButtonArgs) -> U;
41    /// Returns button arguments.
42    fn button_args(&self) -> Option<ButtonArgs> {
43        self.button(|args| args)
44    }
45}
46
47impl ButtonEvent for Event {
48    fn from_button_args(args: ButtonArgs, old_event: &Self) -> Option<Self> {
49        let timestamp = if let Event::Input(_, x) = old_event {
50            *x
51        } else {
52            None
53        };
54        Some(Event::Input(Input::Button(args), timestamp))
55    }
56    fn button<U, F>(&self, mut f: F) -> Option<U>
57    where
58        F: FnMut(ButtonArgs) -> U,
59    {
60        match *self {
61            Event::Input(Input::Button(args), _) => Some(f(args)),
62            _ => None,
63        }
64    }
65}
66
67/// The press of a button.
68pub trait PressEvent: Sized {
69    /// Creates a press event.
70    ///
71    /// Preserves scancode from original button event, if any.
72    /// Preserves time stamp from original input event, if any.
73    fn from_button(button: Button, old_event: &Self) -> Option<Self>;
74    /// Calls closure if this is a press event.
75    fn press<U, F>(&self, f: F) -> Option<U>
76    where
77        F: FnMut(Button) -> U;
78    /// Returns press arguments.
79    fn press_args(&self) -> Option<Button> {
80        self.press(|button| button)
81    }
82}
83
84impl<T> PressEvent for T
85where
86    T: ButtonEvent,
87{
88    fn from_button(button: Button, old_event: &Self) -> Option<Self> {
89        if let Some(mut args) = old_event.button_args() {
90            args.state = ButtonState::Press;
91            args.button = button;
92            ButtonEvent::from_button_args(args, old_event)
93        } else {
94            ButtonEvent::from_button_args(
95                ButtonArgs {
96                    state: ButtonState::Press,
97                    button,
98                    scancode: None,
99                },
100                old_event,
101            )
102        }
103    }
104
105    fn press<U, F>(&self, mut f: F) -> Option<U>
106    where
107        F: FnMut(Button) -> U,
108    {
109        if let Some(ButtonArgs {
110            state: ButtonState::Press,
111            button,
112            ..
113        }) = self.button_args()
114        {
115            Some(f(button))
116        } else {
117            None
118        }
119    }
120}
121
122/// The release of a button.
123pub trait ReleaseEvent: Sized {
124    /// Creates a release event.
125    ///
126    /// Preserves scancode from original button event, if any.
127    /// Preserves time stamp from original input event, if any.
128    fn from_button(button: Button, old_event: &Self) -> Option<Self>;
129    /// Calls closure if this is a release event.
130    fn release<U, F>(&self, f: F) -> Option<U>
131    where
132        F: FnMut(Button) -> U;
133    /// Returns release arguments.
134    fn release_args(&self) -> Option<Button> {
135        self.release(|button| button)
136    }
137}
138
139impl<T> ReleaseEvent for T
140where
141    T: ButtonEvent,
142{
143    fn from_button(button: Button, old_event: &Self) -> Option<Self> {
144        if let Some(mut args) = old_event.button_args() {
145            args.state = ButtonState::Release;
146            args.button = button;
147            ButtonEvent::from_button_args(args, old_event)
148        } else {
149            ButtonEvent::from_button_args(
150                ButtonArgs {
151                    state: ButtonState::Release,
152                    button,
153                    scancode: None,
154                },
155                old_event,
156            )
157        }
158    }
159
160    fn release<U, F>(&self, mut f: F) -> Option<U>
161    where
162        F: FnMut(Button) -> U,
163    {
164        if let Some(ButtonArgs {
165            state: ButtonState::Release,
166            button,
167            ..
168        }) = self.button_args()
169        {
170            Some(f(button))
171        } else {
172            None
173        }
174    }
175}
176
177#[cfg(test)]
178mod tests {
179    use super::*;
180
181    #[test]
182    fn test_input_press() {
183        use super::super::{Button, Key};
184
185        let e: Event = ButtonArgs {
186            state: ButtonState::Press,
187            button: Key::S.into(),
188            scancode: None,
189        }
190        .into();
191        let button = Button::Keyboard(Key::A);
192        let x: Option<Event> = PressEvent::from_button(button, &e);
193        let y: Option<Event> = x
194            .clone()
195            .unwrap()
196            .press(|button| PressEvent::from_button(button, x.as_ref().unwrap()))
197            .unwrap();
198        assert_eq!(x, y);
199    }
200
201    #[test]
202    fn test_input_release() {
203        use super::super::{Button, Key};
204
205        let e: Event = ButtonArgs {
206            state: ButtonState::Release,
207            button: Key::S.into(),
208            scancode: None,
209        }
210        .into();
211        let button = Button::Keyboard(Key::A);
212        let x: Option<Event> = ReleaseEvent::from_button(button, &e);
213        let y: Option<Event> = x
214            .clone()
215            .unwrap()
216            .release(|button| ReleaseEvent::from_button(button, x.as_ref().unwrap()))
217            .unwrap();
218        assert_eq!(x, y);
219    }
220}
input/button.rs

input/
button.rs
