trunk/rdesktop/xkeymap.c

/*
   rdesktop: A Remote Desktop Protocol client.
   User interface services - X keyboard mapping
   Copyright (C) Matthew Chapman 1999-2001
   
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.
   
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
   
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/

#include <X11/Xlib.h>
#include <X11/keysym.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <limits.h>
#include "rdesktop.h"
#include "scancodes.h"

#define KEYMAP_SIZE 4096
#define KEYMAP_MASK (KEYMAP_SIZE - 1)
#define KEYMAP_MAX_LINE_LENGTH 80

extern Display *display;
extern char keymapname[16];
extern int keylayout;

static key_translation keymap[KEYMAP_SIZE];
static unsigned int min_keycode;
static uint16 remote_modifier_state = 0;

static void
add_to_keymap(char *keyname, uint8 scancode, uint16 modifiers, char *mapname)
{
        KeySym keysym;

        keysym = XStringToKeysym(keyname);
        if (keysym == NoSymbol)
        {
                error("Bad keysym %s in keymap %s\n", keyname, mapname);
                return;
        }

        DEBUG_KBD("Adding translation, keysym=0x%x, scancode=0x%x, "
                  "modifiers=0x%x\n", (unsigned int) keysym, scancode,
                  modifiers);

        keymap[keysym & KEYMAP_MASK].scancode = scancode;
        keymap[keysym & KEYMAP_MASK].modifiers = modifiers;

        return;
}


static BOOL
xkeymap_read(char *mapname)
{
        FILE *fp;
        char line[KEYMAP_MAX_LINE_LENGTH], path[PATH_MAX];
        unsigned int line_num = 0;
        unsigned int line_length = 0;
        char *keyname, *p;
        char *line_rest;
        uint8 scancode;
        uint16 modifiers;


        strcpy(path, KEYMAP_PATH);
        strncat(path, mapname, sizeof(path) - sizeof(KEYMAP_PATH));

        fp = fopen(path, "r");
        if (fp == NULL)
        {
                error("Failed to open keymap %s\n", path);
                return False;
        }

        /* FIXME: More tolerant on white space */
        while (fgets(line, sizeof(line), fp) != NULL)
        {
                line_num++;

                /* Replace the \n with \0 */
                p = strchr(line, '\n');
                if (p != NULL)
                        *p = 0;

                line_length = strlen(line);

                /* Completely empty line */
                if (strspn(line, " \t\n\r\f\v") == line_length)
                {
                        continue;
                }

                /* Include */
                if (strncmp(line, "include ", 8) == 0)
                {
                        if (!xkeymap_read(line + 8))
                                return False;
                        continue;
                }

                /* map */
                if (strncmp(line, "map ", 4) == 0)
                {
                        keylayout = strtol(line + 4, NULL, 16);
                        DEBUG_KBD("Keylayout 0x%x\n", keylayout);
                        continue;
                }

                /* Comment */
                if (line[0] == '#')
                {
                        continue;
                }

                /* Normal line */
                keyname = line;
                p = strchr(line, ' ');
                if (p == NULL)
                {
                        error("Bad line %d in keymap %s\n", line_num,
                              mapname);
                        continue;
                }
                else
                {
                        *p = 0;
                }

                /* scancode */
                p++;
                scancode = strtol(p, &line_rest, 16);

                /* flags */
                /* FIXME: Should allow case-insensitive flag names. 
                   Fix by using lex+yacc... */
                modifiers = 0;
                if (strstr(line_rest, "altgr"))
                {
                        MASK_ADD_BITS(modifiers, MapAltGrMask);
                }

                if (strstr(line_rest, "shift"))
                {
                        MASK_ADD_BITS(modifiers, MapLeftShiftMask);
                }

                if (strstr(line_rest, "numlock"))
                {
                        MASK_ADD_BITS(modifiers, MapNumLockMask);
                }

                if (strstr(line_rest, "localstate"))
                {
                        MASK_ADD_BITS(modifiers, MapLocalStateMask);
                }

                add_to_keymap(keyname, scancode, modifiers, mapname);

                if (strstr(line_rest, "addupper"))
                {
                        /* Automatically add uppercase key, with same modifiers 
                           plus shift */
                        for (p = keyname; *p; p++)
                                *p = toupper(*p);
                        MASK_ADD_BITS(modifiers, MapLeftShiftMask);
                        add_to_keymap(keyname, scancode, modifiers, mapname);
                }
        }

        fclose(fp);
        return True;
}


/* Before connecting and creating UI */
void
xkeymap_init1(void)
{
        int i;

        /* Zeroing keymap */
        for (i = 0; i < KEYMAP_SIZE; i++)
        {
                keymap[i].scancode = 0;
                keymap[i].modifiers = 0;
        }

        if (strcmp(keymapname, "none"))
        {
                xkeymap_read(keymapname);
        }

}

/* After connecting and creating UI */
void
xkeymap_init2(void)
{
        unsigned int max_keycode;
        XDisplayKeycodes(display, &min_keycode, &max_keycode);
}


key_translation
xkeymap_translate_key(KeySym keysym, unsigned int keycode, unsigned int state)
{
        key_translation tr = { 0, 0 };

        tr = keymap[keysym & KEYMAP_MASK];

        if (tr.modifiers & MapLocalStateMask)
        {
                /* The modifiers to send for this key should be obtained
                   from the local state. Currently, only shift is implemented. */
                if (state & ShiftMask)
                {
                        tr.modifiers = MapLeftShiftMask;
                }
        }

        if (tr.scancode != 0)
        {
                DEBUG_KBD
                        ("Found key translation, scancode=0x%x, modifiers=0x%x\n",
                         tr.scancode, tr.modifiers);
                return tr;
        }

        printf("No translation for (keysym 0x%lx, %s)\n", keysym,
               get_ksname(keysym));

        /* not in keymap, try to interpret the raw scancode */
        if ((keycode >= min_keycode) && (keycode <= 0x60))
        {
                tr.scancode = keycode - min_keycode;
                printf("Sending guessed scancode 0x%x\n", tr.scancode);
        }
        else
        {
                printf("No good guess for keycode 0x%x found\n", keycode);
        }

        return tr;
}

uint16
xkeymap_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(KeySym keysym)
{
        char *ksname = NULL;

        if (keysym == NoSymbol)
                ksname = "NoSymbol";
        else if (!(ksname = XKeysymToString(keysym)))
                ksname = "(no name)";

        return ksname;
}

BOOL
inhibit_key(KeySym keysym)
{
        switch (keysym)
        {
                case XK_Caps_Lock:
                        return True;
                        break;
                case XK_Multi_key:
                        return True;
                        break;
                default:
                        break;
        }
        return False;
}

void
ensure_remote_modifiers(uint32 ev_time, key_translation tr)
{
        /* If this key is a modifier, do nothing */
        switch (tr.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;
                default:
                        break;
        }

        /* Shift */
        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, MapShiftMask))
                {
                        /* Needs this modifier. Send down. */
                        rdp_send_scancode(ev_time, RDP_KEYPRESS,
                                          SCANCODE_CHAR_LSHIFT);
                }
                else
                {
                        /* Should not use this modifier. Send up. */
                        rdp_send_scancode(ev_time, RDP_KEYRELEASE,
                                          SCANCODE_CHAR_LSHIFT);
                }
        }

        /* 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);
                }
        }

        /* NumLock */
        if (MASK_HAS_BITS(tr.modifiers, MapNumLockMask)
            != MASK_HAS_BITS(remote_modifier_state, MapNumLockMask))
        {
                /* The remote modifier state is not correct */
                DEBUG_KBD("Remote NumLock state is incorrect. Toggling\n");
                if (MASK_HAS_BITS(tr.modifiers, MapNumLockMask))
                {
                        /* Needs this modifier. Toggle */
                        rdp_send_scancode(ev_time, RDP_KEYPRESS,
                                          SCANCODE_CHAR_NUMLOCK);
                        rdp_send_scancode(ev_time, RDP_KEYRELEASE,
                                          SCANCODE_CHAR_NUMLOCK);
                }
                else
                {
                        /* Should not use this modifier. Toggle */
                        rdp_send_scancode(ev_time, RDP_KEYPRESS,
                                          SCANCODE_CHAR_NUMLOCK);
                        rdp_send_scancode(ev_time, RDP_KEYRELEASE,
                                          SCANCODE_CHAR_NUMLOCK);
                }
        }

}


static void
update_modifier_state(uint16 modifiers, BOOL pressed)
{

        DEBUG_KBD("Before updating modifier_state:0x%x, pressed=0x%x\n",
                  remote_modifier_state, pressed);
        switch (modifiers)
        {
                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)
                        {
                                BOOL newNumLockState;
                                newNumLockState =
                                        (MASK_HAS_BITS
                                         (remote_modifier_state,
                                          MapNumLockMask) == False);
                                MASK_CHANGE_BIT(remote_modifier_state,
                                                MapNumLockMask,
                                                newNumLockState);
                        }
                        break;
        }
        DEBUG_KBD("After updating modifier_state:0x%x\n",
                  remote_modifier_state);

}

/* Send keyboard input */
void
rdp_send_scancode(uint32 time, uint16 flags, uint16 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);
        }
}
1	matthewc	38	/*
2			rdesktop: A Remote Desktop Protocol client.
3			User interface services - X keyboard mapping
4			Copyright (C) Matthew Chapman 1999-2001
5
6			This program is free software; you can redistribute it and/or modify
7			it under the terms of the GNU General Public License as published by
8			the Free Software Foundation; either version 2 of the License, or
9			(at your option) any later version.
10
11			This program is distributed in the hope that it will be useful,
12			but WITHOUT ANY WARRANTY; without even the implied warranty of
13			MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14			GNU General Public License for more details.
15
16			You should have received a copy of the GNU General Public License
17			along with this program; if not, write to the Free Software
18			Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19			*/
20
21			#include <X11/Xlib.h>
22			#include <X11/keysym.h>
23			#include <stdio.h>
24			#include <stdlib.h>
25			#include <string.h>
26	astrand	66	#include <ctype.h>
27	matthewc	39	#include <limits.h>
28	matthewc	38	#include "rdesktop.h"
29	astrand	66	#include "scancodes.h"
30	matthewc	38
31			#define KEYMAP_SIZE 4096
32			#define KEYMAP_MASK (KEYMAP_SIZE - 1)
33	astrand	66	#define KEYMAP_MAX_LINE_LENGTH 80
34	matthewc	38
35	matthewc	50	extern Display *display;
36	matthewc	38	extern char keymapname[16];
37			extern int keylayout;
38
39	astrand	66	static key_translation keymap[KEYMAP_SIZE];
40	matthewc	38	static unsigned int min_keycode;
41	astrand	66	static uint16 remote_modifier_state = 0;
42	matthewc	38
43	astrand	66	static void
44			add_to_keymap(char keyname, uint8 scancode, uint16 modifiers, char mapname)
45			{
46			KeySym keysym;
47
48			keysym = XStringToKeysym(keyname);
49			if (keysym == NoSymbol)
50			{
51			error("Bad keysym %s in keymap %s\n", keyname, mapname);
52			return;
53			}
54
55			DEBUG_KBD("Adding translation, keysym=0x%x, scancode=0x%x, "
56			"modifiers=0x%x\n", (unsigned int) keysym, scancode,
57			modifiers);
58
59			keymap[keysym & KEYMAP_MASK].scancode = scancode;
60			keymap[keysym & KEYMAP_MASK].modifiers = modifiers;
61
62			return;
63			}
64
65
66	astrand	64	static BOOL
67			xkeymap_read(char *mapname)
68	matthewc	38	{
69			FILE *fp;
70	astrand	66	char line[KEYMAP_MAX_LINE_LENGTH], path[PATH_MAX];
71			unsigned int line_num = 0;
72			unsigned int line_length = 0;
73	matthewc	38	char keyname, p;
74	astrand	66	char *line_rest;
75			uint8 scancode;
76			uint16 modifiers;
77	matthewc	38
78	astrand	66
79	matthewc	38	strcpy(path, KEYMAP_PATH);
80			strncat(path, mapname, sizeof(path) - sizeof(KEYMAP_PATH));
81
82			fp = fopen(path, "r");
83			if (fp == NULL)
84			{
85			error("Failed to open keymap %s\n", path);
86			return False;
87			}
88
89	astrand	66	/* FIXME: More tolerant on white space */
90	matthewc	38	while (fgets(line, sizeof(line), fp) != NULL)
91			{
92	astrand	66	line_num++;
93
94			/* Replace the \n with \0 */
95	matthewc	38	p = strchr(line, '\n');
96			if (p != NULL)
97			*p = 0;
98
99	astrand	66	line_length = strlen(line);
100
101			/* Completely empty line */
102			if (strspn(line, " \t\n\r\f\v") == line_length)
103	matthewc	38	{
104	astrand	66	continue;
105			}
106	matthewc	38
107	astrand	66	/* Include */
108			if (strncmp(line, "include ", 8) == 0)
109	matthewc	38	{
110	astrand	64	if (!xkeymap_read(line + 8))
111	matthewc	38	return False;
112	astrand	66	continue;
113	matthewc	38	}
114	astrand	66
115			/* map */
116			if (strncmp(line, "map ", 4) == 0)
117	matthewc	38	{
118	astrand	64	keylayout = strtol(line + 4, NULL, 16);
119	astrand	66	DEBUG_KBD("Keylayout 0x%x\n", keylayout);
120			continue;
121	matthewc	38	}
122	astrand	66
123			/* Comment */
124			if (line[0] == '#')
125	matthewc	38	{
126	astrand	66	continue;
127	matthewc	38	}
128	astrand	66
129			/* Normal line */
130			keyname = line;
131			p = strchr(line, ' ');
132			if (p == NULL)
133			{
134			error("Bad line %d in keymap %s\n", line_num,
135			mapname);
136			continue;
137			}
138			else
139			{
140			*p = 0;
141			}
142
143			/* scancode */
144			p++;
145			scancode = strtol(p, &line_rest, 16);
146
147			/* flags */
148			/* FIXME: Should allow case-insensitive flag names.
149			Fix by using lex+yacc... */
150			modifiers = 0;
151			if (strstr(line_rest, "altgr"))
152			{
153			MASK_ADD_BITS(modifiers, MapAltGrMask);
154			}
155
156			if (strstr(line_rest, "shift"))
157			{
158			MASK_ADD_BITS(modifiers, MapLeftShiftMask);
159			}
160
161			if (strstr(line_rest, "numlock"))
162			{
163			MASK_ADD_BITS(modifiers, MapNumLockMask);
164			}
165
166	astrand	69	if (strstr(line_rest, "localstate"))
167			{
168			MASK_ADD_BITS(modifiers, MapLocalStateMask);
169			}
170
171	astrand	66	add_to_keymap(keyname, scancode, modifiers, mapname);
172
173			if (strstr(line_rest, "addupper"))
174			{
175			/* Automatically add uppercase key, with same modifiers
176			plus shift */
177			for (p = keyname; *p; p++)
178			p = toupper(p);
179			MASK_ADD_BITS(modifiers, MapLeftShiftMask);
180			add_to_keymap(keyname, scancode, modifiers, mapname);
181			}
182	matthewc	38	}
183
184			fclose(fp);
185			return True;
186			}
187
188	astrand	66
189			/* Before connecting and creating UI */
190	astrand	64	void
191	astrand	66	xkeymap_init1(void)
192	matthewc	38	{
193	astrand	66	int i;
194	matthewc	38
195	astrand	66	/* Zeroing keymap */
196			for (i = 0; i < KEYMAP_SIZE; i++)
197			{
198			keymap[i].scancode = 0;
199			keymap[i].modifiers = 0;
200			}
201	matthewc	38
202			if (strcmp(keymapname, "none"))
203	astrand	66	{
204	matthewc	38	xkeymap_read(keymapname);
205	astrand	66	}
206
207	matthewc	38	}
208
209	astrand	66	/* After connecting and creating UI */
210			void
211			xkeymap_init2(void)
212	matthewc	38	{
213	astrand	66	unsigned int max_keycode;
214			XDisplayKeycodes(display, &min_keycode, &max_keycode);
215			}
216	matthewc	38
217	astrand	66
218			key_translation
219	astrand	69	xkeymap_translate_key(KeySym keysym, unsigned int keycode, unsigned int state)
220	astrand	66	{
221			key_translation tr = { 0, 0 };
222
223			tr = keymap[keysym & KEYMAP_MASK];
224
225	astrand	69	if (tr.modifiers & MapLocalStateMask)
226			{
227			/* The modifiers to send for this key should be obtained
228			from the local state. Currently, only shift is implemented. */
229			if (state & ShiftMask)
230			{
231			tr.modifiers = MapLeftShiftMask;
232			}
233			}
234
235	astrand	66	if (tr.scancode != 0)
236	matthewc	50	{
237	astrand	66	DEBUG_KBD
238			("Found key translation, scancode=0x%x, modifiers=0x%x\n",
239			tr.scancode, tr.modifiers);
240			return tr;
241	matthewc	50	}
242
243	astrand	66	printf("No translation for (keysym 0x%lx, %s)\n", keysym,
244			get_ksname(keysym));
245
246	matthewc	38	/* not in keymap, try to interpret the raw scancode */
247			if ((keycode >= min_keycode) && (keycode <= 0x60))
248			{
249	astrand	66	tr.scancode = keycode - min_keycode;
250			printf("Sending guessed scancode 0x%x\n", tr.scancode);
251	matthewc	38	}
252	astrand	66	else
253			{
254			printf("No good guess for keycode 0x%x found\n", keycode);
255			}
256	matthewc	38
257	astrand	66	return tr;
258	matthewc	38	}
259
260	astrand	64	uint16
261			xkeymap_translate_button(unsigned int button)
262	matthewc	38	{
263			switch (button)
264			{
265	astrand	64	case Button1: /* left */
266	matthewc	38	return MOUSE_FLAG_BUTTON1;
267	astrand	64	case Button2: /* middle */
268	matthewc	38	return MOUSE_FLAG_BUTTON3;
269	astrand	64	case Button3: /* right */
270	matthewc	38	return MOUSE_FLAG_BUTTON2;
271	jsorg71	67	case Button4: /* wheel up */
272			return MOUSE_FLAG_BUTTON4;
273			case Button5: /* wheel down */
274			return MOUSE_FLAG_BUTTON5;
275	matthewc	38	}
276
277			return 0;
278			}
279	astrand	66
280			char *
281			get_ksname(KeySym keysym)
282			{
283			char *ksname = NULL;
284
285			if (keysym == NoSymbol)
286			ksname = "NoSymbol";
287			else if (!(ksname = XKeysymToString(keysym)))
288			ksname = "(no name)";
289
290			return ksname;
291			}
292
293			BOOL
294			inhibit_key(KeySym keysym)
295			{
296			switch (keysym)
297			{
298			case XK_Caps_Lock:
299			return True;
300			break;
301			case XK_Multi_key:
302			return True;
303			break;
304			default:
305			break;
306			}
307			return False;
308			}
309
310			void
311			ensure_remote_modifiers(uint32 ev_time, key_translation tr)
312			{
313			/* If this key is a modifier, do nothing */
314			switch (tr.scancode)
315			{
316			case SCANCODE_CHAR_LSHIFT:
317			case SCANCODE_CHAR_RSHIFT:
318			case SCANCODE_CHAR_LCTRL:
319			case SCANCODE_CHAR_RCTRL:
320			case SCANCODE_CHAR_LALT:
321			case SCANCODE_CHAR_RALT:
322			case SCANCODE_CHAR_LWIN:
323			case SCANCODE_CHAR_RWIN:
324			case SCANCODE_CHAR_NUMLOCK:
325			return;
326			default:
327			break;
328			}
329
330			/* Shift */
331			if (MASK_HAS_BITS(tr.modifiers, MapShiftMask)
332			!= MASK_HAS_BITS(remote_modifier_state, MapShiftMask))
333			{
334			/* The remote modifier state is not correct */
335			if (MASK_HAS_BITS(tr.modifiers, MapShiftMask))
336			{
337			/* Needs this modifier. Send down. */
338			rdp_send_scancode(ev_time, RDP_KEYPRESS,
339			SCANCODE_CHAR_LSHIFT);
340			}
341			else
342			{
343			/* Should not use this modifier. Send up. */
344			rdp_send_scancode(ev_time, RDP_KEYRELEASE,
345			SCANCODE_CHAR_LSHIFT);
346			}
347			}
348
349			/* AltGr */
350			if (MASK_HAS_BITS(tr.modifiers, MapAltGrMask)
351			!= MASK_HAS_BITS(remote_modifier_state, MapAltGrMask))
352			{
353			/* The remote modifier state is not correct */
354			if (MASK_HAS_BITS(tr.modifiers, MapAltGrMask))
355			{
356			/* Needs this modifier. Send down. */
357			rdp_send_scancode(ev_time, RDP_KEYPRESS,
358			SCANCODE_CHAR_RALT);
359			}
360			else
361			{
362			/* Should not use this modifier. Send up. */
363			rdp_send_scancode(ev_time, RDP_KEYRELEASE,
364			SCANCODE_CHAR_RALT);
365			}
366			}
367
368			/* NumLock */
369			if (MASK_HAS_BITS(tr.modifiers, MapNumLockMask)
370			!= MASK_HAS_BITS(remote_modifier_state, MapNumLockMask))
371			{
372			/* The remote modifier state is not correct */
373			DEBUG_KBD("Remote NumLock state is incorrect. Toggling\n");
374			if (MASK_HAS_BITS(tr.modifiers, MapNumLockMask))
375			{
376			/* Needs this modifier. Toggle */
377			rdp_send_scancode(ev_time, RDP_KEYPRESS,
378			SCANCODE_CHAR_NUMLOCK);
379			rdp_send_scancode(ev_time, RDP_KEYRELEASE,
380			SCANCODE_CHAR_NUMLOCK);
381			}
382			else
383			{
384			/* Should not use this modifier. Toggle */
385			rdp_send_scancode(ev_time, RDP_KEYPRESS,
386			SCANCODE_CHAR_NUMLOCK);
387			rdp_send_scancode(ev_time, RDP_KEYRELEASE,
388			SCANCODE_CHAR_NUMLOCK);
389			}
390			}
391
392			}
393
394
395			static void
396			update_modifier_state(uint16 modifiers, BOOL pressed)
397			{
398
399			DEBUG_KBD("Before updating modifier_state:0x%x, pressed=0x%x\n",
400			remote_modifier_state, pressed);
401			switch (modifiers)
402			{
403			case SCANCODE_CHAR_LSHIFT:
404			MASK_CHANGE_BIT(remote_modifier_state,
405			MapLeftShiftMask, pressed);
406			break;
407			case SCANCODE_CHAR_RSHIFT:
408			MASK_CHANGE_BIT(remote_modifier_state,
409			MapRightShiftMask, pressed);
410			break;
411			case SCANCODE_CHAR_LCTRL:
412			MASK_CHANGE_BIT(remote_modifier_state,
413			MapLeftCtrlMask, pressed);
414			break;
415			case SCANCODE_CHAR_RCTRL:
416			MASK_CHANGE_BIT(remote_modifier_state,
417			MapRightCtrlMask, pressed);
418			break;
419			case SCANCODE_CHAR_LALT:
420			MASK_CHANGE_BIT(remote_modifier_state, MapLeftAltMask,
421			pressed);
422			break;
423			case SCANCODE_CHAR_RALT:
424			MASK_CHANGE_BIT(remote_modifier_state,
425			MapRightAltMask, pressed);
426			break;
427			case SCANCODE_CHAR_LWIN:
428			MASK_CHANGE_BIT(remote_modifier_state, MapLeftWinMask,
429			pressed);
430			break;
431			case SCANCODE_CHAR_RWIN:
432			MASK_CHANGE_BIT(remote_modifier_state,
433			MapRightWinMask, pressed);
434			break;
435			case SCANCODE_CHAR_NUMLOCK:
436			/* KeyReleases for NumLocks are sent immediately. Toggle the
437			modifier state only on Keypress */
438			if (pressed)
439			{
440			BOOL newNumLockState;
441			newNumLockState =
442			(MASK_HAS_BITS
443			(remote_modifier_state,
444			MapNumLockMask) == False);
445			MASK_CHANGE_BIT(remote_modifier_state,
446			MapNumLockMask,
447			newNumLockState);
448			}
449			break;
450			}
451			DEBUG_KBD("After updating modifier_state:0x%x\n",
452			remote_modifier_state);
453
454			}
455
456			/* Send keyboard input */
457			void
458			rdp_send_scancode(uint32 time, uint16 flags, uint16 scancode)
459			{
460			update_modifier_state(scancode, !(flags & RDP_KEYRELEASE));
461
462			if (scancode & SCANCODE_EXTENDED)
463			{
464			DEBUG_KBD("Sending extended scancode=0x%x, flags=0x%x\n",
465			scancode & ~SCANCODE_EXTENDED, flags);
466			rdp_send_input(time, RDP_INPUT_SCANCODE, flags \| KBD_FLAG_EXT,
467			scancode & ~SCANCODE_EXTENDED, 0);
468			}
469			else
470			{
471			DEBUG_KBD("Sending scancode=0x%x, flags=0x%x\n", scancode,
472			flags);
473			rdp_send_input(time, RDP_INPUT_SCANCODE, flags, scancode, 0);
474			}
475			}