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>
#define XK_MISCELLANY
#include <X11/keysymdef.h>
#include <ctype.h>
#include <limits.h>
#include <time.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);
                }

                if (strstr(line_rest, "inhibit"))
                {
                        MASK_ADD_BITS(modifiers, MapInhibitMask);
                }

                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_init(void)
{
        unsigned int max_keycode;

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

        XDisplayKeycodes(display, &min_keycode, (int *) &max_keycode);
}

/* Handles, for example, multi-scancode keypresses (which is not
   possible via keymap-files) */
BOOL
handle_special_keys(uint32 keysym, uint32 ev_time, BOOL pressed)
{
        switch (keysym)
        {
                case XK_Break:  /* toggle full screen */
                        if (pressed && (get_key_state(XK_Alt_L) || get_key_state(XK_Alt_R)))
                        {
                                xwin_toggle_fullscreen();
                                return True;
                        }
                        break;

                case XK_Meta_L: /* Windows keys */
                case XK_Super_L:
                case XK_Hyper_L:
                case XK_Meta_R:
                case XK_Super_R:
                case XK_Hyper_R:
                        if (pressed)
                        {
                                rdp_send_scancode(ev_time, RDP_KEYPRESS, SCANCODE_CHAR_LCTRL);
                                rdp_send_scancode(ev_time, RDP_KEYPRESS, SCANCODE_CHAR_ESC);
                        }
                        else
                        {
                                rdp_send_scancode(ev_time, RDP_KEYRELEASE, SCANCODE_CHAR_ESC);
                                rdp_send_scancode(ev_time, RDP_KEYRELEASE, SCANCODE_CHAR_LCTRL);
                        }
                        return True;
                        break;
        }
        return False;
}


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

        tr = keymap[keysym & KEYMAP_MASK];

        if (tr.modifiers & MapInhibitMask)
        {
                DEBUG_KBD(("Inhibiting key\n"));
                tr.scancode = 0;
                return tr;
        }

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

        DEBUG_KBD(("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;

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

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

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

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

        return ksname;
}


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

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


void
reset_modifier_keys()
{
        /* reset keys */
        uint32 ev_time;
        ev_time = time(NULL);

        if (MASK_HAS_BITS(remote_modifier_state, MapLeftShiftMask) && !get_key_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(XK_Shift_R))
                rdp_send_scancode(ev_time, RDP_KEYRELEASE, SCANCODE_CHAR_RSHIFT);

        if (MASK_HAS_BITS(remote_modifier_state, MapLeftCtrlMask) && !get_key_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(XK_Control_R))
                rdp_send_scancode(ev_time, RDP_KEYRELEASE, SCANCODE_CHAR_RCTRL);

        if (MASK_HAS_BITS(remote_modifier_state, MapLeftAltMask) && !get_key_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(XK_Alt_R) && !get_key_state(XK_Mode_switch))
                rdp_send_scancode(ev_time, RDP_KEYRELEASE, SCANCODE_CHAR_RALT);
}


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