3 // Copyright (C) 2014 Thomas Geymayer <tomgey@gmail.com>
5 // This library is free software; you can redistribute it and/or
6 // modify it under the terms of the GNU Library General Public
7 // License as published by the Free Software Foundation; either
8 // version 2 of the License, or (at your option) any later version.
10 // This library is distributed in the hope that it will be useful,
11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 // Library General Public License for more details.
15 // You should have received a copy of the GNU Library General Public
16 // License along with this library; if not, write to the Free Software
17 // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 #include "KeyboardEvent.hxx"
22 #include <osgGA/GUIEventAdapter>
24 #include <boost/version.hpp>
25 #if BOOST_VERSION >= 104800
26 # include <boost/container/flat_map.hpp>
27 # include <boost/container/flat_set.hpp>
39 typedef osgGA::GUIEventAdapter EA;
41 // TODO check Win/Mac keycode for altgr/ISO Level3 Shift
42 const uint32_t KEY_AltGraph = 0xfe03;
44 //----------------------------------------------------------------------------
45 KeyboardEvent::KeyboardEvent():
49 _location(DOM_KEY_LOCATION_STANDARD)
54 //----------------------------------------------------------------------------
55 KeyboardEvent::KeyboardEvent(const osgGA::GUIEventAdapter& ea):
58 _unmodified_key(ea.getUnmodifiedKey()),
60 _location(DOM_KEY_LOCATION_STANDARD)
62 if( ea.getEventType() == EA::KEYDOWN )
64 else if( ea.getEventType() == EA::KEYUP )
67 // // TODO what to do with wrong event type?
70 //----------------------------------------------------------------------------
71 void KeyboardEvent::setKey(uint32_t key)
77 //----------------------------------------------------------------------------
78 void KeyboardEvent::setUnmodifiedKey(uint32_t key)
81 _unmodified_key = key;
84 //----------------------------------------------------------------------------
85 void KeyboardEvent::setRepeat(bool repeat)
90 //----------------------------------------------------------------------------
91 std::string KeyboardEvent::key() const
96 // We need to make sure only valid const char* pointers are passed. The best
97 // way is just to use string constants.
98 // Use an empty string ("") to just use the value reported by the operating
100 typedef std::pair<const char*, uint8_t> InternalKeyInfo;
102 #if BOOST_VERSION >= 104800
103 typedef boost::container::flat_map<int, InternalKeyInfo> InternalKeyMap;
104 typedef boost::container::flat_set<int> KeyList;
106 # warning "Use Boost >= 1.48 for faster and more memory efficient key lookup"
107 typedef std::map<int, InternalKeyInfo> InternalKeyMap;
108 typedef std::set<int> KeyList;
111 static InternalKeyMap key_map;
112 static KeyList num_pad_keys;
114 if( key_map.empty() )
116 const uint8_t S = DOM_KEY_LOCATION_STANDARD,
117 L = DOM_KEY_LOCATION_LEFT,
118 R = DOM_KEY_LOCATION_RIGHT,
119 N = DOM_KEY_LOCATION_NUMPAD;
121 key_map[ EA::KEY_BackSpace ] = std::make_pair("Backspace", S);
122 key_map[ EA::KEY_Tab ] = std::make_pair("Tab", S);
123 key_map[ EA::KEY_Linefeed ] = std::make_pair("Linefeed", S);
124 key_map[ EA::KEY_Clear ] = std::make_pair("Clear", S);
125 key_map[ EA::KEY_Return ] = std::make_pair("Enter", S);
126 key_map[ EA::KEY_Pause ] = std::make_pair("Pause", S);
127 key_map[ EA::KEY_Scroll_Lock ] = std::make_pair("ScrollLock", S);
128 key_map[ EA::KEY_Sys_Req ] = std::make_pair("SystemRequest", S);
129 key_map[ EA::KEY_Escape ] = std::make_pair("Escape", S);
130 key_map[ EA::KEY_Delete ] = std::make_pair("Delete", S);
132 key_map[ EA::KEY_Home ] = std::make_pair("Home", S);
133 key_map[ EA::KEY_Left ] = std::make_pair("Left", S);
134 key_map[ EA::KEY_Up ] = std::make_pair("Up", S);
135 key_map[ EA::KEY_Right ] = std::make_pair("Right", S);
136 key_map[ EA::KEY_Down ] = std::make_pair("Down", S);
137 key_map[ EA::KEY_Page_Up ] = std::make_pair("PageUp", S);
138 key_map[ EA::KEY_Page_Down ] = std::make_pair("PageDown", S);
139 key_map[ EA::KEY_End ] = std::make_pair("End", S);
140 key_map[ EA::KEY_Begin ] = std::make_pair("Begin", S);
142 key_map[ EA::KEY_Select ] = std::make_pair("Select", S);
143 key_map[ EA::KEY_Print ] = std::make_pair("PrintScreen", S);
144 key_map[ EA::KEY_Execute ] = std::make_pair("Execute", S);
145 key_map[ EA::KEY_Insert ] = std::make_pair("Insert", S);
146 key_map[ EA::KEY_Undo ] = std::make_pair("Undo", S);
147 key_map[ EA::KEY_Redo ] = std::make_pair("Redo", S);
148 key_map[ EA::KEY_Menu ] = std::make_pair("ContextMenu", S);
149 key_map[ EA::KEY_Find ] = std::make_pair("Find", S);
150 key_map[ EA::KEY_Cancel ] = std::make_pair("Cancel", S);
151 key_map[ EA::KEY_Help ] = std::make_pair("Help", S);
152 key_map[ EA::KEY_Break ] = std::make_pair("Break", S);
153 key_map[ EA::KEY_Mode_switch ] = std::make_pair("ModeChange", S);
154 key_map[ EA::KEY_Num_Lock ] = std::make_pair("NumLock", S);
156 key_map[ EA::KEY_KP_Space ] = std::make_pair(" ", N);
157 key_map[ EA::KEY_KP_Tab ] = std::make_pair("Tab", N);
158 key_map[ EA::KEY_KP_Enter ] = std::make_pair("Enter", N);
159 key_map[ EA::KEY_KP_F1 ] = std::make_pair("F1", N);
160 key_map[ EA::KEY_KP_F2 ] = std::make_pair("F2", N);
161 key_map[ EA::KEY_KP_F3 ] = std::make_pair("F3", N);
162 key_map[ EA::KEY_KP_F4 ] = std::make_pair("F4", N);
163 key_map[ EA::KEY_KP_Home ] = std::make_pair("Home", N);
164 key_map[ EA::KEY_KP_Left ] = std::make_pair("Left", N);
165 key_map[ EA::KEY_KP_Up ] = std::make_pair("Up", N);
166 key_map[ EA::KEY_KP_Right ] = std::make_pair("Right", N);
167 key_map[ EA::KEY_KP_Down ] = std::make_pair("Down", N);
168 key_map[ EA::KEY_KP_Page_Up ] = std::make_pair("PageUp", N);
169 key_map[ EA::KEY_KP_Page_Down ] = std::make_pair("PageDown", N);
170 key_map[ EA::KEY_KP_End ] = std::make_pair("End", N);
171 key_map[ EA::KEY_KP_Begin ] = std::make_pair("Begin", N);
172 key_map[ EA::KEY_KP_Insert ] = std::make_pair("Insert", N);
173 key_map[ EA::KEY_KP_Delete ] = std::make_pair("Delete", N);
174 key_map[ EA::KEY_KP_Equal ] = std::make_pair("=", N);
175 key_map[ EA::KEY_KP_Multiply ] = std::make_pair("*", N);
176 key_map[ EA::KEY_KP_Add ] = std::make_pair("+", N);
177 key_map[ EA::KEY_KP_Separator ] = std::make_pair("", N);
178 key_map[ EA::KEY_KP_Subtract ] = std::make_pair("-", N);
179 key_map[ EA::KEY_KP_Decimal ] = std::make_pair("", N);
180 key_map[ EA::KEY_KP_Divide ] = std::make_pair("/", N);
182 key_map[ EA::KEY_KP_0 ] = std::make_pair("0", N);
183 key_map[ EA::KEY_KP_1 ] = std::make_pair("1", N);
184 key_map[ EA::KEY_KP_2 ] = std::make_pair("2", N);
185 key_map[ EA::KEY_KP_3 ] = std::make_pair("3", N);
186 key_map[ EA::KEY_KP_4 ] = std::make_pair("4", N);
187 key_map[ EA::KEY_KP_5 ] = std::make_pair("5", N);
188 key_map[ EA::KEY_KP_6 ] = std::make_pair("6", N);
189 key_map[ EA::KEY_KP_7 ] = std::make_pair("7", N);
190 key_map[ EA::KEY_KP_8 ] = std::make_pair("8", N);
191 key_map[ EA::KEY_KP_9 ] = std::make_pair("9", N);
193 key_map[ EA::KEY_F1 ] = std::make_pair("F1", S);
194 key_map[ EA::KEY_F2 ] = std::make_pair("F2", S);
195 key_map[ EA::KEY_F3 ] = std::make_pair("F3", S);
196 key_map[ EA::KEY_F4 ] = std::make_pair("F4", S);
197 key_map[ EA::KEY_F5 ] = std::make_pair("F5", S);
198 key_map[ EA::KEY_F6 ] = std::make_pair("F6", S);
199 key_map[ EA::KEY_F7 ] = std::make_pair("F7", S);
200 key_map[ EA::KEY_F8 ] = std::make_pair("F8", S);
201 key_map[ EA::KEY_F9 ] = std::make_pair("F9", S);
202 key_map[ EA::KEY_F10 ] = std::make_pair("F10", S);
203 key_map[ EA::KEY_F11 ] = std::make_pair("F11", S);
204 key_map[ EA::KEY_F12 ] = std::make_pair("F12", S);
205 key_map[ EA::KEY_F13 ] = std::make_pair("F13", S);
206 key_map[ EA::KEY_F14 ] = std::make_pair("F14", S);
207 key_map[ EA::KEY_F15 ] = std::make_pair("F15", S);
208 key_map[ EA::KEY_F16 ] = std::make_pair("F16", S);
209 key_map[ EA::KEY_F17 ] = std::make_pair("F17", S);
210 key_map[ EA::KEY_F18 ] = std::make_pair("F18", S);
211 key_map[ EA::KEY_F19 ] = std::make_pair("F19", S);
212 key_map[ EA::KEY_F20 ] = std::make_pair("F20", S);
213 key_map[ EA::KEY_F21 ] = std::make_pair("F21", S);
214 key_map[ EA::KEY_F22 ] = std::make_pair("F22", S);
215 key_map[ EA::KEY_F23 ] = std::make_pair("F23", S);
216 key_map[ EA::KEY_F24 ] = std::make_pair("F24", S);
217 key_map[ EA::KEY_F25 ] = std::make_pair("F25", S);
218 key_map[ EA::KEY_F26 ] = std::make_pair("F26", S);
219 key_map[ EA::KEY_F27 ] = std::make_pair("F27", S);
220 key_map[ EA::KEY_F28 ] = std::make_pair("F28", S);
221 key_map[ EA::KEY_F29 ] = std::make_pair("F29", S);
222 key_map[ EA::KEY_F30 ] = std::make_pair("F30", S);
223 key_map[ EA::KEY_F31 ] = std::make_pair("F31", S);
224 key_map[ EA::KEY_F32 ] = std::make_pair("F32", S);
225 key_map[ EA::KEY_F33 ] = std::make_pair("F33", S);
226 key_map[ EA::KEY_F34 ] = std::make_pair("F34", S);
227 key_map[ EA::KEY_F35 ] = std::make_pair("F35", S);
229 key_map[ KEY_AltGraph ] = std::make_pair("AltGraph", S);
230 key_map[ EA::KEY_Shift_L ] = std::make_pair("Shift", L);
231 key_map[ EA::KEY_Shift_R ] = std::make_pair("Shift", R);
232 key_map[ EA::KEY_Control_L ] = std::make_pair("Control", L);
233 key_map[ EA::KEY_Control_R ] = std::make_pair("Control", R);
234 key_map[ EA::KEY_Caps_Lock ] = std::make_pair("CapsLock", S);
235 key_map[ EA::KEY_Shift_Lock ] = std::make_pair("ShiftLock", S);
236 key_map[ EA::KEY_Meta_L ] = std::make_pair("Meta", L);
237 key_map[ EA::KEY_Meta_R ] = std::make_pair("Meta", R);
238 key_map[ EA::KEY_Alt_L ] = std::make_pair("Alt", L);
239 key_map[ EA::KEY_Alt_R ] = std::make_pair("Alt", R);
240 key_map[ EA::KEY_Super_L ] = std::make_pair("Super", L);
241 key_map[ EA::KEY_Super_R ] = std::make_pair("Super", R);
242 key_map[ EA::KEY_Hyper_L ] = std::make_pair("Hyper", L);
243 key_map[ EA::KEY_Hyper_R ] = std::make_pair("Hyper", R);
245 num_pad_keys.insert(EA::KEY_KP_Home );
246 num_pad_keys.insert(EA::KEY_KP_Left );
247 num_pad_keys.insert(EA::KEY_KP_Up );
248 num_pad_keys.insert(EA::KEY_KP_Right );
249 num_pad_keys.insert(EA::KEY_KP_Down );
250 num_pad_keys.insert(EA::KEY_KP_Page_Up );
251 num_pad_keys.insert(EA::KEY_KP_Page_Down);
252 num_pad_keys.insert(EA::KEY_KP_End );
253 num_pad_keys.insert(EA::KEY_KP_Begin );
254 num_pad_keys.insert(EA::KEY_KP_Insert );
255 num_pad_keys.insert(EA::KEY_KP_Delete );
258 _location = DOM_KEY_LOCATION_STANDARD;
260 InternalKeyMap::const_iterator it = key_map.find(_key);
261 if( it != key_map.end())
263 _name = it->second.first;
264 _location = it->second.second;
267 // Empty or no mapping -> convert UTF-32 key value to UTF-8
270 if( !utf8::internal::is_code_point_valid(_key) )
271 _name = "Unidentified";
273 utf8::unchecked::append(_key, std::back_inserter(_name));
276 // Keys on the numpad with NumLock enabled are reported just like their
277 // equivalent keys in the standard key block. Using the unmodified key value
278 // we can detect such keys and set the location accordingly.
279 if( num_pad_keys.find(_unmodified_key) != num_pad_keys.end() )
280 _location = DOM_KEY_LOCATION_NUMPAD;
285 //----------------------------------------------------------------------------
286 KeyboardEvent::DOMKeyLocation KeyboardEvent::location() const
288 key(); // ensure location is up-to-date
289 return static_cast<DOMKeyLocation>(_location);
292 //----------------------------------------------------------------------------
293 bool KeyboardEvent::isModifier() const
295 return ( _key >= EA::KEY_Shift_L
296 && _key <= EA::KEY_Hyper_R
298 || _key == KEY_AltGraph;
301 } // namespace canvas
302 } // namespace simgear