/[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 216 by matthewc, Tue Oct 8 02:30:20 2002 UTC revision 331 by astrand, Tue Feb 18 13:44:27 2003 UTC
# Line 20  Line 20 
20    
21  #include <X11/Xlib.h>  #include <X11/Xlib.h>
22  #define XK_MISCELLANY  #define XK_MISCELLANY
23  #include <X11/keysymdef.h>  #include <X11/keysym.h>
24  #include <ctype.h>  #include <ctype.h>
25  #include <limits.h>  #include <limits.h>
26  #include <time.h>  #include <time.h>
27  #include "rdesktop.h"  #include "rdesktop.h"
28  #include "scancodes.h"  #include "scancodes.h"
29    
30  #define KEYMAP_SIZE 4096  #define KEYMAP_SIZE 0xffff+1
31  #define KEYMAP_MASK (KEYMAP_SIZE - 1)  #define KEYMAP_MASK 0xffff
32  #define KEYMAP_MAX_LINE_LENGTH 80  #define KEYMAP_MAX_LINE_LENGTH 80
33    
34  extern Display *display;  extern Display *display;
35  extern char keymapname[16];  extern char keymapname[16];
36  extern int keylayout;  extern int keylayout;
37    extern int win_button_size;
38  extern BOOL enable_compose;  extern BOOL enable_compose;
39    
40  static BOOL keymap_loaded;  static BOOL keymap_loaded;
# Line 51  add_to_keymap(char *keyname, uint8 scanc Line 52  add_to_keymap(char *keyname, uint8 scanc
52          keysym = XStringToKeysym(keyname);          keysym = XStringToKeysym(keyname);
53          if (keysym == NoSymbol)          if (keysym == NoSymbol)
54          {          {
55                  error("Bad keysym %s in keymap %s\n", keyname, mapname);                  DEBUG_KBD(("Bad keysym \"%s\" in keymap %s (ignoring)\n", keyname, mapname));
56                  return;                  return;
57          }          }
58    
# Line 198  xkeymap_read(char *mapname) Line 199  xkeymap_read(char *mapname)
199                          /* Automatically add uppercase key, with same modifiers                          /* Automatically add uppercase key, with same modifiers
200                             plus shift */                             plus shift */
201                          for (p = keyname; *p; p++)                          for (p = keyname; *p; p++)
202                                  *p = toupper(*p);                                  *p = toupper((int) *p);
203                          MASK_ADD_BITS(modifiers, MapLeftShiftMask);                          MASK_ADD_BITS(modifiers, MapLeftShiftMask);
204                          add_to_keymap(keyname, scancode, modifiers, mapname);                          add_to_keymap(keyname, scancode, modifiers, mapname);
205                  }                  }
# Line 214  void Line 215  void
215  xkeymap_init(void)  xkeymap_init(void)
216  {  {
217          unsigned int max_keycode;          unsigned int max_keycode;
218            char *mapname_ptr;
219    
220            /* Make keymapname lowercase */
221            mapname_ptr = keymapname;
222            while (*mapname_ptr)
223            {
224                    *mapname_ptr = tolower((int) *mapname_ptr);
225                    mapname_ptr++;
226            }
227    
228          if (strcmp(keymapname, "none"))          if (strcmp(keymapname, "none"))
229          {          {
# Line 231  handle_special_keys(uint32 keysym, unsig Line 241  handle_special_keys(uint32 keysym, unsig
241  {  {
242          switch (keysym)          switch (keysym)
243          {          {
244                  case XK_Break:                  case XK_Return:
                 case XK_Pause:  
245                          if ((get_key_state(state, XK_Alt_L) || get_key_state(state, XK_Alt_R))                          if ((get_key_state(state, XK_Alt_L) || get_key_state(state, XK_Alt_R))
246                                  && (get_key_state(state, XK_Control_L) || get_key_state(state, XK_Control_R)))                              && (get_key_state(state, XK_Control_L)
247                                    || get_key_state(state, XK_Control_R)))
248                          {                          {
249                                  /* Ctrl-Alt-Break: toggle full screen */                                  /* Ctrl-Alt-Enter: toggle full screen */
250                                  if (pressed)                                  if (pressed)
251                                          xwin_toggle_fullscreen();                                          xwin_toggle_fullscreen();
252                                    return True;
253                            }
254                            break;
255    
256                    case XK_Break:
257                            /* Send Break sequence E0 46 E0 C6 */
258                            if (pressed)
259                            {
260                                    rdp_send_scancode(ev_time, RDP_KEYPRESS,
261                                                      (SCANCODE_EXTENDED | 0x46));
262                                    rdp_send_scancode(ev_time, RDP_KEYPRESS,
263                                                      (SCANCODE_EXTENDED | 0xc6));
264                          }                          }
265                          else if (keysym == XK_Break)                          /* No release sequence */
266                            return True;
267    
268                    case XK_Pause:
269                            /* According to MS Keyboard Scan Code
270                               Specification, pressing Pause should result
271                               in E1 1D 45 E1 9D C5. I'm not exactly sure
272                               of how this is supposed to be sent via
273                               RDP. The code below seems to work, but with
274                               the side effect that Left Ctrl stays
275                               down. Therefore, we release it when Pause
276                               is released. */
277                            if (pressed)
278                          {                          {
279                                  /* Send Break sequence E0 46 E0 C6 */                                  rdp_send_input(ev_time, RDP_INPUT_SCANCODE, RDP_KEYPRESS, 0xe1, 0);
280                                  if (pressed)                                  rdp_send_input(ev_time, RDP_INPUT_SCANCODE, RDP_KEYPRESS, 0x1d, 0);
281                                  {                                  rdp_send_input(ev_time, RDP_INPUT_SCANCODE, RDP_KEYPRESS, 0x45, 0);
282                                          rdp_send_scancode(ev_time, RDP_KEYPRESS,                                  rdp_send_input(ev_time, RDP_INPUT_SCANCODE, RDP_KEYPRESS, 0xe1, 0);
283                                                            (SCANCODE_EXTENDED | 0x46));                                  rdp_send_input(ev_time, RDP_INPUT_SCANCODE, RDP_KEYPRESS, 0x9d, 0);
284                                          rdp_send_scancode(ev_time, RDP_KEYPRESS,                                  rdp_send_input(ev_time, RDP_INPUT_SCANCODE, RDP_KEYPRESS, 0xc5, 0);
                                                           (SCANCODE_EXTENDED | 0xc6));  
                                 }  
                                 /* No break sequence */  
285                          }                          }
286                          else /* XK_Pause */                          else
287                          {                          {
288                                  /* According to MS Keyboard Scan Code                                  /* Release Left Ctrl */
289                                     Specification, pressing Pause should result                                  rdp_send_input(ev_time, RDP_INPUT_SCANCODE, RDP_KEYRELEASE,
290                                     in E1 1D 45 E1 9D C5. I'm not exactly sure                                                 0x1d, 0);
                                    of how this is supposed to be sent via  
                                    RDP. The code below seems to work, but with  
                                    the side effect that Left Ctrl stays  
                                    down. Therefore, we release it when Pause  
                                    is released. */  
                                 if (pressed)  
                                 {  
                                         rdp_send_input(ev_time, RDP_INPUT_SCANCODE, RDP_KEYPRESS, 0xe1, 0);  
                                         rdp_send_input(ev_time, RDP_INPUT_SCANCODE, RDP_KEYPRESS, 0x1d, 0);  
                                         rdp_send_input(ev_time, RDP_INPUT_SCANCODE, RDP_KEYPRESS, 0x45, 0);  
                                         rdp_send_input(ev_time, RDP_INPUT_SCANCODE, RDP_KEYPRESS, 0xe1, 0);  
                                         rdp_send_input(ev_time, RDP_INPUT_SCANCODE, RDP_KEYPRESS, 0x9d, 0);  
                                         rdp_send_input(ev_time, RDP_INPUT_SCANCODE, RDP_KEYPRESS, 0xc5, 0);  
                                 }  
                                 else  
                                 {  
                                         /* Release Left Ctrl */  
                                         rdp_send_input(ev_time, RDP_INPUT_SCANCODE, RDP_KEYRELEASE, 0x1d,  
                                                        0);  
                                 }  
291                          }                          }
292                          return True;                          return True;
293    
# Line 298  handle_special_keys(uint32 keysym, unsig Line 308  handle_special_keys(uint32 keysym, unsig
308                                  rdp_send_scancode(ev_time, RDP_KEYRELEASE, SCANCODE_CHAR_LCTRL);                                  rdp_send_scancode(ev_time, RDP_KEYRELEASE, SCANCODE_CHAR_LCTRL);
309                          }                          }
310                          return True;                          return True;
311    
312                    case XK_space:
313                            /* Prevent access to the Windows system menu in single app mode */
314                            if (win_button_size
315                                && (get_key_state(state, XK_Alt_L) || get_key_state(state, XK_Alt_R)))
316                                    return True;
317    
318          }          }
319          return False;          return False;
320  }  }
# Line 335  xkeymap_translate_key(uint32 keysym, uns Line 352  xkeymap_translate_key(uint32 keysym, uns
352          }          }
353    
354          if (keymap_loaded)          if (keymap_loaded)
355                  error("No translation for (keysym 0x%lx, %s)\n", keysym, get_ksname(keysym));                  warning("No translation for (keysym 0x%lx, %s)\n", keysym, get_ksname(keysym));
356    
357          /* not in keymap, try to interpret the raw scancode */          /* not in keymap, try to interpret the raw scancode */
358          if ((keycode >= min_keycode) && (keycode <= 0x60))          if ((keycode >= min_keycode) && (keycode <= 0x60))
# Line 414  ensure_remote_modifiers(uint32 ev_time, Line 431  ensure_remote_modifiers(uint32 ev_time,
431                          break;                          break;
432          }          }
433    
434            /* NumLock */
435            if (MASK_HAS_BITS(tr.modifiers, MapNumLockMask)
436                != MASK_HAS_BITS(remote_modifier_state, MapNumLockMask))
437            {
438                    /* The remote modifier state is not correct */
439                    uint16 new_remote_state;
440    
441                    if (MASK_HAS_BITS(tr.modifiers, MapNumLockMask))
442                    {
443                            DEBUG_KBD(("Remote NumLock state is incorrect, activating NumLock.\n"));
444                            new_remote_state = KBD_FLAG_NUMLOCK;
445                            remote_modifier_state = MapNumLockMask;
446                    }
447                    else
448                    {
449                            DEBUG_KBD(("Remote NumLock state is incorrect, deactivating NumLock.\n"));
450                            new_remote_state = 0;
451                            remote_modifier_state = 0;
452                    }
453    
454                    rdp_send_input(0, RDP_INPUT_SYNCHRONIZE, 0, new_remote_state, 0);
455            }
456    
457          /* Shift. Left shift and right shift are treated as equal; either is fine. */          /* Shift. Left shift and right shift are treated as equal; either is fine. */
458          if (MASK_HAS_BITS(tr.modifiers, MapShiftMask)          if (MASK_HAS_BITS(tr.modifiers, MapShiftMask)
459              != MASK_HAS_BITS(remote_modifier_state, MapShiftMask))              != MASK_HAS_BITS(remote_modifier_state, MapShiftMask))
# Line 458  ensure_remote_modifiers(uint32 ev_time, Line 498  ensure_remote_modifiers(uint32 ev_time,
498                  }                  }
499          }          }
500    
         /* 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"));  
                 }  
501    
                 rdp_send_input(0, RDP_INPUT_SYNCHRONIZE, 0, new_remote_state, 0);  
                 update_modifier_state(SCANCODE_CHAR_NUMLOCK, True);  
         }  
502  }  }
503    
504    
# Line 488  reset_modifier_keys(unsigned int state) Line 509  reset_modifier_keys(unsigned int state)
509          uint32 ev_time;          uint32 ev_time;
510          ev_time = time(NULL);          ev_time = time(NULL);
511    
512          if (MASK_HAS_BITS(remote_modifier_state, MapLeftShiftMask) && !get_key_state(state, XK_Shift_L))          if (MASK_HAS_BITS(remote_modifier_state, MapLeftShiftMask)
513                && !get_key_state(state, XK_Shift_L))
514                  rdp_send_scancode(ev_time, RDP_KEYRELEASE, SCANCODE_CHAR_LSHIFT);                  rdp_send_scancode(ev_time, RDP_KEYRELEASE, SCANCODE_CHAR_LSHIFT);
515    
516          if (MASK_HAS_BITS(remote_modifier_state, MapRightShiftMask) && !get_key_state(state, XK_Shift_R))          if (MASK_HAS_BITS(remote_modifier_state, MapRightShiftMask)
517                && !get_key_state(state, XK_Shift_R))
518                  rdp_send_scancode(ev_time, RDP_KEYRELEASE, SCANCODE_CHAR_RSHIFT);                  rdp_send_scancode(ev_time, RDP_KEYRELEASE, SCANCODE_CHAR_RSHIFT);
519    
520          if (MASK_HAS_BITS(remote_modifier_state, MapLeftCtrlMask) && !get_key_state(state, XK_Control_L))          if (MASK_HAS_BITS(remote_modifier_state, MapLeftCtrlMask)
521                && !get_key_state(state, XK_Control_L))
522                  rdp_send_scancode(ev_time, RDP_KEYRELEASE, SCANCODE_CHAR_LCTRL);                  rdp_send_scancode(ev_time, RDP_KEYRELEASE, SCANCODE_CHAR_LCTRL);
523    
524          if (MASK_HAS_BITS(remote_modifier_state, MapRightCtrlMask) && !get_key_state(state, XK_Control_R))          if (MASK_HAS_BITS(remote_modifier_state, MapRightCtrlMask)
525                && !get_key_state(state, XK_Control_R))
526                  rdp_send_scancode(ev_time, RDP_KEYRELEASE, SCANCODE_CHAR_RCTRL);                  rdp_send_scancode(ev_time, RDP_KEYRELEASE, SCANCODE_CHAR_RCTRL);
527    
528          if (MASK_HAS_BITS(remote_modifier_state, MapLeftAltMask) && !get_key_state(state, XK_Alt_L))          if (MASK_HAS_BITS(remote_modifier_state, MapLeftAltMask) && !get_key_state(state, XK_Alt_L))
Legend:
Removed from v.216  
changed lines
  Added in v.331
  ViewVC Help
Powered by ViewVC 1.1.26