BOOL wlf_handle_key(freerdp *instance, UwacKeyEvent *ev) {
rdpInput* input = instance->input;
DWORD rdp_scancode;
rdp_scancode = freerdp_keyboard_get_rdp_scancode_from_x11_keycode(ev->raw_key + 8);
if (rdp_scancode == RDP_SCANCODE_UNKNOWN)
return TRUE;
return freerdp_input_send_keyboard_event_ex(input, ev->pressed, rdp_scancode);
}
void xf_kbd_release_all_keypress(xfInfo* xfi)
{
int keycode;
RDP_SCANCODE rdp_scancode;
for (keycode = 0; keycode < ARRAY_SIZE(xfi->pressed_keys); keycode++)
{
if (xfi->pressed_keys[keycode] != NoSymbol)
{
rdp_scancode = freerdp_keyboard_get_rdp_scancode_from_x11_keycode(keycode);
freerdp_input_send_keyboard_event_2(xfi->instance->input, false, rdp_scancode);
xfi->pressed_keys[keycode] = NoSymbol;
}
}
}
void xf_kbd_release_all_keypress(xfContext* xfc)
{
int keycode;
DWORD rdp_scancode;
for (keycode = 0; keycode < ARRAYSIZE(xfc->pressed_keys); keycode++)
{
if (xfc->pressed_keys[keycode] != NoSymbol)
{
rdp_scancode = freerdp_keyboard_get_rdp_scancode_from_x11_keycode(keycode);
freerdp_input_send_keyboard_event_ex(xfc->instance->input, FALSE, rdp_scancode);
xfc->pressed_keys[keycode] = NoSymbol;
}
}
}
void xf_kbd_send_key(xfInfo* xfi, boolean down, uint8 keycode)
{
uint16 flags;
uint8 scancode;
boolean extended;
rdpInput* input;
input = xfi->instance->input;
scancode = freerdp_keyboard_get_rdp_scancode_from_x11_keycode(keycode, &extended);
if (scancode == 0)
{
/* unknown key */
}
else if ((scancode == 0x46) && extended &&
!xf_kbd_key_pressed(xfi, XK_Control_L) && !xf_kbd_key_pressed(xfi, XK_Control_R))
{
/* Pause without Ctrl has to be sent as Ctrl + NumLock. */
if (down)
{
input->KeyboardEvent(input, KBD_FLAGS_DOWN, 0x1D); /* Ctrl down */
input->KeyboardEvent(input, KBD_FLAGS_DOWN, 0x45); /* NumLock down */
input->KeyboardEvent(input, KBD_FLAGS_RELEASE, 0x1D); /* Ctrl up */
input->KeyboardEvent(input, KBD_FLAGS_RELEASE, 0x45); /* NumLock up */
}
}
else
{
flags = (extended) ? KBD_FLAGS_EXTENDED : 0;
flags |= (down) ? KBD_FLAGS_DOWN : KBD_FLAGS_RELEASE;
input->KeyboardEvent(input, flags, scancode);
if ((scancode == 0x3A) && (down == false)) /* caps lock was released */
{
uint32 syncFlags;
syncFlags = xf_kbd_get_toggle_keys_state(xfi);
input->SynchronizeEvent(input, syncFlags);
}
}
}
void xf_keyboard_release_all_keypress(xfContext* xfc)
{
int keycode;
DWORD rdp_scancode;
for (keycode = 0; keycode < ARRAYSIZE(xfc->KeyboardState); keycode++)
{
if (xfc->KeyboardState[keycode])
{
rdp_scancode = freerdp_keyboard_get_rdp_scancode_from_x11_keycode(keycode);
// release tab before releasing the windows key.
// this stops the start menu from opening on unfocus event.
if (rdp_scancode == RDP_SCANCODE_LWIN)
freerdp_input_send_keyboard_event_ex(xfc->instance->input, FALSE, RDP_SCANCODE_TAB);
freerdp_input_send_keyboard_event_ex(xfc->instance->input, FALSE, rdp_scancode);
xfc->KeyboardState[keycode] = FALSE;
}
}
}
void xf_kbd_send_key(xfContext* xfc, BOOL down, BYTE keycode)
{
DWORD rdp_scancode;
rdpInput* input;
input = xfc->instance->input;
rdp_scancode = freerdp_keyboard_get_rdp_scancode_from_x11_keycode(keycode);
if (rdp_scancode == RDP_SCANCODE_UNKNOWN)
{
fprintf(stderr, "Unknown key with X keycode 0x%02x\n", keycode);
}
else if (rdp_scancode == RDP_SCANCODE_PAUSE &&
!xf_kbd_key_pressed(xfc, XK_Control_L) && !xf_kbd_key_pressed(xfc, XK_Control_R))
{
/* Pause without Ctrl has to be sent as a series of keycodes
* in a single input PDU. Pause only happens on "press";
* no code is sent on "release".
*/
if (down)
{
freerdp_input_send_keyboard_pause_event(input);
}
}
else
{
freerdp_input_send_keyboard_event_ex(input, down, rdp_scancode);
if ((rdp_scancode == RDP_SCANCODE_CAPSLOCK) && (down == FALSE))
{
UINT32 syncFlags;
syncFlags = xf_kbd_get_toggle_keys_state(xfc);
input->SynchronizeEvent(input, syncFlags);
}
}
}
void xf_kbd_send_key(xfInfo* xfi, BOOL down, BYTE keycode)
{
DWORD rdp_scancode;
rdpInput* input;
input = xfi->instance->input;
rdp_scancode = freerdp_keyboard_get_rdp_scancode_from_x11_keycode(keycode);
if (rdp_scancode == RDP_SCANCODE_UNKNOWN)
{
fprintf(stderr, "Unknown key with X keycode 0x%02x\n", keycode);
}
else if (rdp_scancode == RDP_SCANCODE_PAUSE &&
!xf_kbd_key_pressed(xfi, XK_Control_L) && !xf_kbd_key_pressed(xfi, XK_Control_R))
{
/* Pause without Ctrl has to be sent as Ctrl + NumLock. */
if (down)
{
freerdp_input_send_keyboard_event_ex(input, TRUE, RDP_SCANCODE_LCONTROL);
freerdp_input_send_keyboard_event_ex(input, TRUE, RDP_SCANCODE_NUMLOCK);
freerdp_input_send_keyboard_event_ex(input, FALSE, RDP_SCANCODE_LCONTROL);
freerdp_input_send_keyboard_event_ex(input, FALSE, RDP_SCANCODE_NUMLOCK);
}
}
else
{
freerdp_input_send_keyboard_event_ex(input, down, rdp_scancode);
if ((rdp_scancode == RDP_SCANCODE_CAPSLOCK) && (down == FALSE))
{
UINT32 syncFlags;
syncFlags = xf_kbd_get_toggle_keys_state(xfi);
input->SynchronizeEvent(input, syncFlags);
}
}
}
void xf_kbd_send_key(xfInfo* xfi, boolean down, uint8 keycode)
{
RDP_SCANCODE rdp_scancode;
rdpInput* input;
input = xfi->instance->input;
rdp_scancode = freerdp_keyboard_get_rdp_scancode_from_x11_keycode(keycode);
if (rdp_scancode == RDP_SCANCODE_UNKNOWN)
{
printf("Unknown key with X keycode 0x%02x\n", keycode);
}
else if (rdp_scancode == RDP_SCANCODE_PAUSE &&
!xf_kbd_key_pressed(xfi, XK_Control_L) && !xf_kbd_key_pressed(xfi, XK_Control_R))
{
/* Pause without Ctrl has to be sent as Ctrl + NumLock. */
if (down)
{
freerdp_input_send_keyboard_event_2(input, true, RDP_SCANCODE_LCONTROL);
freerdp_input_send_keyboard_event_2(input, true, RDP_SCANCODE_NUMLOCK);
freerdp_input_send_keyboard_event_2(input, false, RDP_SCANCODE_LCONTROL);
freerdp_input_send_keyboard_event_2(input, false, RDP_SCANCODE_NUMLOCK);
}
}
else
{
freerdp_input_send_keyboard_event_2(input, down, rdp_scancode);
if ((rdp_scancode == RDP_SCANCODE_CAPSLOCK) && (down == false))
{
uint32 syncFlags;
syncFlags = xf_kbd_get_toggle_keys_state(xfi);
input->SynchronizeEvent(input, syncFlags);
}
}
}
static gboolean remmina_rdp_event_on_key(GtkWidget* widget, GdkEventKey* event, RemminaProtocolWidget* gp)
{
GdkDisplay* display;
guint16 cooked_keycode;
rfContext* rfi;
RemminaPluginRdpEvent rdp_event;
rfi = GET_DATA(gp);
rdp_event.type = REMMINA_RDP_EVENT_TYPE_SCANCODE;
rdp_event.key_event.up = (event->type == GDK_KEY_PRESS ? False : True);
rdp_event.key_event.extended = False;
switch (event->keyval)
{
case GDK_KEY_Pause:
rdp_event.key_event.key_code = 0x1D;
rdp_event.key_event.up = False;
remmina_rdp_event_event_push(gp, &rdp_event);
rdp_event.key_event.key_code = 0x45;
rdp_event.key_event.up = False;
remmina_rdp_event_event_push(gp, &rdp_event);
rdp_event.key_event.key_code = 0x1D;
rdp_event.key_event.up = True;
remmina_rdp_event_event_push(gp, &rdp_event);
rdp_event.key_event.key_code = 0x45;
rdp_event.key_event.up = True;
remmina_rdp_event_event_push(gp, &rdp_event);
break;
default:
if (!rfi->use_client_keymap)
{
rdp_event.key_event.key_code = freerdp_keyboard_get_rdp_scancode_from_x11_keycode(event->hardware_keycode);
remmina_plugin_service->log_printf("[RDP]keyval=%04X keycode=%i scancode=%i extended=%i\n",
event->keyval, event->hardware_keycode, rdp_event.key_event.key_code, &rdp_event.key_event.extended);
}
else
{
//TODO: Port to GDK functions
display = gdk_display_get_default();
cooked_keycode = XKeysymToKeycode(GDK_DISPLAY_XDISPLAY(display), XKeycodeToKeysym(GDK_DISPLAY_XDISPLAY(display), event->hardware_keycode, 0));
rdp_event.key_event.key_code = freerdp_keyboard_get_rdp_scancode_from_x11_keycode(cooked_keycode);
remmina_plugin_service->log_printf("[RDP]keyval=%04X raw_keycode=%i cooked_keycode=%i scancode=%i extended=%i\n",
event->keyval, event->hardware_keycode, cooked_keycode, rdp_event.key_event.key_code, &rdp_event.key_event.extended);
}
if (rdp_event.key_event.key_code)
remmina_rdp_event_event_push(gp, &rdp_event);
break;
}
/* Register/unregister the pressed key */
if (rdp_event.key_event.key_code)
{
if (event->type == GDK_KEY_PRESS)
g_array_append_val(rfi->pressed_keys, rdp_event.key_event.key_code);
else
remmina_rdp_event_release_key(gp, rdp_event.key_event.key_code);
}
return TRUE;
}
