/* Ctrl-Alt-Enter: toggle full screen */				if (pressed)					xwin_toggle_fullscreen();				return True;			}			break;		case XK_Break:			/* Send Break sequence E0 46 E0 C6 */			if (pressed)			{				rdp_send_scancode(ev_time, RDP_KEYPRESS,						  (SCANCODE_EXTENDED | 0x46));				rdp_send_scancode(ev_time, RDP_KEYPRESS,						  (SCANCODE_EXTENDED | 0xc6));			}			/* No release sequence */			return True;			break;		case XK_Pause:			/* According to MS Keyboard Scan Code			   Specification, pressing Pause should result			   in E1 1D 45 E1 9D C5. I'm not exactly sure			   of how this is supposed to be sent via			   RDP. The code below seems to work, but with			   the side effect that Left Ctrl stays			   down. Therefore, we release it when Pause			   is released. */			if (pressed)			{				rdp_send_input(ev_time, RDP_INPUT_SCANCODE, RDP_KEYPRESS, 0xe1, 0);				rdp_send_input(ev_time, RDP_INPUT_SCANCODE, RDP_KEYPRESS, 0x1d, 0);				rdp_send_input(ev_time, RDP_INPUT_SCANCODE, RDP_KEYPRESS, 0x45, 0);				rdp_send_input(ev_time, RDP_INPUT_SCANCODE, RDP_KEYPRESS, 0xe1, 0);				rdp_send_input(ev_time, RDP_INPUT_SCANCODE, RDP_KEYPRESS, 0x9d, 0);				rdp_send_input(ev_time, RDP_INPUT_SCANCODE, RDP_KEYPRESS, 0xc5, 0);			}			else			{				/* Release Left Ctrl */				rdp_send_input(ev_time, RDP_INPUT_SCANCODE, RDP_KEYRELEASE,					       0x1d, 0);			}			return True;			break;		case XK_Meta_L:	/* Windows keys */		case XK_Super_L:		case XK_Hyper_L:			send_winkey(ev_time, pressed, True);			return True;			break;		case XK_Meta_R:		case XK_Super_R:		case XK_Hyper_R:			send_winkey(ev_time, pressed, False);			return True;			break;		case XK_space:			/* Prevent access to the Windows system menu in single app mode */			if (g_win_button_size			    && (get_key_state(state, XK_Alt_L) || get_key_state(state, XK_Alt_R)))				return True;			break;		case XK_Num_Lock:			/* Synchronize on key release */			if (g_numlock_sync && !pressed)				rdp_send_input(0, RDP_INPUT_SYNCHRONIZE, 0,					       ui_get_numlock_state(read_keyboard_state()), 0);			/* Inhibit */			return True;			break;		case XK_Overlay1_Enable:			/* Toggle SeamlessRDP */			if (pressed)				ui_seamless_toggle();			break;	}	return False;}key_translationxkeymap_translate_key(uint32 keysym, unsigned int keycode, unsigned int state){	key_translation tr = { 0, 0, 0, 0 };	key_translation *ptr;	ptr = keymap[keysym & KEYMAP_MASK];	if (ptr)	{		tr = *ptr;		if (tr.seq_keysym == 0)	/* Normal scancode translation */		{			if (MASK_HAS_BITS(tr.modifiers, MapInhibitMask))			{				DEBUG_KBD(("Inhibiting key\n"));				tr.scancode = 0;				return tr;			}			if (MASK_HAS_BITS(tr.modifiers, MapLocalStateMask))			{				/* The modifiers to send for this key should be obtained				   from the local state. Currently, only shift is implemented. */				if (MASK_HAS_BITS(state, ShiftMask))				{					tr.modifiers = MapLeftShiftMask;				}			}			/* Windows interprets CapsLock+Ctrl+key			   differently from Shift+Ctrl+key. Since we			   are simulating CapsLock with Shifts, things			   like Ctrl+f with CapsLock on breaks. To			   solve this, we are releasing Shift if Ctrl			   is on, but only if Shift isn't physically pressed. */			if (MASK_HAS_BITS(tr.modifiers, MapShiftMask)			    && MASK_HAS_BITS(remote_modifier_state, MapCtrlMask)			    && !MASK_HAS_BITS(state, ShiftMask))			{				DEBUG_KBD(("Non-physical Shift + Ctrl pressed, releasing Shift\n"));				MASK_REMOVE_BITS(tr.modifiers, MapShiftMask);			}			DEBUG_KBD(("Found scancode translation, scancode=0x%x, modifiers=0x%x\n",				   tr.scancode, tr.modifiers));		}	}	else	{		if (keymap_loaded)			warning("No translation for (keysym 0x%lx, %s)\n", keysym,				get_ksname(keysym));		/* not in keymap, try to interpret the raw scancode */		if (((int) keycode >= min_keycode) && (keycode <= 0x60))		{			tr.scancode = keycode - min_keycode;			/* The modifiers to send for this key should be			   obtained from the local state. Currently, only			   shift is implemented. */			if (MASK_HAS_BITS(state, ShiftMask))			{				tr.modifiers = MapLeftShiftMask;			}			DEBUG_KBD(("Sending guessed scancode 0x%x\n", tr.scancode));		}		else		{			DEBUG_KBD(("No good guess for keycode 0x%x found\n", keycode));		}	}	return tr;}static RD_BOOLis_modifier(uint8 scancode){	switch (scancode)	{		case SCANCODE_CHAR_LSHIFT:		case SCANCODE_CHAR_RSHIFT:		case SCANCODE_CHAR_LCTRL:		case SCANCODE_CHAR_RCTRL:		case SCANCODE_CHAR_LALT:		case SCANCODE_CHAR_RALT:		case SCANCODE_CHAR_LWIN:		case SCANCODE_CHAR_RWIN:		case SCANCODE_CHAR_NUMLOCK:			return True;		default:			break;	}	return False;}voidxkeymap_send_keys(uint32 keysym, unsigned int keycode, unsigned int state, uint32 ev_time,		  RD_BOOL pressed, uint8 nesting){	key_translation tr, *ptr;	tr = xkeymap_translate_key(keysym, keycode, state);	if (tr.seq_keysym == 0)	{		/* Scancode translation */		if (tr.scancode == 0)			return;		save_remote_modifiers(tr.scancode);		ensure_remote_modifiers(ev_time, tr);		rdp_send_scancode(ev_time, pressed ? RDP_KEYPRESS : RDP_KEYRELEASE, tr.scancode);		restore_remote_modifiers(ev_time, tr.scancode);		return;	}	/* Sequence, only on key down */	if (pressed)	{		ptr = &tr;		do		{			DEBUG_KBD(("Handling sequence element, keysym=0x%x\n",				   (unsigned int) ptr->seq_keysym));			if (nesting++ > 32)			{				error("Sequence nesting too deep\n");				return;			}			xkeymap_send_keys(ptr->seq_keysym, keycode, state, ev_time, True, nesting);			xkeymap_send_keys(ptr->seq_keysym, keycode, state, ev_time, False, nesting);			ptr = ptr->next;		}		while (ptr);	}}uint16xkeymap_translate_button(unsigned int button){	switch (button)	{		case Button1:	/* left */			return MOUSE_FLAG_BUTTON1;		case Button2:	/* middle */			return MOUSE_FLAG_BUTTON3;		case Button3:	/* right */			return MOUSE_FLAG_BUTTON2;		case Button4:	/* wheel up */			return MOUSE_FLAG_BUTTON4;		case Button5:	/* wheel down */			return MOUSE_FLAG_BUTTON5;	}	return 0;}char *get_ksname(uint32 keysym){	char *ksname = NULL;	if (keysym == NoSymbol)		ksname = "NoSymbol";	else if (!(ksname = XKeysymToString(keysym)))		ksname = "(no name)";	return ksname;}voidsave_remote_modifiers(uint8 scancode){	if (is_modifier(scancode))		return;	saved_remote_modifier_state = remote_modifier_state;}voidrestore_remote_modifiers(uint32 ev_time, uint8 scancode){	key_translation dummy;	if (is_modifier(scancode))		return;	dummy.scancode = 0;	dummy.modifiers = saved_remote_modifier_state;	ensure_remote_modifiers(ev_time, dummy);}voidensure_remote_modifiers(uint32 ev_time, key_translation tr){	/* If this key is a modifier, do nothing */	if (is_modifier(tr.scancode))		return;	if (!g_numlock_sync)	{		/* NumLock */		if (MASK_HAS_BITS(tr.modifiers, MapNumLockMask)		    != MASK_HAS_BITS(remote_modifier_state, MapNumLockMask))		{			/* The remote modifier state is not correct */			uint16 new_remote_state;			if (MASK_HAS_BITS(tr.modifiers, MapNumLockMask))			{				DEBUG_KBD(("Remote NumLock state is incorrect, activating NumLock.\n"));				new_remote_state = KBD_FLAG_NUMLOCK;				remote_modifier_state = MapNumLockMask;			}			else			{				DEBUG_KBD(("Remote NumLock state is incorrect, deactivating NumLock.\n"));				new_remote_state = 0;				remote_modifier_state = 0;			}			rdp_send_input(0, RDP_INPUT_SYNCHRONIZE, 0, new_remote_state, 0);		}	}	/* Shift. Left shift and right shift are treated as equal; either is fine. */	if (MASK_HAS_BITS(tr.modifiers, MapShiftMask)	    != MASK_HAS_BITS(remote_modifier_state, MapShiftMask))	{		/* The remote modifier state is not correct */		if (MASK_HAS_BITS(tr.modifiers, MapLeftShiftMask))		{			/* Needs left shift. Send down. */			rdp_send_scancode(ev_time, RDP_KEYPRESS, SCANCODE_CHAR_LSHIFT);		}		else if (MASK_HAS_BITS(tr.modifiers, MapRightShiftMask))		{			/* Needs right shift. Send down. */			rdp_send_scancode(ev_time, RDP_KEYPRESS, SCANCODE_CHAR_RSHIFT);		}		else		{			/* Should not use this modifier. Send up for shift currently pressed. */			if (MASK_HAS_BITS(remote_modifier_state, MapLeftShiftMask))				/* Left shift is down */				rdp_send_scancode(ev_time, RDP_KEYRELEASE, SCANCODE_CHAR_LSHIFT);			else				/* Right shift is down */				rdp_send_scancode(ev_time, RDP_KEYRELEASE, SCANCODE_CHAR_RSHIFT);		}	}	/* AltGr */	if (MASK_HAS_BITS(tr.modifiers, MapAltGrMask)	    != MASK_HAS_BITS(remote_modifier_state, MapAltGrMask))	{		/* The remote modifier state is not correct */		if (MASK_HAS_BITS(tr.modifiers, MapAltGrMask))		{			/* Needs this modifier. Send down. */			rdp_send_scancode(ev_time, RDP_KEYPRESS, SCANCODE_CHAR_RALT);		}		else		{			/* Should not use this modifier. Send up. */			rdp_send_scancode(ev_time, RDP_KEYRELEASE, SCANCODE_CHAR_RALT);		}	}}unsigned intread_keyboard_state(){#ifdef RDP2VNC	return 0;#else	unsigned int state;	Window wdummy;	int dummy;	XQueryPointer(g_display, g_wnd, &wdummy, &wdummy, &dummy, &dummy, &dummy, &dummy, &state);	return state;#endif}uint16ui_get_numlock_state(unsigned int state){	uint16 numlock_state = 0;	if (get_key_state(state, XK_Num_Lock))		numlock_state = KBD_FLAG_NUMLOCK;	return numlock_state;}voidreset_modifier_keys(){	unsigned int state = read_keyboard_state();	/* reset keys */	uint32 ev_time;	ev_time = time(NULL);	if (MASK_HAS_BITS(remote_modifier_state, MapLeftShiftMask)	    && !get_key_state(state, XK_Shift_L))		rdp_send_scancode(ev_time, RDP_KEYRELEASE, SCANCODE_CHAR_LSHIFT);	if (MASK_HAS_BITS(remote_modifier_state, MapRightShiftMask)	    && !get_key_state(state, XK_Shift_R))		rdp_send_scancode(ev_time, RDP_KEYRELEASE, SCANCODE_CHAR_RSHIFT);	if (MASK_HAS_BITS(remote_modifier_state, MapLeftCtrlMask)	    && !get_key_state(state, XK_Control_L))		rdp_send_scancode(ev_time, RDP_KEYRELEASE, SCANCODE_CHAR_LCTRL);	if (MASK_HAS_BITS(remote_modifier_state, MapRightCtrlMask)	    && !get_key_state(state, XK_Control_R))		rdp_send_scancode(ev_time, RDP_KEYRELEASE, SCANCODE_CHAR_RCTRL);	if (MASK_HAS_BITS(remote_modifier_state, MapLeftAltMask) && !get_key_state(state, XK_Alt_L))		rdp_send_scancode(ev_time, RDP_KEYRELEASE, SCANCODE_CHAR_LALT);	if (MASK_HAS_BITS(remote_modifier_state, MapRightAltMask) &&	    !get_key_state(state, XK_Alt_R) && !get_key_state(state, XK_Mode_switch)	    && !get_key_state(state, XK_ISO_Level3_Shift))		rdp_send_scancode(ev_time, RDP_KEYRELEASE, SCANCODE_CHAR_RALT);	reset_winkey(ev_time);	if (g_numlock_sync)		rdp_send_input(ev_time, RDP_INPUT_SYNCHRONIZE, 0, ui_get_numlock_state(state), 0);}static voidupdate_modifier_state(uint8 scancode, RD_BOOL pressed){#ifdef WITH_DEBUG_KBD	uint16 old_modifier_state;	old_modifier_state = remote_modifier_state;#endif	switch (scancode)	{		case SCANCODE_CHAR_LSHIFT:			MASK_CHANGE_BIT(remote_modifier_state, MapLeftShiftMask, pressed);			break;		case SCANCODE_CHAR_RSHIFT:			MASK_CHANGE_BIT(remote_modifier_state, MapRightShiftMask, pressed);			break;		case SCANCODE_CHAR_LCTRL:			MASK_CHANGE_BIT(remote_modifier_state, MapLeftCtrlMask, pressed);			break;		case SCANCODE_CHAR_RCTRL:			MASK_CHANGE_BIT(remote_modifier_state, MapRightCtrlMask, pressed);			break;		case SCANCODE_CHAR_LALT:			MASK_CHANGE_BIT(remote_modifier_state, MapLeftAltMask, pressed);			break;		case SCANCODE_CHAR_RALT:			MASK_CHANGE_BIT(remote_modifier_state, MapRightAltMask, pressed);			break;		case SCANCODE_CHAR_LWIN:			MASK_CHANGE_BIT(remote_modifier_state, MapLeftWinMask, pressed);			break;		case SCANCODE_CHAR_RWIN:			MASK_CHANGE_BIT(remote_modifier_state, MapRightWinMask, pressed);			break;		case SCANCODE_CHAR_NUMLOCK:			/* KeyReleases for NumLocks are sent immediately. Toggle the			   modifier state only on Keypress */			if (pressed && !g_numlock_sync)			{				RD_BOOL newNumLockState;				newNumLockState =					(MASK_HAS_BITS					 (remote_modifier_state, MapNumLockMask) == False);				MASK_CHANGE_BIT(remote_modifier_state,						MapNumLockMask, newNumLockState);			}	}#ifdef WITH_DEBUG_KBD	if (old_modifier_state != remote_modifier_state)	{		DEBUG_KBD(("Before updating modifier_state:0x%x, pressed=0x%x\n",			   old_modifier_state, pressed));		DEBUG_KBD(("After updating modifier_state:0x%x\n", remote_modifier_state));	}#endif}/* Send keyboard input */voidrdp_send_scancode(uint32 time, uint16 flags, uint8 scancode){	update_modifier_state(scancode, !(flags & RDP_KEYRELEASE));	if (scancode & SCANCODE_EXTENDED)	{		DEBUG_KBD(("Sending extended scancode=0x%x, flags=0x%x\n",			   scancode & ~SCANCODE_EXTENDED, flags));		rdp_send_input(time, RDP_INPUT_SCANCODE, flags | KBD_FLAG_EXT,			       scancode & ~SCANCODE_EXTENDED, 0);	}	else	{		DEBUG_KBD(("Sending scancode=0x%x, flags=0x%x\n", scancode, flags));		rdp_send_input(time, RDP_INPUT_SCANCODE, flags, scancode, 0);	}}