/[rdesktop]/sourceforge.net/trunk/rdesktop/xkeymap.c
This is repository of my old source code which isn't updated any more. Go to git.rot13.org for current projects!
ViewVC logotype

Diff of /sourceforge.net/trunk/rdesktop/xkeymap.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

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