FreeRDP
Loading...
Searching...
No Matches
Data Structures | Public Member Functions | Static Public Attributes
com.freerdp.freerdpcore.utils.KeyboardMapper Class Reference

Data Structures

interface  KeyProcessingListener
 

Public Member Functions

void init (Context context)
 
void reset (KeyProcessingListener listener)
 
void setKeyProcessingListener (KeyProcessingListener listener)
 
boolean processAndroidKeyEvent (KeyEvent event)
 
void processCustomKeyEvent (int keycode)
 
boolean processCustomKeyLock (int keycode)
 
void processUnicodeFallback (int unicodeKey)
 
void sendAltF4 ()
 
int getModifierState (int keycode)
 
void clearlAllModifiers ()
 

Static Public Attributes

static final int KEYBOARD_TYPE_FUNCTIONKEYS = 1
 
static final int KEYBOARD_TYPE_NUMPAD = 2
 
static final int KEYSTATE_ON = 1
 
static final int KEYSTATE_LOCKED = 2
 
static final int KEYSTATE_OFF = 3
 

Detailed Description

Definition at line 19 of file KeyboardMapper.java.

Member Function Documentation

◆ clearlAllModifiers()

void com.freerdp.freerdpcore.utils.KeyboardMapper.clearlAllModifiers ( )
inline

Definition at line 738 of file KeyboardMapper.java.

739 {
740 resetModifierKeysAfterInput(true);
741 }

◆ getModifierState()

int com.freerdp.freerdpcore.utils.KeyboardMapper.getModifierState ( int  keycode)
inline

Definition at line 647 of file KeyboardMapper.java.

648 {
649 int modifierCode = getExtendedKeyCode(keycode);
650
651 // check and get real modifier keycode
652 if ((modifierCode & KEY_FLAG_TOGGLE) == 0)
653 return -1;
654 modifierCode = modifierCode & (~KEY_FLAG_TOGGLE);
655
656 switch (modifierCode)
657 {
658 case VK_LSHIFT:
659 {
660 return (shiftPressed ? (isShiftLocked ? KEYSTATE_LOCKED : KEYSTATE_ON)
661 : KEYSTATE_OFF);
662 }
663 case VK_LCONTROL:
664 {
665 return (ctrlPressed ? (isCtrlLocked ? KEYSTATE_LOCKED : KEYSTATE_ON)
666 : KEYSTATE_OFF);
667 }
668 case VK_LMENU:
669 {
670 return (altPressed ? (isAltLocked ? KEYSTATE_LOCKED : KEYSTATE_ON) : KEYSTATE_OFF);
671 }
672 case VK_LWIN:
673 {
674 return (winPressed ? (isWinLocked ? KEYSTATE_LOCKED : KEYSTATE_ON) : KEYSTATE_OFF);
675 }
676 }
677
678 return -1;
679 }

◆ init()

void com.freerdp.freerdpcore.utils.KeyboardMapper.init ( Context  context)
inline

Definition at line 229 of file KeyboardMapper.java.

230 {
231 if (initialized)
232 return;
233
234 keymapAndroid = new int[256];
235
236 keymapAndroid[KeyEvent.KEYCODE_0] = VK_KEY_0;
237 keymapAndroid[KeyEvent.KEYCODE_1] = VK_KEY_1;
238 keymapAndroid[KeyEvent.KEYCODE_2] = VK_KEY_2;
239 keymapAndroid[KeyEvent.KEYCODE_3] = VK_KEY_3;
240 keymapAndroid[KeyEvent.KEYCODE_4] = VK_KEY_4;
241 keymapAndroid[KeyEvent.KEYCODE_5] = VK_KEY_5;
242 keymapAndroid[KeyEvent.KEYCODE_6] = VK_KEY_6;
243 keymapAndroid[KeyEvent.KEYCODE_7] = VK_KEY_7;
244 keymapAndroid[KeyEvent.KEYCODE_8] = VK_KEY_8;
245 keymapAndroid[KeyEvent.KEYCODE_9] = VK_KEY_9;
246
247 keymapAndroid[KeyEvent.KEYCODE_A] = VK_KEY_A;
248 keymapAndroid[KeyEvent.KEYCODE_B] = VK_KEY_B;
249 keymapAndroid[KeyEvent.KEYCODE_C] = VK_KEY_C;
250 keymapAndroid[KeyEvent.KEYCODE_D] = VK_KEY_D;
251 keymapAndroid[KeyEvent.KEYCODE_E] = VK_KEY_E;
252 keymapAndroid[KeyEvent.KEYCODE_F] = VK_KEY_F;
253 keymapAndroid[KeyEvent.KEYCODE_G] = VK_KEY_G;
254 keymapAndroid[KeyEvent.KEYCODE_H] = VK_KEY_H;
255 keymapAndroid[KeyEvent.KEYCODE_I] = VK_KEY_I;
256 keymapAndroid[KeyEvent.KEYCODE_J] = VK_KEY_J;
257 keymapAndroid[KeyEvent.KEYCODE_K] = VK_KEY_K;
258 keymapAndroid[KeyEvent.KEYCODE_L] = VK_KEY_L;
259 keymapAndroid[KeyEvent.KEYCODE_M] = VK_KEY_M;
260 keymapAndroid[KeyEvent.KEYCODE_N] = VK_KEY_N;
261 keymapAndroid[KeyEvent.KEYCODE_O] = VK_KEY_O;
262 keymapAndroid[KeyEvent.KEYCODE_P] = VK_KEY_P;
263 keymapAndroid[KeyEvent.KEYCODE_Q] = VK_KEY_Q;
264 keymapAndroid[KeyEvent.KEYCODE_R] = VK_KEY_R;
265 keymapAndroid[KeyEvent.KEYCODE_S] = VK_KEY_S;
266 keymapAndroid[KeyEvent.KEYCODE_T] = VK_KEY_T;
267 keymapAndroid[KeyEvent.KEYCODE_U] = VK_KEY_U;
268 keymapAndroid[KeyEvent.KEYCODE_V] = VK_KEY_V;
269 keymapAndroid[KeyEvent.KEYCODE_W] = VK_KEY_W;
270 keymapAndroid[KeyEvent.KEYCODE_X] = VK_KEY_X;
271 keymapAndroid[KeyEvent.KEYCODE_Y] = VK_KEY_Y;
272 keymapAndroid[KeyEvent.KEYCODE_Z] = VK_KEY_Z;
273
274 keymapAndroid[KeyEvent.KEYCODE_DEL] = VK_BACK;
275 keymapAndroid[KeyEvent.KEYCODE_ENTER] = VK_RETURN;
276 keymapAndroid[KeyEvent.KEYCODE_SPACE] = VK_SPACE;
277 keymapAndroid[KeyEvent.KEYCODE_TAB] = VK_TAB;
278 keymapAndroid[KeyEvent.KEYCODE_ESCAPE] = VK_ESCAPE;
279 keymapAndroid[KeyEvent.KEYCODE_CAPS_LOCK] = VK_CAPITAL;
280 // keymapAndroid[KeyEvent.KEYCODE_SHIFT_LEFT] = VK_LSHIFT;
281 // keymapAndroid[KeyEvent.KEYCODE_SHIFT_RIGHT] = VK_RSHIFT;
282
283 keymapAndroid[KeyEvent.KEYCODE_DPAD_DOWN] = VK_DOWN | VK_EXT_KEY;
284 keymapAndroid[KeyEvent.KEYCODE_DPAD_LEFT] = VK_LEFT | VK_EXT_KEY;
285 keymapAndroid[KeyEvent.KEYCODE_DPAD_RIGHT] = VK_RIGHT | VK_EXT_KEY;
286 keymapAndroid[KeyEvent.KEYCODE_DPAD_UP] = VK_UP | VK_EXT_KEY;
287 keymapAndroid[KeyEvent.KEYCODE_MOVE_HOME] = VK_HOME | VK_EXT_KEY;
288 keymapAndroid[KeyEvent.KEYCODE_MOVE_END] = VK_END | VK_EXT_KEY;
289 keymapAndroid[KeyEvent.KEYCODE_PAGE_UP] = VK_PRIOR | VK_EXT_KEY;
290 keymapAndroid[KeyEvent.KEYCODE_PAGE_DOWN] = VK_NEXT | VK_EXT_KEY;
291 keymapAndroid[KeyEvent.KEYCODE_FORWARD_DEL] = VK_DELETE | VK_EXT_KEY;
292 keymapAndroid[KeyEvent.KEYCODE_INSERT] = VK_INSERT | VK_EXT_KEY;
293
294 keymapAndroid[KeyEvent.KEYCODE_MINUS] = VK_OEM_MINUS;
295 keymapAndroid[KeyEvent.KEYCODE_EQUALS] = VK_OEM_PLUS;
296 keymapAndroid[KeyEvent.KEYCODE_LEFT_BRACKET] = VK_OEM_4;
297 keymapAndroid[KeyEvent.KEYCODE_RIGHT_BRACKET] = VK_OEM_6;
298 keymapAndroid[KeyEvent.KEYCODE_BACKSLASH] = VK_OEM_5;
299 keymapAndroid[KeyEvent.KEYCODE_SEMICOLON] = VK_OEM_1;
300 keymapAndroid[KeyEvent.KEYCODE_APOSTROPHE] = VK_OEM_7;
301 keymapAndroid[KeyEvent.KEYCODE_GRAVE] = VK_OEM_3;
302 keymapAndroid[KeyEvent.KEYCODE_COMMA] = VK_OEM_COMMA;
303 keymapAndroid[KeyEvent.KEYCODE_PERIOD] = VK_OEM_PERIOD;
304 keymapAndroid[KeyEvent.KEYCODE_SLASH] = VK_OEM_2;
305
306 keymapAndroid[KeyEvent.KEYCODE_F1] = VK_F1;
307 keymapAndroid[KeyEvent.KEYCODE_F2] = VK_F2;
308 keymapAndroid[KeyEvent.KEYCODE_F3] = VK_F3;
309 keymapAndroid[KeyEvent.KEYCODE_F4] = VK_F4;
310 keymapAndroid[KeyEvent.KEYCODE_F5] = VK_F5;
311 keymapAndroid[KeyEvent.KEYCODE_F6] = VK_F6;
312 keymapAndroid[KeyEvent.KEYCODE_F7] = VK_F7;
313 keymapAndroid[KeyEvent.KEYCODE_F8] = VK_F8;
314 keymapAndroid[KeyEvent.KEYCODE_F9] = VK_F9;
315 keymapAndroid[KeyEvent.KEYCODE_F10] = VK_F10;
316 keymapAndroid[KeyEvent.KEYCODE_F11] = VK_F11;
317 keymapAndroid[KeyEvent.KEYCODE_F12] = VK_F12;
318
319 keymapAndroid[KeyEvent.KEYCODE_NUM_LOCK] = VK_NUMLOCK;
320 keymapAndroid[KeyEvent.KEYCODE_SCROLL_LOCK] = VK_SCROLL;
321 keymapAndroid[KeyEvent.KEYCODE_SYSRQ] = VK_SNAPSHOT | VK_EXT_KEY;
322 keymapAndroid[KeyEvent.KEYCODE_BREAK] = VK_PAUSE;
323
324 keymapAndroid[KeyEvent.KEYCODE_NUMPAD_0] = VK_NUMPAD0;
325 keymapAndroid[KeyEvent.KEYCODE_NUMPAD_1] = VK_NUMPAD1;
326 keymapAndroid[KeyEvent.KEYCODE_NUMPAD_2] = VK_NUMPAD2;
327 keymapAndroid[KeyEvent.KEYCODE_NUMPAD_3] = VK_NUMPAD3;
328 keymapAndroid[KeyEvent.KEYCODE_NUMPAD_4] = VK_NUMPAD4;
329 keymapAndroid[KeyEvent.KEYCODE_NUMPAD_5] = VK_NUMPAD5;
330 keymapAndroid[KeyEvent.KEYCODE_NUMPAD_6] = VK_NUMPAD6;
331 keymapAndroid[KeyEvent.KEYCODE_NUMPAD_7] = VK_NUMPAD7;
332 keymapAndroid[KeyEvent.KEYCODE_NUMPAD_8] = VK_NUMPAD8;
333 keymapAndroid[KeyEvent.KEYCODE_NUMPAD_9] = VK_NUMPAD9;
334 keymapAndroid[KeyEvent.KEYCODE_NUMPAD_DIVIDE] = VK_DIVIDE | VK_EXT_KEY;
335 keymapAndroid[KeyEvent.KEYCODE_NUMPAD_MULTIPLY] = VK_MULTIPLY;
336 keymapAndroid[KeyEvent.KEYCODE_NUMPAD_SUBTRACT] = VK_SUBTRACT;
337 keymapAndroid[KeyEvent.KEYCODE_NUMPAD_ADD] = VK_ADD;
338 keymapAndroid[KeyEvent.KEYCODE_NUMPAD_DOT] = VK_DECIMAL;
339 keymapAndroid[KeyEvent.KEYCODE_NUMPAD_COMMA] = VK_DECIMAL;
340 keymapAndroid[KeyEvent.KEYCODE_NUMPAD_ENTER] = VK_RETURN | VK_EXT_KEY;
341 keymapAndroid[KeyEvent.KEYCODE_NUMPAD_EQUALS] = KEY_FLAG_UNICODE | 61;
342 keymapAndroid[KeyEvent.KEYCODE_NUMPAD_LEFT_PAREN] = KEY_FLAG_UNICODE | 40;
343 keymapAndroid[KeyEvent.KEYCODE_NUMPAD_RIGHT_PAREN] = KEY_FLAG_UNICODE | 41;
344
345 // special keys mapping
346 keymapExt = new int[256];
347 keymapExt[context.getResources().getInteger(R.integer.keycode_F1)] = VK_F1;
348 keymapExt[context.getResources().getInteger(R.integer.keycode_F2)] = VK_F2;
349 keymapExt[context.getResources().getInteger(R.integer.keycode_F3)] = VK_F3;
350 keymapExt[context.getResources().getInteger(R.integer.keycode_F4)] = VK_F4;
351 keymapExt[context.getResources().getInteger(R.integer.keycode_F5)] = VK_F5;
352 keymapExt[context.getResources().getInteger(R.integer.keycode_F6)] = VK_F6;
353 keymapExt[context.getResources().getInteger(R.integer.keycode_F7)] = VK_F7;
354 keymapExt[context.getResources().getInteger(R.integer.keycode_F8)] = VK_F8;
355 keymapExt[context.getResources().getInteger(R.integer.keycode_F9)] = VK_F9;
356 keymapExt[context.getResources().getInteger(R.integer.keycode_F10)] = VK_F10;
357 keymapExt[context.getResources().getInteger(R.integer.keycode_F11)] = VK_F11;
358 keymapExt[context.getResources().getInteger(R.integer.keycode_F12)] = VK_F12;
359 keymapExt[context.getResources().getInteger(R.integer.keycode_tab)] = VK_TAB;
360 keymapExt[context.getResources().getInteger(R.integer.keycode_print)] = VK_PRINT;
361 keymapExt[context.getResources().getInteger(R.integer.keycode_insert)] =
362 VK_INSERT | VK_EXT_KEY;
363 keymapExt[context.getResources().getInteger(R.integer.keycode_delete)] =
364 VK_DELETE | VK_EXT_KEY;
365 keymapExt[context.getResources().getInteger(R.integer.keycode_home)] = VK_HOME | VK_EXT_KEY;
366 keymapExt[context.getResources().getInteger(R.integer.keycode_end)] = VK_END | VK_EXT_KEY;
367 keymapExt[context.getResources().getInteger(R.integer.keycode_pgup)] =
368 VK_PRIOR | VK_EXT_KEY;
369 keymapExt[context.getResources().getInteger(R.integer.keycode_pgdn)] = VK_NEXT | VK_EXT_KEY;
370
371 // numpad mapping
372 keymapExt[context.getResources().getInteger(R.integer.keycode_numpad_0)] = VK_NUMPAD0;
373 keymapExt[context.getResources().getInteger(R.integer.keycode_numpad_1)] = VK_NUMPAD1;
374 keymapExt[context.getResources().getInteger(R.integer.keycode_numpad_2)] = VK_NUMPAD2;
375 keymapExt[context.getResources().getInteger(R.integer.keycode_numpad_3)] = VK_NUMPAD3;
376 keymapExt[context.getResources().getInteger(R.integer.keycode_numpad_4)] = VK_NUMPAD4;
377 keymapExt[context.getResources().getInteger(R.integer.keycode_numpad_5)] = VK_NUMPAD5;
378 keymapExt[context.getResources().getInteger(R.integer.keycode_numpad_6)] = VK_NUMPAD6;
379 keymapExt[context.getResources().getInteger(R.integer.keycode_numpad_7)] = VK_NUMPAD7;
380 keymapExt[context.getResources().getInteger(R.integer.keycode_numpad_8)] = VK_NUMPAD8;
381 keymapExt[context.getResources().getInteger(R.integer.keycode_numpad_9)] = VK_NUMPAD9;
382 keymapExt[context.getResources().getInteger(R.integer.keycode_numpad_numlock)] = VK_NUMLOCK;
383 keymapExt[context.getResources().getInteger(R.integer.keycode_numpad_add)] = VK_ADD;
384 keymapExt[context.getResources().getInteger(R.integer.keycode_numpad_comma)] = VK_DECIMAL;
385 keymapExt[context.getResources().getInteger(R.integer.keycode_comma)] = VK_OEM_COMMA;
386 keymapExt[context.getResources().getInteger(R.integer.keycode_numpad_divide)] =
387 VK_DIVIDE | VK_EXT_KEY;
388 keymapExt[context.getResources().getInteger(R.integer.keycode_numpad_enter)] =
389 VK_RETURN | VK_EXT_KEY;
390 keymapExt[context.getResources().getInteger(R.integer.keycode_numpad_multiply)] =
391 VK_MULTIPLY;
392 keymapExt[context.getResources().getInteger(R.integer.keycode_numpad_subtract)] =
393 VK_SUBTRACT;
394 keymapExt[context.getResources().getInteger(R.integer.keycode_numpad_equals)] =
395 (KEY_FLAG_UNICODE | 61);
396 keymapExt[context.getResources().getInteger(R.integer.keycode_numpad_left_paren)] =
397 (KEY_FLAG_UNICODE | 40);
398 keymapExt[context.getResources().getInteger(R.integer.keycode_numpad_right_paren)] =
399 (KEY_FLAG_UNICODE | 41);
400
401 // cursor key codes
402 keymapExt[context.getResources().getInteger(R.integer.keycode_up)] = VK_UP | VK_EXT_KEY;
403 keymapExt[context.getResources().getInteger(R.integer.keycode_down)] = VK_DOWN | VK_EXT_KEY;
404 keymapExt[context.getResources().getInteger(R.integer.keycode_left)] = VK_LEFT | VK_EXT_KEY;
405 keymapExt[context.getResources().getInteger(R.integer.keycode_right)] =
406 VK_RIGHT | VK_EXT_KEY;
407 keymapExt[context.getResources().getInteger(R.integer.keycode_enter)] =
408 VK_RETURN | VK_EXT_KEY;
409 keymapExt[context.getResources().getInteger(R.integer.keycode_backspace)] = VK_BACK;
410
411 // shared keys
412 keymapExt[context.getResources().getInteger(R.integer.keycode_win)] = VK_LWIN | VK_EXT_KEY;
413 keymapExt[context.getResources().getInteger(R.integer.keycode_menu)] = VK_APPS | VK_EXT_KEY;
414 keymapExt[context.getResources().getInteger(R.integer.keycode_esc)] = VK_ESCAPE;
415
416 /* keymapExt[context.getResources().getInteger(R.integer.keycode_modifier_ctrl)] =
417 VK_LCONTROL; keymapExt[context.getResources().getInteger(R.integer.keycode_modifier_alt)]
418 = VK_LMENU;
419 keymapExt[context.getResources().getInteger(R.integer.keycode_modifier_shift)] =
420 VK_LSHIFT;
421 */
422 // get custom keyboard key codes
423 keymapExt[context.getResources().getInteger(R.integer.keycode_specialkeys_keyboard)] =
424 EXTKEY_KBFUNCTIONKEYS;
425 keymapExt[context.getResources().getInteger(R.integer.keycode_numpad_keyboard)] =
426 EXTKEY_KBNUMPAD;
427
428 keymapExt[context.getResources().getInteger(R.integer.keycode_toggle_shift)] =
429 (KEY_FLAG_TOGGLE | VK_LSHIFT);
430 keymapExt[context.getResources().getInteger(R.integer.keycode_toggle_ctrl)] =
431 (KEY_FLAG_TOGGLE | VK_LCONTROL);
432 keymapExt[context.getResources().getInteger(R.integer.keycode_toggle_alt)] =
433 (KEY_FLAG_TOGGLE | VK_LMENU);
434 keymapExt[context.getResources().getInteger(R.integer.keycode_toggle_win)] =
435 (KEY_FLAG_TOGGLE | VK_LWIN);
436
437 initialized = true;
438 }

◆ processAndroidKeyEvent()

boolean com.freerdp.freerdpcore.utils.KeyboardMapper.processAndroidKeyEvent ( KeyEvent  event)
inline

Definition at line 456 of file KeyboardMapper.java.

457 {
458 switch (event.getAction())
459 {
460 // we only process down events
461 case KeyEvent.ACTION_UP:
462 {
463 if (event.getKeyCode() == KeyEvent.KEYCODE_META_LEFT ||
464 event.getKeyCode() == KeyEvent.KEYCODE_META_RIGHT)
465 {
466 if (!isWinKeyDown)
467 return false;
468 isWinKeyDown = false;
469 if (!isWinComboUsed)
470 {
471 listener.processVirtualKey(VK_LWIN | VK_EXT_KEY, true);
472 listener.processVirtualKey(VK_LWIN | VK_EXT_KEY, false);
473 }
474 isWinComboUsed = false;
475 return true;
476 }
477 return false;
478 }
479
480 case KeyEvent.ACTION_DOWN:
481 {
482 /* Physical Win key: buffer until release to distinguish tap vs combo. */
483 if (event.getKeyCode() == KeyEvent.KEYCODE_META_LEFT ||
484 event.getKeyCode() == KeyEvent.KEYCODE_META_RIGHT)
485 {
486 isWinKeyDown = true;
487 isWinComboUsed = false;
488 return true;
489 }
490
491 if (isWinKeyDown)
492 isWinComboUsed = true;
493
494 boolean modifierActive = isModifierPressed();
495 // if a modifier is pressed we will send a VK event (if possible) so that key
496 // combinations will be recognized correctly. Otherwise we will send the unicode
497 // key. At the end we will reset all modifiers and notify our listener.
498 int vkcode = getVirtualKeyCode(event.getKeyCode());
499 if ((vkcode & KEY_FLAG_UNICODE) != 0)
500 listener.processUnicodeKey(vkcode & (~KEY_FLAG_UNICODE));
501 // if we got a valid vkcode send it - except for letters/numbers if a modifier is
502 // active
503 else if (vkcode > 0 && !event.isSymPressed())
504 {
505 boolean sendCtrl = !ctrlPressed && event.isCtrlPressed();
506 boolean sendAlt = !altPressed && event.isAltPressed();
507 boolean sendWin = !winPressed && isWinKeyDown;
508 boolean sendShift = !shiftPressed && event.isShiftPressed();
509
510 if (sendCtrl)
511 listener.processVirtualKey(VK_LCONTROL, true);
512 if (sendAlt)
513 listener.processVirtualKey(VK_LMENU, true);
514 if (sendWin)
515 listener.processVirtualKey(VK_LWIN | VK_EXT_KEY, true);
516 if (sendShift)
517 listener.processVirtualKey(VK_LSHIFT, true);
518
519 listener.processVirtualKey(vkcode, true);
520 listener.processVirtualKey(vkcode, false);
521
522 if (sendShift)
523 listener.processVirtualKey(VK_LSHIFT, false);
524 if (sendWin)
525 listener.processVirtualKey(VK_LWIN | VK_EXT_KEY, false);
526 if (sendAlt)
527 listener.processVirtualKey(VK_LMENU, false);
528 if (sendCtrl)
529 listener.processVirtualKey(VK_LCONTROL, false);
530 }
531 else if (event.getUnicodeChar() != 0)
532 listener.processUnicodeKey(event.getUnicodeChar());
533 else
534 return false;
535
536 // reset any pending toggle states if a modifier was pressed
537 if (modifierActive)
538 resetModifierKeysAfterInput(false);
539 return true;
540 }
541
542 case KeyEvent.ACTION_MULTIPLE:
543 {
544 String str = event.getCharacters();
545 if (str != null)
546 {
547 for (int i = 0; i < str.length(); i++)
548 listener.processUnicodeKey(str.charAt(i));
549 }
550 return true;
551 }
552
553 default:
554 break;
555 }
556 return false;
557 }

◆ processCustomKeyEvent()

void com.freerdp.freerdpcore.utils.KeyboardMapper.processCustomKeyEvent ( int  keycode)
inline

Definition at line 559 of file KeyboardMapper.java.

560 {
561 int extCode = getExtendedKeyCode(keycode);
562 if (extCode == 0)
563 return;
564
565 // toggle button pressed?
566 if ((extCode & KEY_FLAG_TOGGLE) != 0)
567 {
568 processToggleButton(extCode & (~KEY_FLAG_TOGGLE), false);
569 return;
570 }
571
572 // keyboard switch button pressed?
573 if (extCode == EXTKEY_KBFUNCTIONKEYS || extCode == EXTKEY_KBNUMPAD)
574 {
575 switchKeyboard(extCode);
576 return;
577 }
578
579 // nope - see if we got a unicode or vk
580 if ((extCode & KEY_FLAG_UNICODE) != 0)
581 listener.processUnicodeKey(extCode & (~KEY_FLAG_UNICODE));
582 else
583 {
584 listener.processVirtualKey(extCode, true);
585 listener.processVirtualKey(extCode, false);
586 }
587
588 resetModifierKeysAfterInput(false);
589 }

◆ processCustomKeyLock()

boolean com.freerdp.freerdpcore.utils.KeyboardMapper.processCustomKeyLock ( int  keycode)
inline

Definition at line 592 of file KeyboardMapper.java.

593 {
594 int extCode = getExtendedKeyCode(keycode);
595 if ((extCode & KEY_FLAG_TOGGLE) == 0)
596 return false;
597
598 processToggleButton(extCode & (~KEY_FLAG_TOGGLE), true);
599 return true;
600 }

◆ processUnicodeFallback()

void com.freerdp.freerdpcore.utils.KeyboardMapper.processUnicodeFallback ( int  unicodeKey)
inline

Definition at line 602 of file KeyboardMapper.java.

603 {
604 KeyCharacterMap kcm = KeyCharacterMap.load(KeyCharacterMap.VIRTUAL_KEYBOARD);
605 KeyEvent[] events = kcm.getEvents(new char[] { (char)unicodeKey });
606 if (events == null)
607 return;
608 for (KeyEvent event : events)
609 {
610 int vkcode = fallbackVkcode(event.getKeyCode());
611 if (vkcode > 0)
612 listener.processVirtualKey(vkcode, event.getAction() == KeyEvent.ACTION_DOWN);
613 }
614 }

◆ reset()

void com.freerdp.freerdpcore.utils.KeyboardMapper.reset ( KeyProcessingListener  listener)
inline

Definition at line 440 of file KeyboardMapper.java.

441 {
442 shiftPressed = false;
443 ctrlPressed = false;
444 altPressed = false;
445 winPressed = false;
446 isWinKeyDown = false;
447 isWinComboUsed = false;
448 setKeyProcessingListener(listener);
449 }

◆ sendAltF4()

void com.freerdp.freerdpcore.utils.KeyboardMapper.sendAltF4 ( )
inline

Definition at line 634 of file KeyboardMapper.java.

635 {
636 listener.processVirtualKey(VK_LMENU, true);
637 listener.processVirtualKey(VK_F4, true);
638 listener.processVirtualKey(VK_F4, false);
639 listener.processVirtualKey(VK_LMENU, false);
640 }

◆ setKeyProcessingListener()

void com.freerdp.freerdpcore.utils.KeyboardMapper.setKeyProcessingListener ( KeyProcessingListener  listener)
inline

Definition at line 451 of file KeyboardMapper.java.

452 {
453 this.listener = listener;
454 }

Field Documentation

◆ KEYBOARD_TYPE_FUNCTIONKEYS

final int com.freerdp.freerdpcore.utils.KeyboardMapper.KEYBOARD_TYPE_FUNCTIONKEYS = 1
static

Definition at line 21 of file KeyboardMapper.java.

◆ KEYBOARD_TYPE_NUMPAD

final int com.freerdp.freerdpcore.utils.KeyboardMapper.KEYBOARD_TYPE_NUMPAD = 2
static

Definition at line 22 of file KeyboardMapper.java.

◆ KEYSTATE_LOCKED

final int com.freerdp.freerdpcore.utils.KeyboardMapper.KEYSTATE_LOCKED = 2
static

Definition at line 27 of file KeyboardMapper.java.

◆ KEYSTATE_OFF

final int com.freerdp.freerdpcore.utils.KeyboardMapper.KEYSTATE_OFF = 3
static

Definition at line 28 of file KeyboardMapper.java.

◆ KEYSTATE_ON

final int com.freerdp.freerdpcore.utils.KeyboardMapper.KEYSTATE_ON = 1
static

Definition at line 26 of file KeyboardMapper.java.

The documentation for this class was generated from the following file: