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;
extern BOOL enable_compose;

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

static void update_modifier_state(uint16 modifiers, BOOL pressed);

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;
                }

                /* compose */
                if (strncmp(line, "enable_compose", 15) == 0)
                {
                        DEBUG_KBD(("Enabling compose handling\n"));
                        enable_compose = True;
                        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, (int *) &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;
        }

        fprintf(stderr, "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;
                fprintf(stderr, "Sending guessed scancode 0x%x\n", tr.scancode);
        }
        else
        {
                fprintf(stderr, "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;
                case XK_Num_Lock:
                        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 */
                uint16 new_remote_state = 0;

                if (MASK_HAS_BITS(tr.modifiers, MapNumLockMask))
                {
                        DEBUG_KBD(("Remote NumLock state is incorrect, activating NumLock.\n"));
                        new_remote_state |= KBD_FLAG_NUMLOCK;
                }
                else
                {
                        DEBUG_KBD(("Remote NumLock state is incorrect, deactivating NumLock.\n"));
                }

                rdp_send_input(0, RDP_INPUT_SYNCHRONIZE, 0, new_remote_state, 0);
                update_modifier_state(SCANCODE_CHAR_NUMLOCK, True);
        }
}


static void
update_modifier_state(uint16 modifiers, BOOL pressed)
{
#ifdef WITH_DEBUG_KBD
        uint16 old_modifier_state;

        old_modifier_state = remote_modifier_state;
#endif

        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;
        }

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