25 |
25 |
26 #include "SDL_timer.h" |
26 #include "SDL_timer.h" |
27 #include "SDL_events.h" |
27 #include "SDL_events.h" |
28 #include "SDL_events_c.h" |
28 #include "SDL_events_c.h" |
29 #include "SDL_sysevents.h" |
29 #include "SDL_sysevents.h" |
30 #include "SDL_keynames.h" |
|
31 |
30 |
32 |
31 |
33 /* Global keyboard information */ |
32 /* Global keyboard information */ |
34 int SDL_TranslateUNICODE = 0; |
|
35 static int SDL_num_keyboards; |
33 static int SDL_num_keyboards; |
36 static int SDL_current_keyboard; |
34 static int SDL_current_keyboard; |
37 static SDL_Keyboard **SDL_keyboards; |
35 static SDL_Keyboard **SDL_keyboards; |
38 |
36 |
|
37 static SDLKey SDL_default_keymap[SDL_NUM_SCANCODES] = { |
|
38 0, 0, 0, 0, |
|
39 'a', |
|
40 'b', |
|
41 'c', |
|
42 'd', |
|
43 'e', |
|
44 'f', |
|
45 'g', |
|
46 'h', |
|
47 'i', |
|
48 'j', |
|
49 'k', |
|
50 'l', |
|
51 'm', |
|
52 'n', |
|
53 'o', |
|
54 'p', |
|
55 'q', |
|
56 'r', |
|
57 's', |
|
58 't', |
|
59 'u', |
|
60 'v', |
|
61 'w', |
|
62 'x', |
|
63 'y', |
|
64 'z', |
|
65 '1', |
|
66 '2', |
|
67 '3', |
|
68 '4', |
|
69 '5', |
|
70 '6', |
|
71 '7', |
|
72 '8', |
|
73 '9', |
|
74 '0', |
|
75 SDLK_RETURN, |
|
76 SDLK_ESCAPE, |
|
77 SDLK_BACKSPACE, |
|
78 SDLK_TAB, |
|
79 SDLK_SPACE, |
|
80 '-', |
|
81 '=', |
|
82 '[', |
|
83 ']', |
|
84 '\\', |
|
85 '#', |
|
86 ';', |
|
87 '\'', |
|
88 '`', |
|
89 ',', |
|
90 '.', |
|
91 '/', |
|
92 SDLK_CAPSLOCK, |
|
93 SDLK_F1, |
|
94 SDLK_F2, |
|
95 SDLK_F3, |
|
96 SDLK_F4, |
|
97 SDLK_F5, |
|
98 SDLK_F6, |
|
99 SDLK_F7, |
|
100 SDLK_F8, |
|
101 SDLK_F9, |
|
102 SDLK_F10, |
|
103 SDLK_F11, |
|
104 SDLK_F12, |
|
105 SDLK_PRINTSCREEN, |
|
106 SDLK_SCROLLLOCK, |
|
107 SDLK_PAUSE, |
|
108 SDLK_INSERT, |
|
109 SDLK_HOME, |
|
110 SDLK_PAGEUP, |
|
111 SDLK_DELETE, |
|
112 SDLK_END, |
|
113 SDLK_PAGEDOWN, |
|
114 SDLK_RIGHT, |
|
115 SDLK_LEFT, |
|
116 SDLK_DOWN, |
|
117 SDLK_UP, |
|
118 SDLK_NUMLOCKCLEAR, |
|
119 SDLK_KP_DIVIDE, |
|
120 SDLK_KP_MULTIPLY, |
|
121 SDLK_KP_MINUS, |
|
122 SDLK_KP_PLUS, |
|
123 SDLK_KP_ENTER, |
|
124 SDLK_KP_1, |
|
125 SDLK_KP_2, |
|
126 SDLK_KP_3, |
|
127 SDLK_KP_4, |
|
128 SDLK_KP_5, |
|
129 SDLK_KP_6, |
|
130 SDLK_KP_7, |
|
131 SDLK_KP_8, |
|
132 SDLK_KP_9, |
|
133 SDLK_KP_0, |
|
134 SDLK_KP_PERIOD, |
|
135 0, |
|
136 SDLK_APPLICATION, |
|
137 SDLK_POWER, |
|
138 SDLK_KP_EQUALS, |
|
139 SDLK_F13, |
|
140 SDLK_F14, |
|
141 SDLK_F15, |
|
142 SDLK_F16, |
|
143 SDLK_F17, |
|
144 SDLK_F18, |
|
145 SDLK_F19, |
|
146 SDLK_F20, |
|
147 SDLK_F21, |
|
148 SDLK_F22, |
|
149 SDLK_F23, |
|
150 SDLK_F24, |
|
151 SDLK_EXECUTE, |
|
152 SDLK_HELP, |
|
153 SDLK_MENU, |
|
154 SDLK_SELECT, |
|
155 SDLK_STOP, |
|
156 SDLK_AGAIN, |
|
157 SDLK_UNDO, |
|
158 SDLK_CUT, |
|
159 SDLK_COPY, |
|
160 SDLK_PASTE, |
|
161 SDLK_FIND, |
|
162 SDLK_MUTE, |
|
163 SDLK_VOLUMEUP, |
|
164 SDLK_VOLUMEDOWN, |
|
165 0, 0, 0, |
|
166 SDLK_KP_COMMA, |
|
167 SDLK_KP_EQUALSAS400, |
|
168 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
|
169 SDLK_ALTERASE, |
|
170 SDLK_SYSREQ, |
|
171 SDLK_CANCEL, |
|
172 SDLK_CLEAR, |
|
173 SDLK_PRIOR, |
|
174 SDLK_RETURN2, |
|
175 SDLK_SEPARATOR, |
|
176 SDLK_OUT, |
|
177 SDLK_OPER, |
|
178 SDLK_CLEARAGAIN, |
|
179 SDLK_CRSEL, |
|
180 SDLK_EXSEL, |
|
181 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
|
182 SDLK_KP_00, |
|
183 SDLK_KP_000, |
|
184 SDLK_THOUSANDSSEPARATOR, |
|
185 SDLK_DECIMALSEPARATOR, |
|
186 SDLK_CURRENCYUNIT, |
|
187 SDLK_CURRENCYSUBUNIT, |
|
188 SDLK_KP_LEFTPAREN, |
|
189 SDLK_KP_RIGHTPAREN, |
|
190 SDLK_KP_LEFTBRACE, |
|
191 SDLK_KP_RIGHTBRACE, |
|
192 SDLK_KP_TAB, |
|
193 SDLK_KP_BACKSPACE, |
|
194 SDLK_KP_A, |
|
195 SDLK_KP_B, |
|
196 SDLK_KP_C, |
|
197 SDLK_KP_D, |
|
198 SDLK_KP_E, |
|
199 SDLK_KP_F, |
|
200 SDLK_KP_XOR, |
|
201 SDLK_KP_POWER, |
|
202 SDLK_KP_PERCENT, |
|
203 SDLK_KP_LESS, |
|
204 SDLK_KP_GREATER, |
|
205 SDLK_KP_AMPERSAND, |
|
206 SDLK_KP_DBLAMPERSAND, |
|
207 SDLK_KP_VERTICALBAR, |
|
208 SDLK_KP_DBLVERTICALBAR, |
|
209 SDLK_KP_COLON, |
|
210 SDLK_KP_HASH, |
|
211 SDLK_KP_SPACE, |
|
212 SDLK_KP_AT, |
|
213 SDLK_KP_EXCLAM, |
|
214 SDLK_KP_MEMSTORE, |
|
215 SDLK_KP_MEMRECALL, |
|
216 SDLK_KP_MEMCLEAR, |
|
217 SDLK_KP_MEMADD, |
|
218 SDLK_KP_MEMSUBTRACT, |
|
219 SDLK_KP_MEMMULTIPLY, |
|
220 SDLK_KP_MEMDIVIDE, |
|
221 SDLK_KP_PLUSMINUS, |
|
222 SDLK_KP_CLEAR, |
|
223 SDLK_KP_CLEARENTRY, |
|
224 SDLK_KP_BINARY, |
|
225 SDLK_KP_OCTAL, |
|
226 SDLK_KP_DECIMAL, |
|
227 SDLK_KP_HEXADECIMAL, |
|
228 0, 0, |
|
229 SDLK_LCTRL, |
|
230 SDLK_LSHIFT, |
|
231 SDLK_LALT, |
|
232 SDLK_LGUI, |
|
233 SDLK_RCTRL, |
|
234 SDLK_RSHIFT, |
|
235 SDLK_RALT, |
|
236 SDLK_RGUI, |
|
237 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
|
238 SDLK_MODE, |
|
239 SDLK_AUDIONEXT, |
|
240 SDLK_AUDIOPREV, |
|
241 SDLK_AUDIOSTOP, |
|
242 SDLK_AUDIOPLAY, |
|
243 SDLK_AUDIOMUTE, |
|
244 SDLK_MEDIASELECT, |
|
245 SDLK_MAIL, |
|
246 SDLK_CALCULATOR, |
|
247 SDLK_COMPUTER, |
|
248 SDLK_AC_SEARCH, |
|
249 SDLK_AC_HOME, |
|
250 SDLK_AC_BACK, |
|
251 SDLK_AC_FORWARD, |
|
252 SDLK_AC_STOP, |
|
253 SDLK_AC_REFRESH, |
|
254 SDLK_AC_BOOKMARKS, |
|
255 SDLK_BRIGHTNESSDOWN, |
|
256 SDLK_BRIGHTNESSUP, |
|
257 SDLK_DISPLAYSWITCH, |
|
258 SDLK_KBDILLUMTOGGLE, |
|
259 SDLK_KBDILLUMDOWN, |
|
260 SDLK_KBDILLUMUP, |
|
261 SDLK_EJECT, |
|
262 SDLK_SLEEP, |
|
263 }; |
|
264 |
|
265 static const char *SDL_scancode_names[SDL_NUM_SCANCODES] = { |
|
266 NULL, NULL, NULL, NULL, |
|
267 "A", |
|
268 "B", |
|
269 "C", |
|
270 "D", |
|
271 "E", |
|
272 "F", |
|
273 "G", |
|
274 "H", |
|
275 "I", |
|
276 "J", |
|
277 "K", |
|
278 "L", |
|
279 "M", |
|
280 "N", |
|
281 "O", |
|
282 "P", |
|
283 "Q", |
|
284 "R", |
|
285 "S", |
|
286 "T", |
|
287 "U", |
|
288 "V", |
|
289 "W", |
|
290 "X", |
|
291 "Y", |
|
292 "Z", |
|
293 "1", |
|
294 "2", |
|
295 "3", |
|
296 "4", |
|
297 "5", |
|
298 "6", |
|
299 "7", |
|
300 "8", |
|
301 "9", |
|
302 "0", |
|
303 "Return", |
|
304 "Escape", |
|
305 "Backspace", |
|
306 "Tab", |
|
307 "Space", |
|
308 "-", |
|
309 "=", |
|
310 "[", |
|
311 "]", |
|
312 "\\", |
|
313 "#", |
|
314 ";", |
|
315 "'", |
|
316 "`", |
|
317 ",", |
|
318 ".", |
|
319 "/", |
|
320 "CapsLock", |
|
321 "F1", |
|
322 "F2", |
|
323 "F3", |
|
324 "F4", |
|
325 "F5", |
|
326 "F6", |
|
327 "F7", |
|
328 "F8", |
|
329 "F9", |
|
330 "F10", |
|
331 "F11", |
|
332 "F12", |
|
333 "PrintScreen", |
|
334 "ScrollLock", |
|
335 "Pause", |
|
336 "Insert", |
|
337 "Home", |
|
338 "PageUp", |
|
339 "Delete", |
|
340 "End", |
|
341 "PageDown", |
|
342 "Right", |
|
343 "Left", |
|
344 "Down", |
|
345 "Up", |
|
346 "Numlock", |
|
347 "Keypad /", |
|
348 "Keypad *", |
|
349 "Keypad -", |
|
350 "Keypad +", |
|
351 "Keypad Enter", |
|
352 "Keypad 1", |
|
353 "Keypad 2", |
|
354 "Keypad 3", |
|
355 "Keypad 4", |
|
356 "Keypad 5", |
|
357 "Keypad 6", |
|
358 "Keypad 7", |
|
359 "Keypad 8", |
|
360 "Keypad 9", |
|
361 "Keypad 0", |
|
362 "Keypad .", |
|
363 NULL, |
|
364 "Application", |
|
365 "Power", |
|
366 "Keypad =", |
|
367 "F13", |
|
368 "F14", |
|
369 "F15", |
|
370 "F16", |
|
371 "F17", |
|
372 "F18", |
|
373 "F19", |
|
374 "F20", |
|
375 "F21", |
|
376 "F22", |
|
377 "F23", |
|
378 "F24", |
|
379 "Execute", |
|
380 "Help", |
|
381 "Menu", |
|
382 "Select", |
|
383 "Stop", |
|
384 "Again", |
|
385 "Undo", |
|
386 "Cut", |
|
387 "Copy", |
|
388 "Paste", |
|
389 "Find", |
|
390 "Mute", |
|
391 "VolumeUp", |
|
392 "VolumeDown", |
|
393 NULL, NULL, NULL, |
|
394 "Keypad ,", |
|
395 "Keypad = (AS400)", |
|
396 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, |
|
397 NULL, NULL, NULL, NULL, NULL, NULL, |
|
398 "AltErase", |
|
399 "SysReq", |
|
400 "Cancel", |
|
401 "Clear", |
|
402 "Prior", |
|
403 "Return", |
|
404 "Separator", |
|
405 "Out", |
|
406 "Oper", |
|
407 "Clear / Again", |
|
408 "CrSel", |
|
409 "ExSel", |
|
410 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, |
|
411 "Keypad 00", |
|
412 "Keypad 000", |
|
413 "ThousandsSeparator", |
|
414 "DecimalSeparator", |
|
415 "CurrencyUnit", |
|
416 "CurrencySubUnit", |
|
417 "Keypad (", |
|
418 "Keypad )", |
|
419 "Keypad {", |
|
420 "Keypad }", |
|
421 "Keypad Tab", |
|
422 "Keypad Backspace", |
|
423 "Keypad A", |
|
424 "Keypad B", |
|
425 "Keypad C", |
|
426 "Keypad D", |
|
427 "Keypad E", |
|
428 "Keypad F", |
|
429 "Keypad XOR", |
|
430 "Keypad ^", |
|
431 "Keypad %", |
|
432 "Keypad <", |
|
433 "Keypad >", |
|
434 "Keypad &", |
|
435 "Keypad &&", |
|
436 "Keypad |", |
|
437 "Keypad ||", |
|
438 "Keypad :", |
|
439 "Keypad #", |
|
440 "Keypad Space", |
|
441 "Keypad @", |
|
442 "Keypad !", |
|
443 "Keypad MemStore", |
|
444 "Keypad MemRecall", |
|
445 "Keypad MemClear", |
|
446 "Keypad MemAdd", |
|
447 "Keypad MemSubtract", |
|
448 "Keypad MemMultiply", |
|
449 "Keypad MemDivide", |
|
450 "Keypad +/-", |
|
451 "Keypad Clear", |
|
452 "Keypad ClearEntry", |
|
453 "Keypad Binary", |
|
454 "Keypad Octal", |
|
455 "Keypad Decimal", |
|
456 "Keypad Hexadecimal", |
|
457 NULL, NULL, |
|
458 "Left Ctrl", |
|
459 "Left Shift", |
|
460 "Left Alt", |
|
461 "Left GUI", |
|
462 "Right Ctrl", |
|
463 "Right Shift", |
|
464 "Right Alt", |
|
465 "Right GUI", |
|
466 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, |
|
467 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, |
|
468 NULL, |
|
469 "ModeSwitch", |
|
470 "AudioNext", |
|
471 "AudioPrev", |
|
472 "AudioStop", |
|
473 "AudioPlay", |
|
474 "AudioMute", |
|
475 "MediaSelect", |
|
476 "Mail", |
|
477 "Calculator", |
|
478 "Computer", |
|
479 "AC Search", |
|
480 "AC Home", |
|
481 "AC Back", |
|
482 "AC Forward", |
|
483 "AC Stop", |
|
484 "AC Refresh", |
|
485 "AC Bookmarks", |
|
486 "BrightnessDown", |
|
487 "BrightnessUp", |
|
488 "DisplaySwitch", |
|
489 "KBDIllumToggle", |
|
490 "KBDIllumDown", |
|
491 "KBDIllumUp", |
|
492 "Eject", |
|
493 "Sleep", |
|
494 }; |
|
495 |
39 /* Taken from SDL_iconv() */ |
496 /* Taken from SDL_iconv() */ |
40 char * |
497 static char * |
41 SDL_Ucs4ToUtf8(Uint32 ch, char *dst) |
498 SDL_UCS4ToUTF8(Uint32 ch, char *dst) |
42 { |
499 { |
43 Uint8 *p = (Uint8 *) dst; |
500 Uint8 *p = (Uint8 *) dst; |
44 if (ch <= 0x7F) { |
501 if (ch <= 0x7F) { |
45 *p = (Uint8) ch; |
502 *p = (Uint8) ch; |
46 ++dst; |
503 ++dst; |
146 |
600 |
147 void |
601 void |
148 SDL_ResetKeyboard(int index) |
602 SDL_ResetKeyboard(int index) |
149 { |
603 { |
150 SDL_Keyboard *keyboard = SDL_GetKeyboard(index); |
604 SDL_Keyboard *keyboard = SDL_GetKeyboard(index); |
151 int key; |
605 SDL_scancode scancode; |
152 |
606 |
153 if (!keyboard) { |
607 if (!keyboard) { |
154 return; |
608 return; |
155 } |
609 } |
156 |
610 |
157 for (key = SDLK_FIRST; key < SDLK_LAST; ++key) { |
611 for (scancode = 0; scancode < SDL_NUM_SCANCODES; ++scancode) { |
158 if (keyboard->keystate[key] == SDL_PRESSED) { |
612 if (keyboard->keystate[scancode] == SDL_PRESSED) { |
159 SDL_SendKeyboardKey(index, SDL_RELEASED, 0, |
613 SDL_SendKeyboardKey(index, SDL_RELEASED, scancode); |
160 key | SDL_KEY_CAN_BE_PHYSICAL_BIT); |
|
161 } |
614 } |
162 } |
615 } |
163 } |
616 } |
164 |
617 |
165 void |
618 void |
166 SDL_KeyboardQuit(void) |
619 SDL_GetDefaultKeymap(SDLKey * keymap) |
167 { |
620 { |
168 int i; |
621 SDL_memcpy(keymap, SDL_default_keymap, sizeof(SDL_default_keymap)); |
169 |
|
170 for (i = 0; i < SDL_num_keyboards; ++i) { |
|
171 SDL_DelKeyboard(i); |
|
172 } |
|
173 SDL_num_keyboards = 0; |
|
174 SDL_current_keyboard = 0; |
|
175 |
|
176 if (SDL_keyboards) { |
|
177 SDL_free(SDL_keyboards); |
|
178 SDL_keyboards = NULL; |
|
179 } |
|
180 } |
|
181 |
|
182 int |
|
183 SDL_GetNumKeyboards(void) |
|
184 { |
|
185 return SDL_num_keyboards; |
|
186 } |
|
187 |
|
188 int |
|
189 SDL_SelectKeyboard(int index) |
|
190 { |
|
191 if (index >= 0 && index < SDL_num_keyboards) { |
|
192 SDL_current_keyboard = index; |
|
193 } |
|
194 return SDL_current_keyboard; |
|
195 } |
|
196 |
|
197 int |
|
198 SDL_EnableUNICODE(int enable) |
|
199 { |
|
200 int old_mode; |
|
201 |
|
202 old_mode = SDL_TranslateUNICODE; |
|
203 if (enable >= 0) { |
|
204 SDL_TranslateUNICODE = enable; |
|
205 } |
|
206 return (old_mode); |
|
207 } |
|
208 |
|
209 Uint8 * |
|
210 SDL_GetKeyState(int *numkeys) |
|
211 { |
|
212 SDL_Keyboard *keyboard = SDL_GetKeyboard(SDL_current_keyboard); |
|
213 |
|
214 if (numkeys != (int *) 0) { |
|
215 *numkeys = SDLK_LAST; |
|
216 } |
|
217 |
|
218 if (!keyboard) { |
|
219 return NULL; |
|
220 } |
|
221 return keyboard->keystate; |
|
222 } |
|
223 |
|
224 SDLMod |
|
225 SDL_GetModState(void) |
|
226 { |
|
227 SDL_Keyboard *keyboard = SDL_GetKeyboard(SDL_current_keyboard); |
|
228 |
|
229 if (!keyboard) { |
|
230 return KMOD_NONE; |
|
231 } |
|
232 return keyboard->modstate; |
|
233 } |
622 } |
234 |
623 |
235 void |
624 void |
236 SDL_SetModState(SDLMod modstate) |
625 SDL_SetKeymap(int index, int start, SDLKey * keys, int length) |
237 { |
626 { |
238 SDL_Keyboard *keyboard = SDL_GetKeyboard(SDL_current_keyboard); |
627 SDL_Keyboard *keyboard = SDL_GetKeyboard(index); |
239 |
628 |
240 if (!keyboard) { |
629 if (!keyboard) { |
241 return; |
630 return; |
242 } |
631 } |
243 keyboard->modstate = modstate; |
632 |
244 } |
633 if (start < 0 || start + length > SDL_NUM_SCANCODES) { |
245 |
634 return; |
246 SDLKey |
635 } |
247 SDL_GetLayoutKey(SDLKey physicalKey) |
636 |
248 { |
637 SDL_memcpy(&keyboard->keymap[start], keys, sizeof(*keys) * length); |
249 SDL_VideoDevice *_this = SDL_GetVideoDevice(); |
|
250 if (_this && _this->GetLayoutKey) { |
|
251 return _this->GetLayoutKey(_this, physicalKey) |
|
252 | (physicalKey & SDL_KEY_KEYPAD_BIT); |
|
253 } else { |
|
254 return physicalKey; |
|
255 } |
|
256 } |
|
257 |
|
258 const char * |
|
259 SDL_GetKeyName(SDLKey layoutKey) |
|
260 { |
|
261 const char *keyname = NULL; |
|
262 |
|
263 if ((layoutKey & SDL_KEY_LAYOUT_SPECIAL_BIT) != 0) { |
|
264 SDL_VideoDevice *_this = SDL_GetVideoDevice(); |
|
265 if (_this && _this->GetSpecialKeyName) { |
|
266 keyname = _this->GetSpecialKeyName(_this, layoutKey); |
|
267 } |
|
268 } else if ((layoutKey & SDL_KEY_CAN_BE_PHYSICAL_BIT) == 0) { |
|
269 /* SDLK_INDEX(layoutKey) is the unicode code point of the |
|
270 character generated by the key */ |
|
271 static char buffer[9]; /* 6 (maximal UTF-8 char length) + 2 ([] for keypad) + 1 (null teminator) */ |
|
272 char *bufferPtr = &buffer[1]; |
|
273 Uint32 codepoint = SDLK_INDEX(layoutKey); |
|
274 |
|
275 /* Unaccented letter keys on latin keyboards are normally |
|
276 labeled in upper case (and probably on others like Greek or |
|
277 Cyrillic too, so if you happen to know for sure, please |
|
278 adapt this). */ |
|
279 if (codepoint >= 'a' && codepoint <= 'z') { |
|
280 codepoint -= 32; |
|
281 } |
|
282 |
|
283 bufferPtr = SDL_Ucs4ToUtf8(codepoint, bufferPtr); |
|
284 *bufferPtr = '\0'; |
|
285 |
|
286 if ((layoutKey & SDL_KEY_KEYPAD_BIT) != 0) { |
|
287 buffer[0] = '['; |
|
288 *bufferPtr++ = ']'; |
|
289 *bufferPtr = '\0'; |
|
290 keyname = buffer; |
|
291 } else { |
|
292 keyname = &buffer[1]; |
|
293 } |
|
294 } else { |
|
295 /* SDLK_INDEX(layoutKey) is a physical key number */ |
|
296 if (SDLK_INDEX(layoutKey) < SDL_arraysize(SDL_keynames)) { |
|
297 keyname = SDL_keynames[SDLK_INDEX(layoutKey)]; |
|
298 } |
|
299 } |
|
300 |
|
301 if (keyname == NULL) { |
|
302 keyname = SDL_keynames[SDLK_INDEX(SDLK_UNKNOWN)]; |
|
303 } |
|
304 |
|
305 return keyname; |
|
306 } |
638 } |
307 |
639 |
308 void |
640 void |
309 SDL_SetKeyName(SDLKey physicalKey, const char *name) |
641 SDL_SetScancodeName(SDL_scancode scancode, const char *name) |
310 { |
642 { |
311 physicalKey = SDLK_INDEX(physicalKey); |
643 SDL_scancode_names[scancode] = name; |
312 if (physicalKey < SDL_arraysize(SDL_keynames)) { |
|
313 SDL_keynames[physicalKey] = name; |
|
314 } |
|
315 } |
644 } |
316 |
645 |
317 void |
646 void |
318 SDL_SetKeyboardFocus(int index, SDL_WindowID windowID) |
647 SDL_SetKeyboardFocus(int index, SDL_WindowID windowID) |
319 { |
648 { |
364 } |
693 } |
365 } |
694 } |
366 } |
695 } |
367 |
696 |
368 int |
697 int |
369 SDL_SendKeyboardKey(int index, Uint8 state, Uint8 scancode, |
698 SDL_SendKeyboardKey(int index, Uint8 state, SDL_scancode scancode) |
370 SDLKey physicalKey) |
|
371 { |
699 { |
372 SDL_Keyboard *keyboard = SDL_GetKeyboard(index); |
700 SDL_Keyboard *keyboard = SDL_GetKeyboard(index); |
373 int posted; |
701 int posted; |
374 Uint16 modstate; |
702 Uint16 modstate; |
375 Uint8 type; |
703 Uint8 type; |
376 |
704 |
377 if (!keyboard || physicalKey == SDLK_NONE) { |
705 if (!keyboard || !scancode) { |
378 return 0; |
706 return 0; |
379 } |
707 } |
380 #if 0 |
708 #if 0 |
381 printf("The '%s' key has been %s\n", SDL_GetKeyName(physicalKey), |
709 printf("The '%s' key has been %s\n", SDL_GetScancodeName(scancode), |
382 state == SDL_PRESSED ? "pressed" : "released"); |
710 state == SDL_PRESSED ? "pressed" : "released"); |
383 #endif |
711 #endif |
384 if (state == SDL_PRESSED) { |
712 if (state == SDL_PRESSED) { |
385 modstate = keyboard->modstate; |
713 modstate = keyboard->modstate; |
386 switch (physicalKey) { |
714 switch (scancode) { |
387 case SDLK_UNKNOWN: |
715 case SDL_SCANCODE_NUMLOCKCLEAR: |
388 break; |
|
389 case SDLK_KP_NUMLOCKCLEAR: |
|
390 keyboard->modstate ^= KMOD_NUM; |
716 keyboard->modstate ^= KMOD_NUM; |
391 break; |
717 break; |
392 case SDLK_CAPSLOCK: |
718 case SDL_SCANCODE_CAPSLOCK: |
393 keyboard->modstate ^= KMOD_CAPS; |
719 keyboard->modstate ^= KMOD_CAPS; |
394 break; |
720 break; |
395 case SDLK_LCTRL: |
721 case SDL_SCANCODE_LCTRL: |
396 keyboard->modstate |= KMOD_LCTRL; |
722 keyboard->modstate |= KMOD_LCTRL; |
397 break; |
723 break; |
398 case SDLK_RCTRL: |
724 case SDL_SCANCODE_RCTRL: |
399 keyboard->modstate |= KMOD_RCTRL; |
725 keyboard->modstate |= KMOD_RCTRL; |
400 break; |
726 break; |
401 case SDLK_LSHIFT: |
727 case SDL_SCANCODE_LSHIFT: |
402 keyboard->modstate |= KMOD_LSHIFT; |
728 keyboard->modstate |= KMOD_LSHIFT; |
403 break; |
729 break; |
404 case SDLK_RSHIFT: |
730 case SDL_SCANCODE_RSHIFT: |
405 keyboard->modstate |= KMOD_RSHIFT; |
731 keyboard->modstate |= KMOD_RSHIFT; |
406 break; |
732 break; |
407 case SDLK_LALT: |
733 case SDL_SCANCODE_LALT: |
408 keyboard->modstate |= KMOD_LALT; |
734 keyboard->modstate |= KMOD_LALT; |
409 break; |
735 break; |
410 case SDLK_RALT: |
736 case SDL_SCANCODE_RALT: |
411 keyboard->modstate |= KMOD_RALT; |
737 keyboard->modstate |= KMOD_RALT; |
412 break; |
738 break; |
413 case SDLK_LMETA: |
739 case SDL_SCANCODE_LGUI: |
414 keyboard->modstate |= KMOD_LMETA; |
740 keyboard->modstate |= KMOD_LGUI; |
415 break; |
741 break; |
416 case SDLK_RMETA: |
742 case SDL_SCANCODE_RGUI: |
417 keyboard->modstate |= KMOD_RMETA; |
743 keyboard->modstate |= KMOD_RGUI; |
418 break; |
744 break; |
419 case SDLK_MODE: |
745 case SDL_SCANCODE_MODE: |
420 keyboard->modstate |= KMOD_MODE; |
746 keyboard->modstate |= KMOD_MODE; |
421 break; |
747 break; |
422 default: |
748 default: |
423 break; |
749 break; |
424 } |
750 } |
425 } else { |
751 } else { |
426 switch (physicalKey) { |
752 switch (scancode) { |
427 case SDLK_UNKNOWN: |
753 case SDL_SCANCODE_NUMLOCKCLEAR: |
428 break; |
754 case SDL_SCANCODE_CAPSLOCK: |
429 case SDLK_KP_NUMLOCKCLEAR: |
755 break; |
430 case SDLK_CAPSLOCK: |
756 case SDL_SCANCODE_LCTRL: |
431 break; |
|
432 case SDLK_LCTRL: |
|
433 keyboard->modstate &= ~KMOD_LCTRL; |
757 keyboard->modstate &= ~KMOD_LCTRL; |
434 break; |
758 break; |
435 case SDLK_RCTRL: |
759 case SDL_SCANCODE_RCTRL: |
436 keyboard->modstate &= ~KMOD_RCTRL; |
760 keyboard->modstate &= ~KMOD_RCTRL; |
437 break; |
761 break; |
438 case SDLK_LSHIFT: |
762 case SDL_SCANCODE_LSHIFT: |
439 keyboard->modstate &= ~KMOD_LSHIFT; |
763 keyboard->modstate &= ~KMOD_LSHIFT; |
440 break; |
764 break; |
441 case SDLK_RSHIFT: |
765 case SDL_SCANCODE_RSHIFT: |
442 keyboard->modstate &= ~KMOD_RSHIFT; |
766 keyboard->modstate &= ~KMOD_RSHIFT; |
443 break; |
767 break; |
444 case SDLK_LALT: |
768 case SDL_SCANCODE_LALT: |
445 keyboard->modstate &= ~KMOD_LALT; |
769 keyboard->modstate &= ~KMOD_LALT; |
446 break; |
770 break; |
447 case SDLK_RALT: |
771 case SDL_SCANCODE_RALT: |
448 keyboard->modstate &= ~KMOD_RALT; |
772 keyboard->modstate &= ~KMOD_RALT; |
449 break; |
773 break; |
450 case SDLK_LMETA: |
774 case SDL_SCANCODE_LGUI: |
451 keyboard->modstate &= ~KMOD_LMETA; |
775 keyboard->modstate &= ~KMOD_LGUI; |
452 break; |
776 break; |
453 case SDLK_RMETA: |
777 case SDL_SCANCODE_RGUI: |
454 keyboard->modstate &= ~KMOD_RMETA; |
778 keyboard->modstate &= ~KMOD_RGUI; |
455 break; |
779 break; |
456 case SDLK_MODE: |
780 case SDL_SCANCODE_MODE: |
457 keyboard->modstate &= ~KMOD_MODE; |
781 keyboard->modstate &= ~KMOD_MODE; |
458 break; |
782 break; |
459 default: |
783 default: |
460 break; |
784 break; |
461 } |
785 } |
473 default: |
797 default: |
474 /* Invalid state -- bail */ |
798 /* Invalid state -- bail */ |
475 return 0; |
799 return 0; |
476 } |
800 } |
477 |
801 |
478 if (physicalKey != SDLK_UNKNOWN) { |
802 /* Drop events that don't change state */ |
479 /* Drop events that don't change state */ |
803 if (keyboard->keystate[scancode] == state) { |
480 if (keyboard->keystate[SDLK_INDEX(physicalKey)] == state) { |
|
481 #if 0 |
804 #if 0 |
482 printf("Keyboard event didn't change state - dropped!\n"); |
805 printf("Keyboard event didn't change state - dropped!\n"); |
483 #endif |
806 #endif |
484 return 0; |
807 return 0; |
485 } |
808 } |
486 |
809 |
487 /* Update internal keyboard state */ |
810 /* Update internal keyboard state */ |
488 keyboard->keystate[SDLK_INDEX(physicalKey)] = state; |
811 keyboard->keystate[scancode] = state; |
489 } |
|
490 |
812 |
491 /* Post the event, if desired */ |
813 /* Post the event, if desired */ |
492 posted = 0; |
814 posted = 0; |
493 if (SDL_ProcessEvents[type] == SDL_ENABLE) { |
815 if (SDL_ProcessEvents[type] == SDL_ENABLE) { |
494 SDL_Event event; |
816 SDL_Event event; |
495 event.key.type = type; |
817 event.key.type = type; |
496 event.key.which = (Uint8) index; |
818 event.key.which = (Uint8) index; |
497 event.key.state = state; |
819 event.key.state = state; |
498 event.key.keysym.scancode = scancode; |
820 event.key.keysym.scancode = scancode; |
499 event.key.keysym.sym = physicalKey; |
821 event.key.keysym.sym = keyboard->keymap[scancode]; |
500 event.key.keysym.mod = modstate; |
822 event.key.keysym.mod = modstate; |
501 event.key.keysym.unicode = 0; |
823 event.key.keysym.unicode = 0; |
502 event.key.windowID = keyboard->focus; |
824 event.key.windowID = keyboard->focus; |
503 posted = (SDL_PushEvent(&event) > 0); |
825 posted = (SDL_PushEvent(&event) > 0); |
504 } |
826 } |
526 posted = (SDL_PushEvent(&event) > 0); |
848 posted = (SDL_PushEvent(&event) > 0); |
527 } |
849 } |
528 return (posted); |
850 return (posted); |
529 } |
851 } |
530 |
852 |
|
853 void |
|
854 SDL_KeyboardQuit(void) |
|
855 { |
|
856 int i; |
|
857 |
|
858 for (i = 0; i < SDL_num_keyboards; ++i) { |
|
859 SDL_DelKeyboard(i); |
|
860 } |
|
861 SDL_num_keyboards = 0; |
|
862 SDL_current_keyboard = 0; |
|
863 |
|
864 if (SDL_keyboards) { |
|
865 SDL_free(SDL_keyboards); |
|
866 SDL_keyboards = NULL; |
|
867 } |
|
868 } |
|
869 |
|
870 int |
|
871 SDL_GetNumKeyboards(void) |
|
872 { |
|
873 return SDL_num_keyboards; |
|
874 } |
|
875 |
|
876 int |
|
877 SDL_SelectKeyboard(int index) |
|
878 { |
|
879 if (index >= 0 && index < SDL_num_keyboards) { |
|
880 SDL_current_keyboard = index; |
|
881 } |
|
882 return SDL_current_keyboard; |
|
883 } |
|
884 |
|
885 Uint8 * |
|
886 SDL_GetKeyboardState(int *numkeys) |
|
887 { |
|
888 SDL_Keyboard *keyboard = SDL_GetKeyboard(SDL_current_keyboard); |
|
889 |
|
890 if (numkeys != (int *) 0) { |
|
891 *numkeys = SDL_NUM_SCANCODES; |
|
892 } |
|
893 |
|
894 if (!keyboard) { |
|
895 return NULL; |
|
896 } |
|
897 return keyboard->keystate; |
|
898 } |
|
899 |
|
900 SDLMod |
|
901 SDL_GetModState(void) |
|
902 { |
|
903 SDL_Keyboard *keyboard = SDL_GetKeyboard(SDL_current_keyboard); |
|
904 |
|
905 if (!keyboard) { |
|
906 return KMOD_NONE; |
|
907 } |
|
908 return keyboard->modstate; |
|
909 } |
|
910 |
|
911 void |
|
912 SDL_SetModState(SDLMod modstate) |
|
913 { |
|
914 SDL_Keyboard *keyboard = SDL_GetKeyboard(SDL_current_keyboard); |
|
915 |
|
916 if (!keyboard) { |
|
917 return; |
|
918 } |
|
919 keyboard->modstate = modstate; |
|
920 } |
|
921 |
|
922 SDLKey |
|
923 SDL_GetKeyFromScancode(SDL_scancode scancode) |
|
924 { |
|
925 SDL_Keyboard *keyboard = SDL_GetKeyboard(SDL_current_keyboard); |
|
926 |
|
927 if (!keyboard) { |
|
928 return SDLK_UNKNOWN; |
|
929 } |
|
930 return keyboard->keymap[scancode]; |
|
931 } |
|
932 |
|
933 SDL_scancode |
|
934 SDL_GetScancodeFromKey(SDLKey key) |
|
935 { |
|
936 SDL_Keyboard *keyboard = SDL_GetKeyboard(SDL_current_keyboard); |
|
937 SDL_scancode scancode; |
|
938 |
|
939 if (!keyboard) { |
|
940 return SDL_SCANCODE_UNKNOWN; |
|
941 } |
|
942 |
|
943 for (scancode = SDL_SCANCODE_UNKNOWN; scancode < SDL_NUM_SCANCODES; |
|
944 ++scancode) { |
|
945 if (keyboard->keymap[scancode] == key) { |
|
946 return scancode; |
|
947 } |
|
948 } |
|
949 return SDL_SCANCODE_UNKNOWN; |
|
950 } |
|
951 |
|
952 const char * |
|
953 SDL_GetScancodeName(SDL_scancode scancode) |
|
954 { |
|
955 const char *name = SDL_scancode_names[scancode]; |
|
956 |
|
957 if (name) |
|
958 return name; |
|
959 else |
|
960 return ""; |
|
961 } |
|
962 |
|
963 const char * |
|
964 SDL_GetKeyName(SDLKey key) |
|
965 { |
|
966 static char name[8]; |
|
967 char *end; |
|
968 |
|
969 if (key & SDLK_SCANCODE_MASK) { |
|
970 return |
|
971 SDL_GetScancodeName((SDL_scancode) (key & ~SDLK_SCANCODE_MASK)); |
|
972 } |
|
973 |
|
974 /* Unaccented letter keys on latin keyboards are normally |
|
975 labeled in upper case (and probably on others like Greek or |
|
976 Cyrillic too, so if you happen to know for sure, please |
|
977 adapt this). */ |
|
978 if (key >= 'a' && key <= 'z') { |
|
979 key -= 32; |
|
980 } |
|
981 |
|
982 end = SDL_UCS4ToUTF8((Uint32) key, name); |
|
983 *end = '\0'; |
|
984 return name; |
|
985 } |
|
986 |
531 /* vi: set ts=4 sw=4 expandtab: */ |
987 /* vi: set ts=4 sw=4 expandtab: */ |