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
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
|
pub use super::generated_api::api::key::{
key::{
KeyModifier as ProtobufKeyModifier, MainKey as ProtobufMainKey,
NamedKey as ProtobufNamedKey,
},
Key as ProtobufKey,
};
use crate::data::{BareKey, KeyModifier, KeyWithModifier};
use std::collections::BTreeSet;
use std::convert::TryFrom;
impl TryFrom<ProtobufMainKey> for BareKey {
type Error = &'static str;
fn try_from(protobuf_main_key: ProtobufMainKey) -> Result<Self, &'static str> {
match protobuf_main_key {
ProtobufMainKey::Char(character) => Ok(BareKey::Char(char_index_to_char(character))),
ProtobufMainKey::Key(key_index) => {
let key = ProtobufNamedKey::from_i32(key_index).ok_or("invalid_key")?;
Ok(named_key_to_bare_key(key))
},
}
}
}
impl TryFrom<BareKey> for ProtobufMainKey {
type Error = &'static str;
fn try_from(bare_key: BareKey) -> Result<Self, &'static str> {
match bare_key {
BareKey::PageDown => Ok(ProtobufMainKey::Key(ProtobufNamedKey::PageDown as i32)),
BareKey::PageUp => Ok(ProtobufMainKey::Key(ProtobufNamedKey::PageUp as i32)),
BareKey::Left => Ok(ProtobufMainKey::Key(ProtobufNamedKey::LeftArrow as i32)),
BareKey::Down => Ok(ProtobufMainKey::Key(ProtobufNamedKey::DownArrow as i32)),
BareKey::Up => Ok(ProtobufMainKey::Key(ProtobufNamedKey::UpArrow as i32)),
BareKey::Right => Ok(ProtobufMainKey::Key(ProtobufNamedKey::RightArrow as i32)),
BareKey::Home => Ok(ProtobufMainKey::Key(ProtobufNamedKey::Home as i32)),
BareKey::End => Ok(ProtobufMainKey::Key(ProtobufNamedKey::End as i32)),
BareKey::Backspace => Ok(ProtobufMainKey::Key(ProtobufNamedKey::Backspace as i32)),
BareKey::Delete => Ok(ProtobufMainKey::Key(ProtobufNamedKey::Delete as i32)),
BareKey::Insert => Ok(ProtobufMainKey::Key(ProtobufNamedKey::Insert as i32)),
BareKey::F(f_index) => fn_index_to_main_key(f_index),
BareKey::Char(character) => Ok(ProtobufMainKey::Char(character as i32)),
BareKey::Tab => Ok(ProtobufMainKey::Key(ProtobufNamedKey::Tab as i32)),
BareKey::Esc => Ok(ProtobufMainKey::Key(ProtobufNamedKey::Esc as i32)),
BareKey::Enter => Ok(ProtobufMainKey::Key(ProtobufNamedKey::Enter as i32)),
BareKey::CapsLock => Ok(ProtobufMainKey::Key(ProtobufNamedKey::CapsLock as i32)),
BareKey::ScrollLock => Ok(ProtobufMainKey::Key(ProtobufNamedKey::ScrollLock as i32)),
BareKey::NumLock => Ok(ProtobufMainKey::Key(ProtobufNamedKey::NumLock as i32)),
BareKey::PrintScreen => Ok(ProtobufMainKey::Key(ProtobufNamedKey::PrintScreen as i32)),
BareKey::Pause => Ok(ProtobufMainKey::Key(ProtobufNamedKey::Pause as i32)),
BareKey::Menu => Ok(ProtobufMainKey::Key(ProtobufNamedKey::Menu as i32)),
}
}
}
impl TryFrom<ProtobufKeyModifier> for KeyModifier {
type Error = &'static str;
fn try_from(protobuf_key_modifier: ProtobufKeyModifier) -> Result<Self, &'static str> {
match protobuf_key_modifier {
ProtobufKeyModifier::Ctrl => Ok(KeyModifier::Ctrl),
ProtobufKeyModifier::Alt => Ok(KeyModifier::Alt),
ProtobufKeyModifier::Shift => Ok(KeyModifier::Shift),
ProtobufKeyModifier::Super => Ok(KeyModifier::Super),
}
}
}
impl TryFrom<KeyModifier> for ProtobufKeyModifier {
type Error = &'static str;
fn try_from(key_modifier: KeyModifier) -> Result<Self, &'static str> {
match key_modifier {
KeyModifier::Ctrl => Ok(ProtobufKeyModifier::Ctrl),
KeyModifier::Alt => Ok(ProtobufKeyModifier::Alt),
KeyModifier::Shift => Ok(ProtobufKeyModifier::Shift),
KeyModifier::Super => Ok(ProtobufKeyModifier::Super),
}
}
}
impl TryFrom<ProtobufKey> for KeyWithModifier {
type Error = &'static str;
fn try_from(protobuf_key: ProtobufKey) -> Result<Self, &'static str> {
let bare_key = protobuf_key
.main_key
.ok_or("Key must have main_key")?
.try_into()?;
let mut key_modifiers = BTreeSet::new();
if let Some(main_modifier) = protobuf_key.modifier {
key_modifiers.insert(
ProtobufKeyModifier::from_i32(main_modifier)
.ok_or("invalid key modifier")?
.try_into()?,
);
}
for key_modifier in protobuf_key.additional_modifiers {
key_modifiers.insert(
ProtobufKeyModifier::from_i32(key_modifier)
.ok_or("invalid key modifier")?
.try_into()?,
);
}
Ok(KeyWithModifier {
bare_key,
key_modifiers,
})
}
}
impl TryFrom<KeyWithModifier> for ProtobufKey {
type Error = &'static str;
fn try_from(key_with_modifier: KeyWithModifier) -> Result<Self, &'static str> {
let mut modifiers: Vec<ProtobufKeyModifier> = vec![];
for key_modifier in key_with_modifier.key_modifiers {
modifiers.push(key_modifier.try_into()?);
}
Ok(ProtobufKey {
main_key: Some(key_with_modifier.bare_key.try_into()?),
modifier: modifiers.pop().map(|m| m as i32),
additional_modifiers: modifiers.into_iter().map(|m| m as i32).collect(),
})
}
}
fn fn_index_to_main_key(index: u8) -> Result<ProtobufMainKey, &'static str> {
match index {
1 => Ok(ProtobufMainKey::Key(ProtobufNamedKey::F1 as i32)),
2 => Ok(ProtobufMainKey::Key(ProtobufNamedKey::F2 as i32)),
3 => Ok(ProtobufMainKey::Key(ProtobufNamedKey::F3 as i32)),
4 => Ok(ProtobufMainKey::Key(ProtobufNamedKey::F4 as i32)),
5 => Ok(ProtobufMainKey::Key(ProtobufNamedKey::F5 as i32)),
6 => Ok(ProtobufMainKey::Key(ProtobufNamedKey::F6 as i32)),
7 => Ok(ProtobufMainKey::Key(ProtobufNamedKey::F7 as i32)),
8 => Ok(ProtobufMainKey::Key(ProtobufNamedKey::F8 as i32)),
9 => Ok(ProtobufMainKey::Key(ProtobufNamedKey::F9 as i32)),
10 => Ok(ProtobufMainKey::Key(ProtobufNamedKey::F10 as i32)),
11 => Ok(ProtobufMainKey::Key(ProtobufNamedKey::F11 as i32)),
12 => Ok(ProtobufMainKey::Key(ProtobufNamedKey::F12 as i32)),
_ => Err("Invalid key"),
}
}
fn char_index_to_char(char_index: i32) -> char {
char_index as u8 as char
}
fn named_key_to_bare_key(named_key: ProtobufNamedKey) -> BareKey {
match named_key {
ProtobufNamedKey::PageDown => BareKey::PageDown,
ProtobufNamedKey::PageUp => BareKey::PageUp,
ProtobufNamedKey::LeftArrow => BareKey::Left,
ProtobufNamedKey::DownArrow => BareKey::Down,
ProtobufNamedKey::UpArrow => BareKey::Up,
ProtobufNamedKey::RightArrow => BareKey::Right,
ProtobufNamedKey::Home => BareKey::Home,
ProtobufNamedKey::End => BareKey::End,
ProtobufNamedKey::Backspace => BareKey::Backspace,
ProtobufNamedKey::Delete => BareKey::Delete,
ProtobufNamedKey::Insert => BareKey::Insert,
ProtobufNamedKey::F1 => BareKey::F(1),
ProtobufNamedKey::F2 => BareKey::F(2),
ProtobufNamedKey::F3 => BareKey::F(3),
ProtobufNamedKey::F4 => BareKey::F(4),
ProtobufNamedKey::F5 => BareKey::F(5),
ProtobufNamedKey::F6 => BareKey::F(6),
ProtobufNamedKey::F7 => BareKey::F(7),
ProtobufNamedKey::F8 => BareKey::F(8),
ProtobufNamedKey::F9 => BareKey::F(9),
ProtobufNamedKey::F10 => BareKey::F(10),
ProtobufNamedKey::F11 => BareKey::F(11),
ProtobufNamedKey::F12 => BareKey::F(12),
ProtobufNamedKey::Tab => BareKey::Tab,
ProtobufNamedKey::Esc => BareKey::Esc,
ProtobufNamedKey::CapsLock => BareKey::CapsLock,
ProtobufNamedKey::ScrollLock => BareKey::ScrollLock,
ProtobufNamedKey::PrintScreen => BareKey::PrintScreen,
ProtobufNamedKey::Pause => BareKey::Pause,
ProtobufNamedKey::Menu => BareKey::Menu,
ProtobufNamedKey::NumLock => BareKey::NumLock,
ProtobufNamedKey::Enter => BareKey::Enter,
}
}
|
