Skip to main content

ferroui_base/input/raw/
raw_key_event_args.rs

1use super::raw_input_event_args::raw_input_event_args;
2use super::RawInputEventArgs;
3use crate::input::{IInputDevice, IInputRoot, Key, KeyDeviceType, PhysicalKey, RawInputModifiers};
4use std::cell::{Cell, RefCell};
5use std::rc::Rc;
6
7/// The kinds of raw key events.
8#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
9pub enum RawKeyEventType {
10    KeyDown,
11    KeyUp,
12}
13
14/// A raw keyboard event.
15pub struct RawKeyEventArgs {
16    base: RawInputEventArgs,
17    key: Cell<Key>,
18    modifiers: Cell<RawInputModifiers>,
19    type_: Cell<RawKeyEventType>,
20    physical_key: Cell<PhysicalKey>,
21    key_device_type: Cell<KeyDeviceType>,
22    key_symbol: RefCell<Option<String>>,
23}
24
25raw_input_event_args!(RawKeyEventArgs: RawInputEventArgs);
26
27impl RawKeyEventArgs {
28    /// Creates raw key event args.
29    #[allow(clippy::too_many_arguments)]
30    pub fn new(
31        device: Rc<dyn IInputDevice>,
32        timestamp: u64,
33        root: Rc<dyn IInputRoot>,
34        type_: RawKeyEventType,
35        key: Key,
36        modifiers: RawInputModifiers,
37        physical_key: PhysicalKey,
38        key_symbol: Option<String>,
39        key_device_type: KeyDeviceType,
40    ) -> Self {
41        Self {
42            base: RawInputEventArgs::new(device, timestamp, root),
43            key: Cell::new(key),
44            modifiers: Cell::new(modifiers),
45            type_: Cell::new(type_),
46            physical_key: Cell::new(physical_key),
47            key_device_type: Cell::new(key_device_type),
48            key_symbol: RefCell::new(key_symbol),
49        }
50    }
51
52    #[inline]
53    pub fn key(&self) -> Key {
54        self.key.get()
55    }
56
57    pub fn set_key(&self, value: Key) {
58        self.key.set(value)
59    }
60
61    #[inline]
62    pub fn modifiers(&self) -> RawInputModifiers {
63        self.modifiers.get()
64    }
65
66    pub fn set_modifiers(&self, value: RawInputModifiers) {
67        self.modifiers.set(value)
68    }
69
70    #[inline]
71    pub fn type_(&self) -> RawKeyEventType {
72        self.type_.get()
73    }
74
75    pub fn set_type(&self, value: RawKeyEventType) {
76        self.type_.set(value)
77    }
78
79    #[inline]
80    pub fn physical_key(&self) -> PhysicalKey {
81        self.physical_key.get()
82    }
83
84    pub fn set_physical_key(&self, value: PhysicalKey) {
85        self.physical_key.set(value)
86    }
87
88    #[inline]
89    pub fn key_device_type(&self) -> KeyDeviceType {
90        self.key_device_type.get()
91    }
92
93    pub fn set_key_device_type(&self, value: KeyDeviceType) {
94        self.key_device_type.set(value)
95    }
96
97    pub fn key_symbol(&self) -> Option<String> {
98        self.key_symbol.borrow().clone()
99    }
100
101    pub fn set_key_symbol(&self, value: Option<String>) {
102        *self.key_symbol.borrow_mut() = value;
103    }
104}