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)
 
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 KEYBOARD_TYPE_CURSOR = 3
 
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 746 of file KeyboardMapper.java.

747 {
748 resetModifierKeysAfterInput(true);
749 }

◆ getModifierState()

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

Definition at line 642 of file KeyboardMapper.java.

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

◆ init()

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

Definition at line 233 of file KeyboardMapper.java.

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

◆ processAndroidKeyEvent()

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

Definition at line 461 of file KeyboardMapper.java.

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

◆ processCustomKeyEvent()

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

Definition at line 564 of file KeyboardMapper.java.

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

◆ processUnicodeFallback()

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

Definition at line 597 of file KeyboardMapper.java.

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

◆ reset()

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

Definition at line 445 of file KeyboardMapper.java.

446 {
447 shiftPressed = false;
448 ctrlPressed = false;
449 altPressed = false;
450 winPressed = false;
451 isWinKeyDown = false;
452 isWinComboUsed = false;
453 setKeyProcessingListener(listener);
454 }

◆ sendAltF4()

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

Definition at line 629 of file KeyboardMapper.java.

630 {
631 listener.processVirtualKey(VK_LMENU, true);
632 listener.processVirtualKey(VK_F4, true);
633 listener.processVirtualKey(VK_F4, false);
634 listener.processVirtualKey(VK_LMENU, false);
635 }

◆ setKeyProcessingListener()

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

Definition at line 456 of file KeyboardMapper.java.

457 {
458 this.listener = listener;
459 }

Field Documentation

◆ KEYBOARD_TYPE_CURSOR

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

Definition at line 23 of file KeyboardMapper.java.

◆ 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 28 of file KeyboardMapper.java.

◆ KEYSTATE_OFF

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

Definition at line 29 of file KeyboardMapper.java.

◆ KEYSTATE_ON

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

Definition at line 27 of file KeyboardMapper.java.

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