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