/[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 77 by astrand, Mon Jul 29 20:17:10 2002 UTC revision 199 by astrand, Wed Sep 25 11:17:59 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>
 #include <stdlib.h>  
 #include <string.h>  
24  #include <ctype.h>  #include <ctype.h>
25  #include <limits.h>  #include <limits.h>
26    #include <time.h>
27  #include "rdesktop.h"  #include "rdesktop.h"
28  #include "scancodes.h"  #include "scancodes.h"
29    
# Line 41  static key_translation keymap[KEYMAP_SIZ Line 40  static key_translation keymap[KEYMAP_SIZ
40  static int min_keycode;  static int min_keycode;
41  static uint16 remote_modifier_state = 0;  static uint16 remote_modifier_state = 0;
42    
43    static void update_modifier_state(uint16 modifiers, BOOL pressed);
44    
45  static void  static void
46  add_to_keymap(char *keyname, uint8 scancode, uint16 modifiers, char *mapname)  add_to_keymap(char *keyname, uint8 scancode, uint16 modifiers, char *mapname)
47  {  {
# Line 53  add_to_keymap(char *keyname, uint8 scanc Line 54  add_to_keymap(char *keyname, uint8 scanc
54                  return;                  return;
55          }          }
56    
57          DEBUG_KBD("Adding translation, keysym=0x%x, scancode=0x%x, "          DEBUG_KBD(("Adding translation, keysym=0x%x, scancode=0x%x, "
58                    "modifiers=0x%x\n", (unsigned int) keysym, scancode,                     "modifiers=0x%x\n", (unsigned int) keysym, scancode, modifiers));
                   modifiers);  
59    
60          keymap[keysym & KEYMAP_MASK].scancode = scancode;          keymap[keysym & KEYMAP_MASK].scancode = scancode;
61          keymap[keysym & KEYMAP_MASK].modifiers = modifiers;          keymap[keysym & KEYMAP_MASK].modifiers = modifiers;
# Line 117  xkeymap_read(char *mapname) Line 117  xkeymap_read(char *mapname)
117                  if (strncmp(line, "map ", 4) == 0)                  if (strncmp(line, "map ", 4) == 0)
118                  {                  {
119                          keylayout = strtol(line + 4, NULL, 16);                          keylayout = strtol(line + 4, NULL, 16);
120                          DEBUG_KBD("Keylayout 0x%x\n", keylayout);                          DEBUG_KBD(("Keylayout 0x%x\n", keylayout));
121                          continue;                          continue;
122                  }                  }
123    
124                  /* compose */                  /* compose */
125                  if (strncmp(line, "enable_compose", 15) == 0)                  if (strncmp(line, "enable_compose", 15) == 0)
126                  {                  {
127                          DEBUG_KBD("Enabling compose handling\n");                          DEBUG_KBD(("Enabling compose handling\n"));
128                          enable_compose = True;                          enable_compose = True;
129                          continue;                          continue;
130                  }                  }
# Line 140  xkeymap_read(char *mapname) Line 140  xkeymap_read(char *mapname)
140                  p = strchr(line, ' ');                  p = strchr(line, ' ');
141                  if (p == NULL)                  if (p == NULL)
142                  {                  {
143                          error("Bad line %d in keymap %s\n", line_num,                          error("Bad line %d in keymap %s\n", line_num, mapname);
                               mapname);  
144                          continue;                          continue;
145                  }                  }
146                  else                  else
# Line 177  xkeymap_read(char *mapname) Line 176  xkeymap_read(char *mapname)
176                          MASK_ADD_BITS(modifiers, MapLocalStateMask);                          MASK_ADD_BITS(modifiers, MapLocalStateMask);
177                  }                  }
178    
179                    if (strstr(line_rest, "inhibit"))
180                    {
181                            MASK_ADD_BITS(modifiers, MapInhibitMask);
182                    }
183    
184                  add_to_keymap(keyname, scancode, modifiers, mapname);                  add_to_keymap(keyname, scancode, modifiers, mapname);
185    
186                  if (strstr(line_rest, "addupper"))                  if (strstr(line_rest, "addupper"))
# Line 197  xkeymap_read(char *mapname) Line 201  xkeymap_read(char *mapname)
201    
202  /* Before connecting and creating UI */  /* Before connecting and creating UI */
203  void  void
204  xkeymap_init1(void)  xkeymap_init(void)
205  {  {
206          int i;          unsigned int max_keycode;
   
         /* Zeroing keymap */  
         for (i = 0; i < KEYMAP_SIZE; i++)  
         {  
                 keymap[i].scancode = 0;  
                 keymap[i].modifiers = 0;  
         }  
207    
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  /* After connecting and creating UI */  /* Handles, for example, multi-scancode keypresses (which is not
215  void     possible via keymap-files) */
216  xkeymap_init2(void)  BOOL
217    handle_special_keys(uint32 keysym, uint32 ev_time, BOOL pressed)
218  {  {
219          unsigned int max_keycode;          switch (keysym)
220          XDisplayKeycodes(display, &min_keycode, (int *) &max_keycode);          {
221                    case XK_Break:
222                            if (get_key_state(XK_Alt_L) || get_key_state(XK_Alt_R))
223                            {
224                                    /* toggle full screen */
225                                    if (pressed)
226                                            xwin_toggle_fullscreen();
227    
228                            }
229                            else
230                            {
231                                    /* Send Break sequence E0 46 E0 C6 */
232                                    if (pressed)
233                                    {
234                                            rdp_send_scancode(ev_time, RDP_KEYPRESS,
235                                                              (SCANCODE_EXTENDED | 0x46));
236                                            rdp_send_scancode(ev_time, RDP_KEYPRESS,
237                                                              (SCANCODE_EXTENDED | 0xc6));
238                                    }
239                                    /* No break sequence */
240                            }
241    
242                            return True;
243                            break;
244    
245                    case XK_Pause:
246                            /* According to MS Keyboard Scan Code
247                               Specification, pressing Pause should result
248                               in E1 1D 45 E1 9D C5. I'm not exactly sure
249                               of how this is supposed to be sent via
250                               RDP. The code below seems to work, but with
251                               the side effect that Left Ctrl stays
252                               down. Therefore, we release it when Pause
253                               is released. */
254                            if (pressed)
255                            {
256                                    rdp_send_input(ev_time, RDP_INPUT_SCANCODE, RDP_KEYPRESS, 0xe1, 0);
257                                    rdp_send_input(ev_time, RDP_INPUT_SCANCODE, RDP_KEYPRESS, 0x1d, 0);
258                                    rdp_send_input(ev_time, RDP_INPUT_SCANCODE, RDP_KEYPRESS, 0x45, 0);
259                                    rdp_send_input(ev_time, RDP_INPUT_SCANCODE, RDP_KEYPRESS, 0xe1, 0);
260                                    rdp_send_input(ev_time, RDP_INPUT_SCANCODE, RDP_KEYPRESS, 0x9d, 0);
261                                    rdp_send_input(ev_time, RDP_INPUT_SCANCODE, RDP_KEYPRESS, 0xc5, 0);
262                            }
263                            else
264                            {
265                                    // Release Left Ctrl
266                                    rdp_send_input(ev_time, RDP_INPUT_SCANCODE, RDP_KEYRELEASE, 0x1d,
267                                                   0);
268                            }
269    
270                            return True;
271                            break;
272    
273                    case XK_Meta_L: /* Windows keys */
274                    case XK_Super_L:
275                    case XK_Hyper_L:
276                    case XK_Meta_R:
277                    case XK_Super_R:
278                    case XK_Hyper_R:
279                            if (pressed)
280                            {
281                                    rdp_send_scancode(ev_time, RDP_KEYPRESS, SCANCODE_CHAR_LCTRL);
282                                    rdp_send_scancode(ev_time, RDP_KEYPRESS, SCANCODE_CHAR_ESC);
283                            }
284                            else
285                            {
286                                    rdp_send_scancode(ev_time, RDP_KEYRELEASE, SCANCODE_CHAR_ESC);
287                                    rdp_send_scancode(ev_time, RDP_KEYRELEASE, SCANCODE_CHAR_LCTRL);
288                            }
289                            return True;
290                            break;
291            }
292            return False;
293  }  }
294    
295    
296  key_translation  key_translation
297  xkeymap_translate_key(KeySym keysym, unsigned int keycode, unsigned int state)  xkeymap_translate_key(uint32 keysym, unsigned int keycode, unsigned int state)
298  {  {
299          key_translation tr = { 0, 0 };          key_translation tr = { 0, 0 };
300    
301          tr = keymap[keysym & KEYMAP_MASK];          tr = keymap[keysym & KEYMAP_MASK];
302    
303            if (tr.modifiers & MapInhibitMask)
304            {
305                    DEBUG_KBD(("Inhibiting key\n"));
306                    tr.scancode = 0;
307                    return tr;
308            }
309    
310          if (tr.modifiers & MapLocalStateMask)          if (tr.modifiers & MapLocalStateMask)
311          {          {
312                  /* The modifiers to send for this key should be obtained                  /* The modifiers to send for this key should be obtained
# Line 243  xkeymap_translate_key(KeySym keysym, uns Line 319  xkeymap_translate_key(KeySym keysym, uns
319    
320          if (tr.scancode != 0)          if (tr.scancode != 0)
321          {          {
322                  DEBUG_KBD                  DEBUG_KBD(("Found key translation, scancode=0x%x, modifiers=0x%x\n",
323                          ("Found key translation, scancode=0x%x, modifiers=0x%x\n",                             tr.scancode, tr.modifiers));
                          tr.scancode, tr.modifiers);  
324                  return tr;                  return tr;
325          }          }
326    
327          printf("No translation for (keysym 0x%lx, %s)\n", keysym,          DEBUG_KBD(("No translation for (keysym 0x%lx, %s)\n", keysym, get_ksname(keysym)));
                get_ksname(keysym));  
328    
329          /* not in keymap, try to interpret the raw scancode */          /* not in keymap, try to interpret the raw scancode */
330          if ((keycode >= min_keycode) && (keycode <= 0x60))          if ((keycode >= min_keycode) && (keycode <= 0x60))
331          {          {
332                  tr.scancode = keycode - min_keycode;                  tr.scancode = keycode - min_keycode;
333                  printf("Sending guessed scancode 0x%x\n", tr.scancode);  
334                    /* The modifiers to send for this key should be
335                       obtained from the local state. Currently, only
336                       shift is implemented. */
337                    if (state & ShiftMask)
338                    {
339                            tr.modifiers = MapLeftShiftMask;
340                    }
341    
342                    DEBUG_KBD(("Sending guessed scancode 0x%x\n", tr.scancode));
343          }          }
344          else          else
345          {          {
346                  printf("No good guess for keycode 0x%x found\n", keycode);                  DEBUG_KBD(("No good guess for keycode 0x%x found\n", keycode));
347          }          }
348    
349          return tr;          return tr;
# Line 287  xkeymap_translate_button(unsigned int bu Line 370  xkeymap_translate_button(unsigned int bu
370  }  }
371    
372  char *  char *
373  get_ksname(KeySym keysym)  get_ksname(uint32 keysym)
374  {  {
375          char *ksname = NULL;          char *ksname = NULL;
376    
# Line 299  get_ksname(KeySym keysym) Line 382  get_ksname(KeySym keysym)
382          return ksname;          return ksname;
383  }  }
384    
 BOOL  
 inhibit_key(KeySym keysym)  
 {  
         switch (keysym)  
         {  
                 case XK_Caps_Lock:  
                         return True;  
                         break;  
                 case XK_Multi_key:  
                         return True;  
                         break;  
                 default:  
                         break;  
         }  
         return False;  
 }  
385    
386  void  void
387  ensure_remote_modifiers(uint32 ev_time, key_translation tr)  ensure_remote_modifiers(uint32 ev_time, key_translation tr)
# Line 336  ensure_remote_modifiers(uint32 ev_time, Line 403  ensure_remote_modifiers(uint32 ev_time,
403                          break;                          break;
404          }          }
405    
406          /* Shift */          /* Shift. Left shift and right shift are treated as equal; either is fine. */
407          if (MASK_HAS_BITS(tr.modifiers, MapShiftMask)          if (MASK_HAS_BITS(tr.modifiers, MapShiftMask)
408              != MASK_HAS_BITS(remote_modifier_state, MapShiftMask))              != MASK_HAS_BITS(remote_modifier_state, MapShiftMask))
409          {          {
410                  /* The remote modifier state is not correct */                  /* The remote modifier state is not correct */
411                  if (MASK_HAS_BITS(tr.modifiers, MapShiftMask))                  if (MASK_HAS_BITS(tr.modifiers, MapLeftShiftMask))
412                  {                  {
413                          /* Needs this modifier. Send down. */                          /* Needs left shift. Send down. */
414                          rdp_send_scancode(ev_time, RDP_KEYPRESS,                          rdp_send_scancode(ev_time, RDP_KEYPRESS, SCANCODE_CHAR_LSHIFT);
415                                            SCANCODE_CHAR_LSHIFT);                  }
416                    else if (MASK_HAS_BITS(tr.modifiers, MapRightShiftMask))
417                    {
418                            /* Needs right shift. Send down. */
419                            rdp_send_scancode(ev_time, RDP_KEYPRESS, SCANCODE_CHAR_RSHIFT);
420                  }                  }
421                  else                  else
422                  {                  {
423                          /* Should not use this modifier. Send up. */                          /* Should not use this modifier. Send up for shift currently pressed. */
424                          rdp_send_scancode(ev_time, RDP_KEYRELEASE,                          if (MASK_HAS_BITS(remote_modifier_state, MapLeftShiftMask))
425                                            SCANCODE_CHAR_LSHIFT);                                  /* Left shift is down */
426                                    rdp_send_scancode(ev_time, RDP_KEYRELEASE, SCANCODE_CHAR_LSHIFT);
427                            else
428                                    /* Right shift is down */
429                                    rdp_send_scancode(ev_time, RDP_KEYRELEASE, SCANCODE_CHAR_RSHIFT);
430                  }                  }
431          }          }
432    
# Line 363  ensure_remote_modifiers(uint32 ev_time, Line 438  ensure_remote_modifiers(uint32 ev_time,
438                  if (MASK_HAS_BITS(tr.modifiers, MapAltGrMask))                  if (MASK_HAS_BITS(tr.modifiers, MapAltGrMask))
439                  {                  {
440                          /* Needs this modifier. Send down. */                          /* Needs this modifier. Send down. */
441                          rdp_send_scancode(ev_time, RDP_KEYPRESS,                          rdp_send_scancode(ev_time, RDP_KEYPRESS, SCANCODE_CHAR_RALT);
                                           SCANCODE_CHAR_RALT);  
442                  }                  }
443                  else                  else
444                  {                  {
445                          /* Should not use this modifier. Send up. */                          /* Should not use this modifier. Send up. */
446                          rdp_send_scancode(ev_time, RDP_KEYRELEASE,                          rdp_send_scancode(ev_time, RDP_KEYRELEASE, SCANCODE_CHAR_RALT);
                                           SCANCODE_CHAR_RALT);  
447                  }                  }
448          }          }
449    
# Line 379  ensure_remote_modifiers(uint32 ev_time, Line 452  ensure_remote_modifiers(uint32 ev_time,
452              != MASK_HAS_BITS(remote_modifier_state, MapNumLockMask))              != MASK_HAS_BITS(remote_modifier_state, MapNumLockMask))
453          {          {
454                  /* The remote modifier state is not correct */                  /* The remote modifier state is not correct */
455                  DEBUG_KBD("Remote NumLock state is incorrect. Toggling\n");                  uint16 new_remote_state = 0;
456    
457                  if (MASK_HAS_BITS(tr.modifiers, MapNumLockMask))                  if (MASK_HAS_BITS(tr.modifiers, MapNumLockMask))
458                  {                  {
459                          /* Needs this modifier. Toggle */                          DEBUG_KBD(("Remote NumLock state is incorrect, activating NumLock.\n"));
460                          rdp_send_scancode(ev_time, RDP_KEYPRESS,                          new_remote_state |= KBD_FLAG_NUMLOCK;
                                           SCANCODE_CHAR_NUMLOCK);  
                         rdp_send_scancode(ev_time, RDP_KEYRELEASE,  
                                           SCANCODE_CHAR_NUMLOCK);  
461                  }                  }
462                  else                  else
463                  {                  {
464                          /* Should not use this modifier. Toggle */                          DEBUG_KBD(("Remote NumLock state is incorrect, deactivating NumLock.\n"));
                         rdp_send_scancode(ev_time, RDP_KEYPRESS,  
                                           SCANCODE_CHAR_NUMLOCK);  
                         rdp_send_scancode(ev_time, RDP_KEYRELEASE,  
                                           SCANCODE_CHAR_NUMLOCK);  
465                  }                  }
466    
467                    rdp_send_input(0, RDP_INPUT_SYNCHRONIZE, 0, new_remote_state, 0);
468                    update_modifier_state(SCANCODE_CHAR_NUMLOCK, True);
469          }          }
470    }
471    
472    
473    void
474    reset_modifier_keys(void)
475    {
476            /* reset keys */
477            uint32 ev_time;
478            ev_time = time(NULL);
479    
480            if (MASK_HAS_BITS(remote_modifier_state, MapLeftShiftMask) && !get_key_state(XK_Shift_L))
481                    rdp_send_scancode(ev_time, RDP_KEYRELEASE, SCANCODE_CHAR_LSHIFT);
482    
483            if (MASK_HAS_BITS(remote_modifier_state, MapRightShiftMask) && !get_key_state(XK_Shift_R))
484                    rdp_send_scancode(ev_time, RDP_KEYRELEASE, SCANCODE_CHAR_RSHIFT);
485    
486            if (MASK_HAS_BITS(remote_modifier_state, MapLeftCtrlMask) && !get_key_state(XK_Control_L))
487                    rdp_send_scancode(ev_time, RDP_KEYRELEASE, SCANCODE_CHAR_LCTRL);
488    
489            if (MASK_HAS_BITS(remote_modifier_state, MapRightCtrlMask) && !get_key_state(XK_Control_R))
490                    rdp_send_scancode(ev_time, RDP_KEYRELEASE, SCANCODE_CHAR_RCTRL);
491    
492            if (MASK_HAS_BITS(remote_modifier_state, MapLeftAltMask) && !get_key_state(XK_Alt_L))
493                    rdp_send_scancode(ev_time, RDP_KEYRELEASE, SCANCODE_CHAR_LALT);
494    
495            if (MASK_HAS_BITS(remote_modifier_state, MapRightAltMask) &&
496                !get_key_state(XK_Alt_R) && !get_key_state(XK_Mode_switch))
497                    rdp_send_scancode(ev_time, RDP_KEYRELEASE, SCANCODE_CHAR_RALT);
498  }  }
499    
500    
501  static void  static void
502  update_modifier_state(uint16 modifiers, BOOL pressed)  update_modifier_state(uint16 modifiers, BOOL pressed)
503  {  {
504    #ifdef WITH_DEBUG_KBD
505            uint16 old_modifier_state;
506    
507            old_modifier_state = remote_modifier_state;
508    #endif
509    
         DEBUG_KBD("Before updating modifier_state:0x%x, pressed=0x%x\n",  
                   remote_modifier_state, pressed);  
510          switch (modifiers)          switch (modifiers)
511          {          {
512                  case SCANCODE_CHAR_LSHIFT:                  case SCANCODE_CHAR_LSHIFT:
513                          MASK_CHANGE_BIT(remote_modifier_state,                          MASK_CHANGE_BIT(remote_modifier_state, MapLeftShiftMask, pressed);
                                         MapLeftShiftMask, pressed);  
514                          break;                          break;
515                  case SCANCODE_CHAR_RSHIFT:                  case SCANCODE_CHAR_RSHIFT:
516                          MASK_CHANGE_BIT(remote_modifier_state,                          MASK_CHANGE_BIT(remote_modifier_state, MapRightShiftMask, pressed);
                                         MapRightShiftMask, pressed);  
517                          break;                          break;
518                  case SCANCODE_CHAR_LCTRL:                  case SCANCODE_CHAR_LCTRL:
519                          MASK_CHANGE_BIT(remote_modifier_state,                          MASK_CHANGE_BIT(remote_modifier_state, MapLeftCtrlMask, pressed);
                                         MapLeftCtrlMask, pressed);  
520                          break;                          break;
521                  case SCANCODE_CHAR_RCTRL:                  case SCANCODE_CHAR_RCTRL:
522                          MASK_CHANGE_BIT(remote_modifier_state,                          MASK_CHANGE_BIT(remote_modifier_state, MapRightCtrlMask, pressed);
                                         MapRightCtrlMask, pressed);  
523                          break;                          break;
524                  case SCANCODE_CHAR_LALT:                  case SCANCODE_CHAR_LALT:
525                          MASK_CHANGE_BIT(remote_modifier_state, MapLeftAltMask,                          MASK_CHANGE_BIT(remote_modifier_state, MapLeftAltMask, pressed);
                                         pressed);  
526                          break;                          break;
527                  case SCANCODE_CHAR_RALT:                  case SCANCODE_CHAR_RALT:
528                          MASK_CHANGE_BIT(remote_modifier_state,                          MASK_CHANGE_BIT(remote_modifier_state, MapRightAltMask, pressed);
                                         MapRightAltMask, pressed);  
529                          break;                          break;
530                  case SCANCODE_CHAR_LWIN:                  case SCANCODE_CHAR_LWIN:
531                          MASK_CHANGE_BIT(remote_modifier_state, MapLeftWinMask,                          MASK_CHANGE_BIT(remote_modifier_state, MapLeftWinMask, pressed);
                                         pressed);  
532                          break;                          break;
533                  case SCANCODE_CHAR_RWIN:                  case SCANCODE_CHAR_RWIN:
534                          MASK_CHANGE_BIT(remote_modifier_state,                          MASK_CHANGE_BIT(remote_modifier_state, MapRightWinMask, pressed);
                                         MapRightWinMask, pressed);  
535                          break;                          break;
536                  case SCANCODE_CHAR_NUMLOCK:                  case SCANCODE_CHAR_NUMLOCK:
537                          /* KeyReleases for NumLocks are sent immediately. Toggle the                          /* KeyReleases for NumLocks are sent immediately. Toggle the
# Line 449  update_modifier_state(uint16 modifiers, Line 541  update_modifier_state(uint16 modifiers,
541                                  BOOL newNumLockState;                                  BOOL newNumLockState;
542                                  newNumLockState =                                  newNumLockState =
543                                          (MASK_HAS_BITS                                          (MASK_HAS_BITS
544                                           (remote_modifier_state,                                           (remote_modifier_state, MapNumLockMask) == False);
                                           MapNumLockMask) == False);  
545                                  MASK_CHANGE_BIT(remote_modifier_state,                                  MASK_CHANGE_BIT(remote_modifier_state,
546                                                  MapNumLockMask,                                                  MapNumLockMask, newNumLockState);
                                                 newNumLockState);  
547                          }                          }
548                          break;                          break;
549          }          }
550          DEBUG_KBD("After updating modifier_state:0x%x\n",  
551                    remote_modifier_state);  #ifdef WITH_DEBUG_KBD
552            if (old_modifier_state != remote_modifier_state)
553            {
554                    DEBUG_KBD(("Before updating modifier_state:0x%x, pressed=0x%x\n",
555                               old_modifier_state, pressed));
556                    DEBUG_KBD(("After updating modifier_state:0x%x\n", remote_modifier_state));
557            }
558    #endif
559    
560  }  }
561    
# Line 470  rdp_send_scancode(uint32 time, uint16 fl Line 567  rdp_send_scancode(uint32 time, uint16 fl
567    
568          if (scancode & SCANCODE_EXTENDED)          if (scancode & SCANCODE_EXTENDED)
569          {          {
570                  DEBUG_KBD("Sending extended scancode=0x%x, flags=0x%x\n",                  DEBUG_KBD(("Sending extended scancode=0x%x, flags=0x%x\n",
571                            scancode & ~SCANCODE_EXTENDED, flags);                             scancode & ~SCANCODE_EXTENDED, flags));
572                  rdp_send_input(time, RDP_INPUT_SCANCODE, flags | KBD_FLAG_EXT,                  rdp_send_input(time, RDP_INPUT_SCANCODE, flags | KBD_FLAG_EXT,
573                                 scancode & ~SCANCODE_EXTENDED, 0);                                 scancode & ~SCANCODE_EXTENDED, 0);
574          }          }
575          else          else
576          {          {
577                  DEBUG_KBD("Sending scancode=0x%x, flags=0x%x\n", scancode,                  DEBUG_KBD(("Sending scancode=0x%x, flags=0x%x\n", scancode, flags));
                           flags);  
578                  rdp_send_input(time, RDP_INPUT_SCANCODE, flags, scancode, 0);                  rdp_send_input(time, RDP_INPUT_SCANCODE, flags, scancode, 0);
579          }          }
580  }  }
Legend:
Removed from v.77  
changed lines
  Added in v.199
  ViewVC Help
Powered by ViewVC 1.1.26