/[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 199 by astrand, Wed Sep 25 11:17:59 2002 UTC revision 244 by matthewc, Thu Oct 24 08:48:51 2002 UTC
# Line 1  Line 1 
1  /*  /*
2     rdesktop: A Remote Desktop Protocol client.     rdesktop: A Remote Desktop Protocol client.
3     User interface services - X keyboard mapping     User interface services - X keyboard mapping
4     Copyright (C) Matthew Chapman 1999-2001     Copyright (C) Matthew Chapman 1999-2002
5        
6     This program is free software; you can redistribute it and/or modify     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     it under the terms of the GNU General Public License as published by
# Line 36  extern char keymapname[16]; Line 36  extern char keymapname[16];
36  extern int keylayout;  extern int keylayout;
37  extern BOOL enable_compose;  extern BOOL enable_compose;
38    
39    static BOOL keymap_loaded;
40  static key_translation keymap[KEYMAP_SIZE];  static key_translation keymap[KEYMAP_SIZE];
41  static int min_keycode;  static int min_keycode;
42  static uint16 remote_modifier_state = 0;  static uint16 remote_modifier_state = 0;
43    
44  static void update_modifier_state(uint16 modifiers, BOOL pressed);  static void update_modifier_state(uint8 scancode, BOOL pressed);
45    
46  static void  static void
47  add_to_keymap(char *keyname, uint8 scancode, uint16 modifiers, char *mapname)  add_to_keymap(char *keyname, uint8 scancode, uint16 modifiers, char *mapname)
# Line 68  static BOOL Line 69  static BOOL
69  xkeymap_read(char *mapname)  xkeymap_read(char *mapname)
70  {  {
71          FILE *fp;          FILE *fp;
72          char line[KEYMAP_MAX_LINE_LENGTH], path[PATH_MAX];          char line[KEYMAP_MAX_LINE_LENGTH];
73            char path[PATH_MAX], inplace_path[PATH_MAX];
74          unsigned int line_num = 0;          unsigned int line_num = 0;
75          unsigned int line_length = 0;          unsigned int line_length = 0;
76          char *keyname, *p;          char *keyname, *p;
# Line 83  xkeymap_read(char *mapname) Line 85  xkeymap_read(char *mapname)
85          fp = fopen(path, "r");          fp = fopen(path, "r");
86          if (fp == NULL)          if (fp == NULL)
87          {          {
88                  error("Failed to open keymap %s\n", path);                  /* in case we are running from the source tree */
89                  return False;                  strcpy(inplace_path, "keymaps/");
90                    strncat(inplace_path, mapname, sizeof(inplace_path) - sizeof("keymaps/"));
91    
92                    fp = fopen(inplace_path, "r");
93                    if (fp == NULL)
94                    {
95                            error("Failed to open keymap %s\n", path);
96                            return False;
97                    }
98          }          }
99    
100          /* FIXME: More tolerant on white space */          /* FIXME: More tolerant on white space */
# Line 204  void Line 214  void
214  xkeymap_init(void)  xkeymap_init(void)
215  {  {
216          unsigned int max_keycode;          unsigned int max_keycode;
217            char *mapname_ptr;
218    
219            /* Make keymapname lowercase */
220            mapname_ptr = keymapname;
221            while (*mapname_ptr)
222            {
223                    *mapname_ptr = tolower(*mapname_ptr);
224                    mapname_ptr++;
225            }
226    
227          if (strcmp(keymapname, "none"))          if (strcmp(keymapname, "none"))
228                  xkeymap_read(keymapname);          {
229                    if (xkeymap_read(keymapname))
230                            keymap_loaded = True;
231            }
232    
233          XDisplayKeycodes(display, &min_keycode, (int *) &max_keycode);          XDisplayKeycodes(display, &min_keycode, (int *) &max_keycode);
234  }  }
# Line 214  xkeymap_init(void) Line 236  xkeymap_init(void)
236  /* Handles, for example, multi-scancode keypresses (which is not  /* Handles, for example, multi-scancode keypresses (which is not
237     possible via keymap-files) */     possible via keymap-files) */
238  BOOL  BOOL
239  handle_special_keys(uint32 keysym, uint32 ev_time, BOOL pressed)  handle_special_keys(uint32 keysym, unsigned int state, uint32 ev_time, BOOL pressed)
240  {  {
241          switch (keysym)          switch (keysym)
242          {          {
243                  case XK_Break:                  case XK_Return:
244                          if (get_key_state(XK_Alt_L) || get_key_state(XK_Alt_R))                          if ((get_key_state(state, XK_Alt_L) || get_key_state(state, XK_Alt_R))
245                                && (get_key_state(state, XK_Control_L)
246                                    || get_key_state(state, XK_Control_R)))
247                          {                          {
248                                  /* toggle full screen */                                  /* Ctrl-Alt-Enter: toggle full screen */
249                                  if (pressed)                                  if (pressed)
250                                          xwin_toggle_fullscreen();                                          xwin_toggle_fullscreen();
251                                    return True;
252                          }                          }
253                          else                          break;
254    
255                    case XK_Break:
256                            /* Send Break sequence E0 46 E0 C6 */
257                            if (pressed)
258                          {                          {
259                                  /* Send Break sequence E0 46 E0 C6 */                                  rdp_send_scancode(ev_time, RDP_KEYPRESS,
260                                  if (pressed)                                                    (SCANCODE_EXTENDED | 0x46));
261                                  {                                  rdp_send_scancode(ev_time, RDP_KEYPRESS,
262                                          rdp_send_scancode(ev_time, RDP_KEYPRESS,                                                    (SCANCODE_EXTENDED | 0xc6));
                                                           (SCANCODE_EXTENDED | 0x46));  
                                         rdp_send_scancode(ev_time, RDP_KEYPRESS,  
                                                           (SCANCODE_EXTENDED | 0xc6));  
                                 }  
                                 /* No break sequence */  
263                          }                          }
264                            /* No release sequence */
265                          return True;                          return True;
                         break;  
266    
267                  case XK_Pause:                  case XK_Pause:
268                          /* According to MS Keyboard Scan Code                          /* According to MS Keyboard Scan Code
# Line 253  handle_special_keys(uint32 keysym, uint3 Line 275  handle_special_keys(uint32 keysym, uint3
275                             is released. */                             is released. */
276                          if (pressed)                          if (pressed)
277                          {                          {
278                                  rdp_send_input(ev_time, RDP_INPUT_SCANCODE, RDP_KEYPRESS, 0xe1, 0);                                  rdp_send_input(ev_time, RDP_INPUT_SCANCODE, RDP_KEYPRESS,
279                                  rdp_send_input(ev_time, RDP_INPUT_SCANCODE, RDP_KEYPRESS, 0x1d, 0);                                                 0xe1, 0);
280                                  rdp_send_input(ev_time, RDP_INPUT_SCANCODE, RDP_KEYPRESS, 0x45, 0);                                  rdp_send_input(ev_time, RDP_INPUT_SCANCODE, RDP_KEYPRESS,
281                                  rdp_send_input(ev_time, RDP_INPUT_SCANCODE, RDP_KEYPRESS, 0xe1, 0);                                                 0x1d, 0);
282                                  rdp_send_input(ev_time, RDP_INPUT_SCANCODE, RDP_KEYPRESS, 0x9d, 0);                                  rdp_send_input(ev_time, RDP_INPUT_SCANCODE, RDP_KEYPRESS,
283                                  rdp_send_input(ev_time, RDP_INPUT_SCANCODE, RDP_KEYPRESS, 0xc5, 0);                                                 0x45, 0);
284                                    rdp_send_input(ev_time, RDP_INPUT_SCANCODE, RDP_KEYPRESS,
285                                                   0xe1, 0);
286                                    rdp_send_input(ev_time, RDP_INPUT_SCANCODE, RDP_KEYPRESS,
287                                                   0x9d, 0);
288                                    rdp_send_input(ev_time, RDP_INPUT_SCANCODE, RDP_KEYPRESS,
289                                                   0xc5, 0);
290                          }                          }
291                          else                          else
292                          {                          {
293                                  // Release Left Ctrl                                  /* Release Left Ctrl */
294                                  rdp_send_input(ev_time, RDP_INPUT_SCANCODE, RDP_KEYRELEASE, 0x1d,                                  rdp_send_input(ev_time, RDP_INPUT_SCANCODE, RDP_KEYRELEASE,
295                                                 0);                                                 0x1d, 0);
296                          }                          }
   
297                          return True;                          return True;
                         break;  
298    
299                  case XK_Meta_L: /* Windows keys */                  case XK_Meta_L: /* Windows keys */
300                  case XK_Super_L:                  case XK_Super_L:
# Line 287  handle_special_keys(uint32 keysym, uint3 Line 313  handle_special_keys(uint32 keysym, uint3
313                                  rdp_send_scancode(ev_time, RDP_KEYRELEASE, SCANCODE_CHAR_LCTRL);                                  rdp_send_scancode(ev_time, RDP_KEYRELEASE, SCANCODE_CHAR_LCTRL);
314                          }                          }
315                          return True;                          return True;
                         break;  
316          }          }
317          return False;          return False;
318  }  }
# Line 324  xkeymap_translate_key(uint32 keysym, uns Line 349  xkeymap_translate_key(uint32 keysym, uns
349                  return tr;                  return tr;
350          }          }
351    
352          DEBUG_KBD(("No translation for (keysym 0x%lx, %s)\n", keysym, get_ksname(keysym)));          if (keymap_loaded)
353                    error("No translation for (keysym 0x%lx, %s)\n", keysym, get_ksname(keysym));
354    
355          /* not in keymap, try to interpret the raw scancode */          /* not in keymap, try to interpret the raw scancode */
356          if ((keycode >= min_keycode) && (keycode <= 0x60))          if ((keycode >= min_keycode) && (keycode <= 0x60))
# Line 471  ensure_remote_modifiers(uint32 ev_time, Line 497  ensure_remote_modifiers(uint32 ev_time,
497    
498    
499  void  void
500  reset_modifier_keys(void)  reset_modifier_keys(unsigned int state)
501  {  {
502          /* reset keys */          /* reset keys */
503          uint32 ev_time;          uint32 ev_time;
504          ev_time = time(NULL);          ev_time = time(NULL);
505    
506          if (MASK_HAS_BITS(remote_modifier_state, MapLeftShiftMask) && !get_key_state(XK_Shift_L))          if (MASK_HAS_BITS(remote_modifier_state, MapLeftShiftMask)
507                && !get_key_state(state, XK_Shift_L))
508                  rdp_send_scancode(ev_time, RDP_KEYRELEASE, SCANCODE_CHAR_LSHIFT);                  rdp_send_scancode(ev_time, RDP_KEYRELEASE, SCANCODE_CHAR_LSHIFT);
509    
510          if (MASK_HAS_BITS(remote_modifier_state, MapRightShiftMask) && !get_key_state(XK_Shift_R))          if (MASK_HAS_BITS(remote_modifier_state, MapRightShiftMask)
511                && !get_key_state(state, XK_Shift_R))
512                  rdp_send_scancode(ev_time, RDP_KEYRELEASE, SCANCODE_CHAR_RSHIFT);                  rdp_send_scancode(ev_time, RDP_KEYRELEASE, SCANCODE_CHAR_RSHIFT);
513    
514          if (MASK_HAS_BITS(remote_modifier_state, MapLeftCtrlMask) && !get_key_state(XK_Control_L))          if (MASK_HAS_BITS(remote_modifier_state, MapLeftCtrlMask)
515                && !get_key_state(state, XK_Control_L))
516                  rdp_send_scancode(ev_time, RDP_KEYRELEASE, SCANCODE_CHAR_LCTRL);                  rdp_send_scancode(ev_time, RDP_KEYRELEASE, SCANCODE_CHAR_LCTRL);
517    
518          if (MASK_HAS_BITS(remote_modifier_state, MapRightCtrlMask) && !get_key_state(XK_Control_R))          if (MASK_HAS_BITS(remote_modifier_state, MapRightCtrlMask)
519                && !get_key_state(state, XK_Control_R))
520                  rdp_send_scancode(ev_time, RDP_KEYRELEASE, SCANCODE_CHAR_RCTRL);                  rdp_send_scancode(ev_time, RDP_KEYRELEASE, SCANCODE_CHAR_RCTRL);
521    
522          if (MASK_HAS_BITS(remote_modifier_state, MapLeftAltMask) && !get_key_state(XK_Alt_L))          if (MASK_HAS_BITS(remote_modifier_state, MapLeftAltMask) && !get_key_state(state, XK_Alt_L))
523                  rdp_send_scancode(ev_time, RDP_KEYRELEASE, SCANCODE_CHAR_LALT);                  rdp_send_scancode(ev_time, RDP_KEYRELEASE, SCANCODE_CHAR_LALT);
524    
525          if (MASK_HAS_BITS(remote_modifier_state, MapRightAltMask) &&          if (MASK_HAS_BITS(remote_modifier_state, MapRightAltMask) &&
526              !get_key_state(XK_Alt_R) && !get_key_state(XK_Mode_switch))              !get_key_state(state, XK_Alt_R) && !get_key_state(state, XK_Mode_switch))
527                  rdp_send_scancode(ev_time, RDP_KEYRELEASE, SCANCODE_CHAR_RALT);                  rdp_send_scancode(ev_time, RDP_KEYRELEASE, SCANCODE_CHAR_RALT);
528  }  }
529    
530    
531  static void  static void
532  update_modifier_state(uint16 modifiers, BOOL pressed)  update_modifier_state(uint8 scancode, BOOL pressed)
533  {  {
534  #ifdef WITH_DEBUG_KBD  #ifdef WITH_DEBUG_KBD
535          uint16 old_modifier_state;          uint16 old_modifier_state;
# Line 507  update_modifier_state(uint16 modifiers, Line 537  update_modifier_state(uint16 modifiers,
537          old_modifier_state = remote_modifier_state;          old_modifier_state = remote_modifier_state;
538  #endif  #endif
539    
540          switch (modifiers)          switch (scancode)
541          {          {
542                  case SCANCODE_CHAR_LSHIFT:                  case SCANCODE_CHAR_LSHIFT:
543                          MASK_CHANGE_BIT(remote_modifier_state, MapLeftShiftMask, pressed);                          MASK_CHANGE_BIT(remote_modifier_state, MapLeftShiftMask, pressed);
# Line 561  update_modifier_state(uint16 modifiers, Line 591  update_modifier_state(uint16 modifiers,
591    
592  /* Send keyboard input */  /* Send keyboard input */
593  void  void
594  rdp_send_scancode(uint32 time, uint16 flags, uint16 scancode)  rdp_send_scancode(uint32 time, uint16 flags, uint8 scancode)
595  {  {
596          update_modifier_state(scancode, !(flags & RDP_KEYRELEASE));          update_modifier_state(scancode, !(flags & RDP_KEYRELEASE));
597    
Legend:
Removed from v.199  
changed lines
  Added in v.244
  ViewVC Help
Powered by ViewVC 1.1.26