/[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 964 by astrand, Wed Aug 3 11:30:53 2005 UTC revision 1293 by astrand, Wed Oct 11 17:56:05 2006 UTC
# Line 40  Line 40 
40    
41  extern Display *g_display;  extern Display *g_display;
42  extern Window g_wnd;  extern Window g_wnd;
43  extern char keymapname[16];  extern char g_keymapname[16];
44  extern int g_keylayout;  extern unsigned int g_keylayout;
45  extern int g_keyboard_type;  extern int g_keyboard_type;
46  extern int g_keyboard_subtype;  extern int g_keyboard_subtype;
47  extern int g_keyboard_functionkeys;  extern int g_keyboard_functionkeys;
# Line 159  add_sequence(char *rest, char *mapname) Line 159  add_sequence(char *rest, char *mapname)
159          DEBUG_KBD(("\n"));          DEBUG_KBD(("\n"));
160  }  }
161    
162  void  BOOL
163  xkeymap_from_locale(const char *locale)  xkeymap_from_locale(const char *locale)
164  {  {
165          char *str, *ptr;          char *str, *ptr;
166          FILE *fp;          FILE *fp;
167    
168          /* Create a working copy */          /* Create a working copy */
169          str = strdup(locale);          str = xstrdup(locale);
         if (str == NULL)  
         {  
                 perror("strdup");  
                 exit(1);  
         }  
170    
171          /* Truncate at dot and at */          /* Truncate at dot and at */
172          ptr = strrchr(str, '.');          ptr = strrchr(str, '.');
# Line 210  xkeymap_from_locale(const char *locale) Line 205  xkeymap_from_locale(const char *locale)
205          if (fp)          if (fp)
206          {          {
207                  fclose(fp);                  fclose(fp);
208                  STRNCPY(keymapname, str, sizeof(keymapname));                  STRNCPY(g_keymapname, str, sizeof(g_keymapname));
209                  fprintf(stderr, "Autoselected keyboard map %s.\n", keymapname);                  xfree(str);
210                    return True;
211          }          }
212    
213            xfree(str);
214            return False;
215  }  }
216    
217    
# Line 314  xkeymap_read(char *mapname) Line 313  xkeymap_read(char *mapname)
313                  }                  }
314    
315                  /* Include */                  /* Include */
316                  if (strncmp(line, "include ", 8) == 0)                  if (str_startswith(line, "include "))
317                  {                  {
318                          if (!xkeymap_read(line + 8))                          if (!xkeymap_read(line + sizeof("include ") - 1))
319                                  return False;                                  return False;
320                          continue;                          continue;
321                  }                  }
322    
323                  /* map */                  /* map */
324                  if (strncmp(line, "map ", 4) == 0)                  if (str_startswith(line, "map "))
325                  {                  {
326                          g_keylayout = strtol(line + 4, NULL, 16);                          g_keylayout = strtoul(line + sizeof("map ") - 1, NULL, 16);
327                          DEBUG_KBD(("Keylayout 0x%x\n", g_keylayout));                          DEBUG_KBD(("Keylayout 0x%x\n", g_keylayout));
328                          continue;                          continue;
329                  }                  }
330    
331                  /* compose */                  /* compose */
332                  if (strncmp(line, "enable_compose", 15) == 0)                  if (str_startswith(line, "enable_compose"))
333                  {                  {
334                          DEBUG_KBD(("Enabling compose handling\n"));                          DEBUG_KBD(("Enabling compose handling\n"));
335                          g_enable_compose = True;                          g_enable_compose = True;
# Line 338  xkeymap_read(char *mapname) Line 337  xkeymap_read(char *mapname)
337                  }                  }
338    
339                  /* sequence */                  /* sequence */
340                  if (strncmp(line, "sequence", 8) == 0)                  if (str_startswith(line, "sequence"))
341                  {                  {
342                          add_sequence(line + 8, mapname);                          add_sequence(line + sizeof("sequence") - 1, mapname);
343                          continue;                          continue;
344                  }                  }
345    
346                  /* keyboard_type */                  /* keyboard_type */
347                  if (strncmp(line, "keyboard_type ", sizeof("keyboard_type ")) == 0)                  if (str_startswith(line, "keyboard_type "))
348                  {                  {
349                          g_keyboard_type = strtol(line + sizeof("keyboard_type "), NULL, 16);                          g_keyboard_type = strtol(line + sizeof("keyboard_type ") - 1, NULL, 16);
350                          DEBUG_KBD(("keyboard_type 0x%x\n", g_keyboard_type));                          DEBUG_KBD(("keyboard_type 0x%x\n", g_keyboard_type));
351                          continue;                          continue;
352                  }                  }
353    
354                  /* keyboard_subtype */                  /* keyboard_subtype */
355                  if (strncmp(line, "keyboard_subtype ", sizeof("keyboard_subtype ")) == 0)                  if (str_startswith(line, "keyboard_subtype "))
356                  {                  {
357                          g_keyboard_subtype = strtol(line + sizeof("keyboard_subtype "), NULL, 16);                          g_keyboard_subtype =
358                                    strtol(line + sizeof("keyboard_subtype ") - 1, NULL, 16);
359                          DEBUG_KBD(("keyboard_subtype 0x%x\n", g_keyboard_subtype));                          DEBUG_KBD(("keyboard_subtype 0x%x\n", g_keyboard_subtype));
360                          continue;                          continue;
361                  }                  }
362    
363                  /* keyboard_functionkeys */                  /* keyboard_functionkeys */
364                  if (strncmp(line, "keyboard_functionkeys ", sizeof("keyboard_functionkeys ")) == 0)                  if (str_startswith(line, "keyboard_functionkeys "))
365                  {                  {
366                          g_keyboard_functionkeys =                          g_keyboard_functionkeys =
367                                  strtol(line + sizeof("keyboard_functionkeys "), NULL, 16);                                  strtol(line + sizeof("keyboard_functionkeys ") - 1, NULL, 16);
368                          DEBUG_KBD(("keyboard_functionkeys 0x%x\n", g_keyboard_functionkeys));                          DEBUG_KBD(("keyboard_functionkeys 0x%x\n", g_keyboard_functionkeys));
369                          continue;                          continue;
370                  }                  }
# Line 445  xkeymap_init(void) Line 445  xkeymap_init(void)
445  {  {
446          unsigned int max_keycode;          unsigned int max_keycode;
447    
448          if (strcmp(keymapname, "none"))          if (strcmp(g_keymapname, "none"))
449          {          {
450                  if (xkeymap_read(keymapname))                  if (xkeymap_read(g_keymapname))
451                          keymap_loaded = True;                          keymap_loaded = True;
452          }          }
453    
# Line 495  send_winkey(uint32 ev_time, BOOL pressed Line 495  send_winkey(uint32 ev_time, BOOL pressed
495  static void  static void
496  reset_winkey(uint32 ev_time)  reset_winkey(uint32 ev_time)
497  {  {
498            printf("reset_winkey\n");
499          if (g_use_rdp5)          if (g_use_rdp5)
500          {          {
501                  /* For some reason, it seems to suffice to release                  /* For some reason, it seems to suffice to release
# Line 591  handle_special_keys(uint32 keysym, unsig Line 592  handle_special_keys(uint32 keysym, unsig
592                          /* Inhibit */                          /* Inhibit */
593                          return True;                          return True;
594                          break;                          break;
595                    case XK_Overlay1_Enable:
596                            /* Toggle SeamlessRDP */
597                            if (pressed)
598                                    ui_seamless_toggle();
599                            break;
600    
601          }          }
602          return False;          return False;
# Line 609  xkeymap_translate_key(uint32 keysym, uns Line 615  xkeymap_translate_key(uint32 keysym, uns
615                  tr = *ptr;                  tr = *ptr;
616                  if (tr.seq_keysym == 0) /* Normal scancode translation */                  if (tr.seq_keysym == 0) /* Normal scancode translation */
617                  {                  {
618                          if (tr.modifiers & MapInhibitMask)                          if (MASK_HAS_BITS(tr.modifiers, MapInhibitMask))
619                          {                          {
620                                  DEBUG_KBD(("Inhibiting key\n"));                                  DEBUG_KBD(("Inhibiting key\n"));
621                                  tr.scancode = 0;                                  tr.scancode = 0;
622                                  return tr;                                  return tr;
623                          }                          }
624    
625                          if (tr.modifiers & MapLocalStateMask)                          if (MASK_HAS_BITS(tr.modifiers, MapLocalStateMask))
626                          {                          {
627                                  /* The modifiers to send for this key should be obtained                                  /* The modifiers to send for this key should be obtained
628                                     from the local state. Currently, only shift is implemented. */                                     from the local state. Currently, only shift is implemented. */
629                                  if (state & ShiftMask)                                  if (MASK_HAS_BITS(state, ShiftMask))
630                                  {                                  {
631                                          tr.modifiers = MapLeftShiftMask;                                          tr.modifiers = MapLeftShiftMask;
632                                  }                                  }
633                          }                          }
634    
635                          if ((tr.modifiers & MapLeftShiftMask)                          /* Windows interprets CapsLock+Ctrl+key
636                              && ((remote_modifier_state & MapLeftCtrlMask)                             differently from Shift+Ctrl+key. Since we
637                                  || (remote_modifier_state & MapRightCtrlMask))                             are simulating CapsLock with Shifts, things
638                              && get_key_state(state, XK_Caps_Lock))                             like Ctrl+f with CapsLock on breaks. To
639                               solve this, we are releasing Shift if Ctrl
640                               is on, but only if Shift isn't physically pressed. */
641                            if (MASK_HAS_BITS(tr.modifiers, MapShiftMask)
642                                && MASK_HAS_BITS(remote_modifier_state, MapCtrlMask)
643                                && !MASK_HAS_BITS(state, ShiftMask))
644                          {                          {
645                                  DEBUG_KBD(("CapsLock + Ctrl pressed, releasing LeftShift\n"));                                  DEBUG_KBD(("Non-physical Shift + Ctrl pressed, releasing Shift\n"));
646                                  tr.modifiers ^= MapLeftShiftMask;                                  MASK_REMOVE_BITS(tr.modifiers, MapShiftMask);
647                          }                          }
648    
649                          DEBUG_KBD(("Found scancode translation, scancode=0x%x, modifiers=0x%x\n",                          DEBUG_KBD(("Found scancode translation, scancode=0x%x, modifiers=0x%x\n",
# Line 653  xkeymap_translate_key(uint32 keysym, uns Line 664  xkeymap_translate_key(uint32 keysym, uns
664                          /* The modifiers to send for this key should be                          /* The modifiers to send for this key should be
665                             obtained from the local state. Currently, only                             obtained from the local state. Currently, only
666                             shift is implemented. */                             shift is implemented. */
667                          if (state & ShiftMask)                          if (MASK_HAS_BITS(state, ShiftMask))
668                          {                          {
669                                  tr.modifiers = MapLeftShiftMask;                                  tr.modifiers = MapLeftShiftMask;
670                          }                          }
# Line 671  xkeymap_translate_key(uint32 keysym, uns Line 682  xkeymap_translate_key(uint32 keysym, uns
682    
683  void  void
684  xkeymap_send_keys(uint32 keysym, unsigned int keycode, unsigned int state, uint32 ev_time,  xkeymap_send_keys(uint32 keysym, unsigned int keycode, unsigned int state, uint32 ev_time,
685                    BOOL pressed)                    BOOL pressed, uint8 nesting)
686  {  {
687          key_translation tr, *ptr;          key_translation tr, *ptr;
688          tr = xkeymap_translate_key(keysym, keycode, state);          tr = xkeymap_translate_key(keysym, keycode, state);
# Line 704  xkeymap_send_keys(uint32 keysym, unsigne Line 715  xkeymap_send_keys(uint32 keysym, unsigne
715                  {                  {
716                          DEBUG_KBD(("Handling sequence element, keysym=0x%x\n",                          DEBUG_KBD(("Handling sequence element, keysym=0x%x\n",
717                                     (unsigned int) ptr->seq_keysym));                                     (unsigned int) ptr->seq_keysym));
718                          xkeymap_send_keys(ptr->seq_keysym, keycode, state, ev_time, True);  
719                          xkeymap_send_keys(ptr->seq_keysym, keycode, state, ev_time, False);                          if (nesting++ > 32)
720                            {
721                                    error("Sequence nesting too deep\n");
722                                    return;
723                            }
724    
725                            xkeymap_send_keys(ptr->seq_keysym, keycode, state, ev_time, True, nesting);
726                            xkeymap_send_keys(ptr->seq_keysym, keycode, state, ev_time, False, nesting);
727                          ptr = ptr->next;                          ptr = ptr->next;
728                  }                  }
729                  while (ptr);                  while (ptr);
# Line 935  reset_modifier_keys() Line 953  reset_modifier_keys()
953    
954          if (g_numlock_sync)          if (g_numlock_sync)
955                  rdp_send_input(ev_time, RDP_INPUT_SYNCHRONIZE, 0, ui_get_numlock_state(state), 0);                  rdp_send_input(ev_time, RDP_INPUT_SYNCHRONIZE, 0, ui_get_numlock_state(state), 0);
956    
957            //sleep(4);
958            //rdp_send_input(time(NULL), RDP_INPUT_SCANCODE, RDP_KEYPRESS, 0x9c, 0);
959            //rdp_send_input(time(NULL), RDP_INPUT_SCANCODE, RDP_KEYRELEASE, 0x9c, 0);
960  }  }
961    
962    
Legend:
Removed from v.964  
changed lines
  Added in v.1293
  ViewVC Help
Powered by ViewVC 1.1.26