git.oblomov.eu Git - wine/blob - windows/keyboard.c

   1 /*
   2  * Keyboard related functions
   3  *
   4  * Copyright 1993 Bob Amstadt
   5  * Copyright 1996 Albrecht Kleine
   6  * Copyright 1997 David Faure
   7  *
   8  */
   9
  10 #include <stdlib.h>
  11 #include <stdio.h>
  12 #include <string.h>
  13 #include <ctype.h>
  14 #include <X11/keysym.h>
  15 #include <X11/Xlib.h>
  16 #include <X11/Xresource.h>
  17 #include <X11/Xutil.h>
  18 #include <X11/Xatom.h>
  19
  20 #include "windows.h"
  21 #include "win.h"
  22 #include "gdi.h"
  23 #include "keyboard.h"
  24 #include "message.h"
  25 #include "stddebug.h"
  26 /* #define DEBUG_KEYBOARD */
  27 #include "debug.h"
  28 #include "xmalloc.h"
  29 #include "accel.h"
  30 #include "struct32.h"
  31
  32 BOOL32 MouseButtonsStates[3];
  33 BOOL32 AsyncMouseButtonsStates[3];
  34 BYTE InputKeyStateTable[256];
  35 BYTE QueueKeyStateTable[256];
  36 BYTE AsyncKeyStateTable[256];
  37
  38 static int NumLockMask;
  39 static int AltGrMask;
  40 static int min_keycode, max_keycode;
  41 static int keyc2vkey[256];
  42
  43 typedef union
  44 {
  45     struct
  46     {
  47         unsigned long count : 16;
  48         unsigned long code : 8;
  49         unsigned long extended : 1;
  50         unsigned long unused : 2;
  51         unsigned long win_internal : 2;
  52         unsigned long context : 1;
  53         unsigned long previous : 1;
  54         unsigned long transition : 1;
  55     } lp1;
  56     unsigned long lp2;
  57 } KEYLP;
  58
  59 /* Keyboard translation tables */
  60 static const int special_key[] =
  61 {
  62     VK_BACK, VK_TAB, 0, VK_CLEAR, 0, VK_RETURN, 0, 0,           /* FF08 */
  63     0, 0, 0, VK_PAUSE, VK_SCROLL, 0, 0, 0,                      /* FF10 */
  64     0, 0, 0, VK_ESCAPE                                          /* FF18 */
  65 };
  66
  67 static const int cursor_key[] =
  68 {
  69     VK_HOME, VK_LEFT, VK_UP, VK_RIGHT, VK_DOWN, VK_PRIOR,
  70                                        VK_NEXT, VK_END          /* FF50 */
  71 };
  72
  73 static const int misc_key[] =
  74 {
  75     VK_SELECT, VK_SNAPSHOT, VK_EXECUTE, VK_INSERT, 0, 0, 0, 0,  /* FF60 */
  76     VK_CANCEL, VK_HELP, VK_CANCEL, VK_MENU                      /* FF68 */
  77 };
  78
  79 static const int keypad_key[] =
  80 {
  81     0, VK_NUMLOCK,                                              /* FF7E */
  82     0, 0, 0, 0, 0, 0, 0, 0,                                     /* FF80 */
  83     0, 0, 0, 0, 0, VK_RETURN, 0, 0,                             /* FF88 */
  84     0, 0, 0, 0, 0, VK_HOME, VK_LEFT, VK_UP,                     /* FF90 */
  85     VK_RIGHT, VK_DOWN, VK_PRIOR, VK_NEXT, VK_END, 0,
  86                                  VK_INSERT, VK_DELETE,          /* FF98 */
  87     0, 0, 0, 0, 0, 0, 0, 0,                                     /* FFA0 */
  88     0, 0, VK_MULTIPLY, VK_ADD, VK_SEPARATOR, VK_SUBTRACT,
  89                                VK_DECIMAL, VK_DIVIDE,           /* FFA8 */
  90     VK_NUMPAD0, VK_NUMPAD1, VK_NUMPAD2, VK_NUMPAD3, VK_NUMPAD4,
  91                             VK_NUMPAD5, VK_NUMPAD6, VK_NUMPAD7, /* FFB0 */
  92     VK_NUMPAD8, VK_NUMPAD9                                      /* FFB8 */
  93 };
  94
  95 static const int function_key[] =
  96 {
  97     VK_F1, VK_F2,                                               /* FFBE */
  98     VK_F3, VK_F4, VK_F5, VK_F6, VK_F7, VK_F8, VK_F9, VK_F10,    /* FFC0 */
  99     VK_F11, VK_F12, VK_F13, VK_F14, VK_F15, VK_F16              /* FFC8 */
 100 };
 101
 102 static const int modifier_key[] =
 103 {
 104     VK_SHIFT, VK_SHIFT, VK_CONTROL, VK_CONTROL, VK_CAPITAL, 0, /* FFE1 */
 105     VK_MENU, VK_MENU, VK_MENU, VK_MENU                         /* FFE7 */
 106 };
 107
 108
 109 static WORD EVENT_event_to_vkey( XKeyEvent *e)
 110 {
 111     KeySym keysym;
 112
 113     XLookupString(e, NULL, 0, &keysym, NULL);
 114
 115     if ((keysym >= 0xFFAE) && (keysym <= 0xFFB9) && (e->state & NumLockMask))
 116         /* Only the Keypad keys 0-9 and . send different keysyms
 117          * depending on the NumLock state */
 118         return keypad_key[(keysym & 0xFF) - 0x7E];
 119
 120     return keyc2vkey[e->keycode];
 121 }
 122
 123 /**********************************************************************
 124  *              KEYBOARD_Init
 125  */
 126 BOOL32 KEYBOARD_Init(void)
 127 {
 128     int i, keysyms_per_keycode;
 129     KeySym *ksp;
 130     XModifierKeymap *mmp;
 131     KeySym keysym;
 132     KeyCode *kcp;
 133     XKeyEvent e2;
 134     WORD vkey, OEMvkey;
 135
 136     XDisplayKeycodes(display, &min_keycode, &max_keycode);
 137     ksp = XGetKeyboardMapping(display, min_keycode,
 138                               max_keycode + 1 - min_keycode, &keysyms_per_keycode);
 139     /* We are only interested in keysyms_per_keycode.
 140        There is no need to hold a local copy of the keysyms table */
 141     XFree(ksp);
 142     mmp = XGetModifierMapping(display);
 143     kcp = mmp->modifiermap;
 144     for (i = 0; i < 8; i += 1) /* There are 8 modifier keys */
 145     {
 146         int j;
 147
 148         for (j = 0; j < mmp->max_keypermod; j += 1, kcp += 1)
 149             if (*kcp)
 150             {
 151                 int k;
 152
 153                 for (k = 0; k < keysyms_per_keycode; k += 1)
 154                     if (XKeycodeToKeysym(display, *kcp, k) == XK_Mode_switch)
 155                     {
 156                         AltGrMask = 1 << i;
 157                         dprintf_key(stddeb, "AltGrMask is %x\n", AltGrMask);
 158                     }
 159                     else if (XKeycodeToKeysym(display, *kcp, k) == XK_Num_Lock)
 160                     {
 161                         NumLockMask = 1 << i;
 162                         dprintf_key(stddeb, "NumLockMask is %x\n", NumLockMask);
 163                     }
 164             }
 165     }
 166     XFreeModifiermap(mmp);
 167
 168     /* Now build two conversion arrays :
 169      * keycode -> vkey + extended
 170      * vkey + extended -> keycode */
 171
 172     e2.display = display;
 173     e2.state = 0;
 174
 175     OEMvkey = 0xb9; /* first OEM virtual key available is ba */
 176     for (e2.keycode=min_keycode; e2.keycode<=max_keycode; e2.keycode++)
 177     {
 178         XLookupString(&e2, NULL, 0, &keysym, NULL);
 179         vkey = 0;
 180         if (keysym)  /* otherwise, keycode not used */
 181         {
 182             if ((keysym >> 8) == 0xFF)         /* non-character key */
 183             {
 184                 int key = keysym & 0xff;
 185
 186                 if (key >= 0x08 && key <= 0x1B)         /* special key */
 187                     vkey = special_key[key - 0x08];
 188                 else if (key >= 0x50 && key <= 0x57)    /* cursor key */
 189                     vkey = cursor_key[key - 0x50];
 190                 else if (key >= 0x60 && key <= 0x6B)    /* miscellaneous key */
 191                     vkey = misc_key[key - 0x60];
 192                 else if (key >= 0x7E && key <= 0xB9)    /* keypad key */
 193                     vkey = keypad_key[key - 0x7E];
 194                 else if (key >= 0xBE && key <= 0xCD)    /* function key */
 195                 {
 196                     vkey = function_key[key - 0xBE];
 197                     vkey |= 0x100; /* set extended bit */
 198                 }
 199                 else if (key >= 0xE1 && key <= 0xEA)    /* modifier key */
 200                     vkey = modifier_key[key - 0xE1];
 201                 else if (key == 0xFF)                   /* DEL key */
 202                     vkey = VK_DELETE;
 203                 /* extended must also be set for ALT_R, CTRL_R,
 204                    INS, DEL, HOME, END, PAGE_UP, PAGE_DOWN, ARROW keys,
 205                    keypad / and keypad ENTER (SDK 3.1 Vol.3 p 138) */
 206                 /* FIXME should we set extended bit for NumLock ? My
 207                  * Windows does ... DF */
 208                 switch (keysym)
 209                 {
 210                 case XK_Control_R :
 211                 case XK_Alt_R :
 212                 case XK_Insert :
 213                 case XK_Delete :
 214                 case XK_Home :
 215                 case XK_End :
 216                 case XK_Prior :
 217                 case XK_Next :
 218                 case XK_Left :
 219                 case XK_Up :
 220                 case XK_Right :
 221                 case XK_Down :
 222                 case XK_KP_Divide :
 223                 case XK_KP_Enter :
 224                     vkey |= 0x100;
 225                 }
 226             }
 227             for (i = 0; (i < keysyms_per_keycode) && (!vkey); i++)
 228             {
 229                 keysym = XLookupKeysym(&e2, i);
 230                 if ((keysym >= VK_0 && keysym <= VK_9)
 231                     || (keysym >= VK_A && keysym <= VK_Z)
 232                     || keysym == VK_SPACE)
 233                     vkey = keysym;
 234             }
 235
 236             if (!vkey)
 237             {
 238                 /* Others keys: let's assign OEM virtual key codes in the allowed range,
 239                  * that is ([0xba,0xc0], [0xdb,0xe4], 0xe6 (given up) et [0xe9,0xf5]) */
 240                 switch (++OEMvkey)
 241                 {
 242                 case 0xc1 : OEMvkey=0xdb; break;
 243                 case 0xe5 : OEMvkey=0xe9; break;
 244                 case 0xf6 : OEMvkey=0xf5; fprintf(stderr,"No more OEM vkey available!\n");
 245                 }
 246
 247                 vkey = OEMvkey;
 248
 249                 if (debugging_keyboard)
 250                 {
 251                     fprintf(stddeb,"OEM specific virtual key %X assigned to keycode %X :\n ("
 252                             ,OEMvkey,e2.keycode);
 253                     for (i = 0; i < keysyms_per_keycode; i += 1)
 254                     {
 255                         char    *ksname;
 256
 257                         keysym = XLookupKeysym(&e2, i);
 258                         ksname = XKeysymToString(keysym);
 259                         if (!ksname)
 260                             ksname = "NoSymbol";
 261                         fprintf(stddeb, "%lX (%s) ", keysym, ksname);
 262                     }
 263                     fprintf(stddeb, ")\n");
 264                 }
 265             }
 266         }
 267         keyc2vkey[e2.keycode] = vkey;
 268     } /* for */
 269     return TRUE;
 270 }
 271
 272 static BOOL32 NumState=FALSE, CapsState=FALSE;
 273
 274 void KEYBOARD_GenerateMsg( WORD vkey, int Evtype, XKeyEvent * event, KEYLP localkeylp )
 275 {
 276   BOOL32 * State = (vkey==VK_NUMLOCK? &NumState : &CapsState);
 277
 278   if (*State) {
 279     /* The INTERMEDIARY state means : just after a 'press' event, if a 'release' event comes,
 280        don't treat it. It's from the same key press. Then the state goes to ON.
 281        And from there, a 'release' event will switch off the toggle key. */
 282     *State=FALSE;
 283     dprintf_keyboard(stddeb,"INTERM : don\'t treat release of toggle key. InputKeyStateTable[%#x] = %#x\n",vkey,InputKeyStateTable[vkey]);
 284   } else
 285     {
 286         if ( InputKeyStateTable[vkey] & 0x1 ) /* it was ON */
 287           {
 288             if (Evtype!=KeyPress)
 289               {
 290                 dprintf_keyboard(stddeb,"ON + KeyRelease => generating DOWN and UP messages.\n");
 291                 localkeylp.lp1.previous = 0; /* ? */
 292                 localkeylp.lp1.transition = 0;
 293                 hardware_event( WM_KEYDOWN, vkey, localkeylp.lp2, event->x_root - desktopX,
 294                                 event->y_root - desktopY, event->time - MSG_WineStartTicks, 0);
 295                 hardware_event( WM_KEYUP, vkey, localkeylp.lp2, event->x_root - desktopX,
 296                                 event->y_root - desktopY, event->time - MSG_WineStartTicks, 0);
 297                 *State=FALSE;
 298                 InputKeyStateTable[vkey] &= ~0x01; /* Toggle state to off. */
 299               }
 300           }
 301         else /* it was OFF */
 302           if (Evtype==KeyPress)
 303             {
 304               dprintf_keyboard(stddeb,"OFF + Keypress => generating DOWN and UP messages.\n");
 305               hardware_event( WM_KEYDOWN, vkey, localkeylp.lp2, event->x_root - desktopX,
 306                               event->y_root - desktopY, event->time - MSG_WineStartTicks, 0);
 307               localkeylp.lp1.previous = 1;
 308               localkeylp.lp1.transition = 1;
 309               hardware_event( WM_KEYUP, vkey, localkeylp.lp2, event->x_root - desktopX,
 310                               event->y_root - desktopY, event->time - MSG_WineStartTicks, 0);
 311               *State=TRUE; /* Goes to intermediary state before going to ON */
 312               InputKeyStateTable[vkey] |= 0x01; /* Toggle state to on. */
 313             }
 314     }
 315 }
 316
 317 /***********************************************************************
 318  *           KEYBOARD_HandleEvent
 319  *
 320  * Handle a X key event
 321  */
 322 void KEYBOARD_HandleEvent( XKeyEvent *event )
 323 {
 324     char Str[24];
 325     XComposeStatus cs;
 326     KeySym keysym;
 327     WORD vkey = 0;
 328     KEYLP keylp;
 329     static BOOL32 force_extended = FALSE; /* hack for AltGr translation */
 330
 331     int ascii_chars = XLookupString(event, Str, 1, &keysym, &cs);
 332
 333     dprintf_key(stddeb, "EVENT_key : state = %X\n", event->state);
 334     if (keysym == XK_Mode_switch)
 335         {
 336         dprintf_key(stddeb, "Alt Gr key event received\n");
 337         event->keycode = XKeysymToKeycode(event->display, XK_Control_L);
 338         dprintf_key(stddeb, "Control_L is keycode 0x%x\n", event->keycode);
 339         KEYBOARD_HandleEvent(event);
 340         event->keycode = XKeysymToKeycode(event->display, XK_Alt_L);
 341         dprintf_key(stddeb, "Alt_L is keycode 0x%x\n", event->keycode);
 342         force_extended = TRUE;
 343         KEYBOARD_HandleEvent(event);
 344         force_extended = FALSE;
 345         return;
 346         }
 347
 348     Str[ascii_chars] = '\0';
 349     if (debugging_key)
 350         {
 351         char    *ksname;
 352
 353         ksname = XKeysymToString(keysym);
 354         if (!ksname)
 355             ksname = "No Name";
 356         fprintf(stddeb, "%s : keysym=%lX (%s), ascii chars=%u / %X / '%s'\n",
 357                 (event->type == KeyPress) ? "KeyPress" : "KeyRelease",
 358                 keysym, ksname, ascii_chars, Str[0] & 0xff, Str);
 359         }
 360
 361     vkey = EVENT_event_to_vkey(event);
 362     if (force_extended) vkey |= 0x100;
 363
 364     dprintf_key(stddeb, "keycode 0x%x converted to vkey 0x%x\n",
 365                     event->keycode, vkey);
 366
 367    if (vkey)
 368    {
 369     keylp.lp1.count = 1;
 370     keylp.lp1.code = LOBYTE(event->keycode) - 8;
 371     keylp.lp1.extended = (vkey & 0x100 ? 1 : 0);
 372     keylp.lp1.win_internal = 0; /* this has something to do with dialogs,
 373                                 * don't remember where I read it - AK */
 374                                 /* it's '1' under windows, when a dialog box appears
 375                                  * and you press one of the underlined keys - DF*/
 376     vkey &= 0xff;
 377
 378     switch(vkey)
 379     {
 380     case VK_NUMLOCK:
 381       KEYBOARD_GenerateMsg(VK_NUMLOCK,event->type,event,keylp); break;
 382     case VK_CAPITAL:
 383       dprintf_keyboard(stddeb,"Caps Lock event. (type %d). State before : %#.2x\n",event->type,InputKeyStateTable[vkey]);
 384       KEYBOARD_GenerateMsg(VK_CAPITAL,event->type,event,keylp);
 385       dprintf_keyboard(stddeb,"State after : %#.2x\n",InputKeyStateTable[vkey]);
 386       break;
 387     default:
 388       {
 389         WORD message;
 390         if (event->type == KeyPress)
 391           {
 392             keylp.lp1.previous = (InputKeyStateTable[vkey] & 0x80) != 0;
 393             if (!(InputKeyStateTable[vkey] & 0x80))
 394               InputKeyStateTable[vkey] ^= 0x01;
 395             InputKeyStateTable[vkey] |= 0x80;
 396             keylp.lp1.transition = 0;
 397             message = (InputKeyStateTable[VK_MENU] & 0x80)
 398               && !(InputKeyStateTable[VK_CONTROL] & 0x80)
 399               ? WM_SYSKEYDOWN : WM_KEYDOWN;
 400           }
 401         else
 402           {
 403             BOOL32 sysKey = (InputKeyStateTable[VK_MENU] & 0x80)
 404                 && !(InputKeyStateTable[VK_CONTROL] & 0x80)
 405                 && (force_extended == FALSE); /* for Alt from AltGr */
 406
 407             InputKeyStateTable[vkey] &= ~0x80;
 408             keylp.lp1.previous = 1;
 409             keylp.lp1.transition = 1;
 410             message = sysKey ? WM_SYSKEYUP : WM_KEYUP;
 411           }
 412         keylp.lp1.context = ( (event->state & Mod1Mask)  ||
 413                               (InputKeyStateTable[VK_MENU] & 0x80)) ? 1 : 0;
 414         if (!(InputKeyStateTable[VK_NUMLOCK] & 0x01) != !(event->state & NumLockMask))
 415           {
 416             dprintf_keyboard(stddeb,"Adjusting NumLock state. \n");
 417             KEYBOARD_GenerateMsg(VK_NUMLOCK,KeyPress,event,keylp);
 418             KEYBOARD_GenerateMsg(VK_NUMLOCK,KeyRelease,event,keylp);
 419           }
 420         if (!(InputKeyStateTable[VK_CAPITAL] & 0x01) != !(event->state & LockMask))
 421           {
 422             dprintf_keyboard(stddeb,"Adjusting Caps Lock state. State before %#.2x \n",InputKeyStateTable[VK_CAPITAL]);
 423             KEYBOARD_GenerateMsg(VK_CAPITAL,KeyPress,event,keylp);
 424             KEYBOARD_GenerateMsg(VK_CAPITAL,KeyRelease,event,keylp);
 425             dprintf_keyboard(stddeb,"State after %#.2x \n",InputKeyStateTable[VK_CAPITAL]);
 426           }
 427         /* End of intermediary states. */
 428         NumState = FALSE;
 429         CapsState = FALSE;
 430
 431         dprintf_key(stddeb,"            wParam=%04X, lParam=%08lX\n",
 432                     vkey, keylp.lp2 );
 433         dprintf_key(stddeb,"            InputKeyState=%X\n",
 434                     InputKeyStateTable[vkey]);
 435
 436         hardware_event( message, vkey, keylp.lp2, event->x_root - desktopX,
 437                         event->y_root - desktopY, event->time - MSG_WineStartTicks, 0 );
 438       }
 439     }
 440    }
 441 }
 442
 443
 444 /**********************************************************************
 445  *              GetKeyState                     [USER.106]
 446  */
 447 WORD GetKeyState16(INT16 vkey)
 448 {
 449     return GetKeyState32(vkey);
 450 }
 451
 452 /**********************************************************************
 453  *              GetKeyState                     [USER32.248]
 454  * An application calls the GetKeyState function in response to a
 455  * keyboard-input message.  This function retrieves the state of the key
 456  * at the time the input message was generated.  (SDK 3.1 Vol 2. p 390)
 457  */
 458 WORD GetKeyState32(INT32 vkey)
 459 {
 460     INT32 retval;
 461
 462     switch (vkey)
 463         {
 464         case VK_LBUTTON : /* VK_LBUTTON is 1 */
 465             retval = MouseButtonsStates[0];
 466             break;
 467         case VK_MBUTTON : /* VK_MBUTTON is 4 */
 468             retval = MouseButtonsStates[1];
 469             break;
 470         case VK_RBUTTON : /* VK_RBUTTON is 2 */
 471             retval = MouseButtonsStates[2];
 472             break;
 473         default :
 474             if (vkey >= 'a' && vkey <= 'z')
 475                 vkey += 'A' - 'a';
 476             retval = ( (WORD)(QueueKeyStateTable[vkey] & 0x80) << 8 ) |
 477                        (WORD)(QueueKeyStateTable[vkey] & 0x01);
 478         }
 479     dprintf_key(stddeb, "GetKeyState(0x%x) -> %x\n", vkey, retval);
 480     return retval;
 481 }
 482
 483 /**********************************************************************
 484  *              GetKeyboardState        [USER.222][USER32.253]
 485  * An application calls the GetKeyboardState function in response to a
 486  * keyboard-input message.  This function retrieves the state of the keyboard
 487  * at the time the input message was generated.  (SDK 3.1 Vol 2. p 387)
 488  */
 489 VOID GetKeyboardState(LPBYTE lpKeyState)
 490 {
 491     dprintf_key(stddeb, "GetKeyboardState()\n");
 492     if (lpKeyState != NULL) {
 493         QueueKeyStateTable[VK_LBUTTON] = MouseButtonsStates[0] >> 8;
 494         QueueKeyStateTable[VK_MBUTTON] = MouseButtonsStates[1] >> 8;
 495         QueueKeyStateTable[VK_RBUTTON] = MouseButtonsStates[2] >> 8;
 496         memcpy(lpKeyState, QueueKeyStateTable, 256);
 497     }
 498 }
 499
 500 /**********************************************************************
 501  *      SetKeyboardState            [USER.223][USER32.483]
 502  */
 503 VOID SetKeyboardState(LPBYTE lpKeyState)
 504 {
 505     dprintf_key(stddeb, "SetKeyboardState()\n");
 506     if (lpKeyState != NULL) {
 507         memcpy(QueueKeyStateTable, lpKeyState, 256);
 508         MouseButtonsStates[0] = QueueKeyStateTable[VK_LBUTTON]? 0x8000: 0;
 509         MouseButtonsStates[1] = QueueKeyStateTable[VK_MBUTTON]? 0x8000: 0;
 510         MouseButtonsStates[2] = QueueKeyStateTable[VK_RBUTTON]? 0x8000: 0;
 511     }
 512 }
 513
 514 /**********************************************************************
 515  *            GetAsyncKeyState        (USER32.206)
 516  *
 517  *      Determine if a key is or was pressed.  retval has high-order
 518  * bit set to 1 if currently pressed, low-order bit set to 1 if key has
 519  * been pressed.
 520  *
 521  *      This uses the variable AsyncMouseButtonsStates and
 522  * AsyncKeyStateTable (set in event.c) which have the mouse button
 523  * number or key number (whichever is applicable) set to true if the
 524  * mouse or key had been depressed since the last call to
 525  * GetAsyncKeyState.
 526  */
 527 WORD GetAsyncKeyState32(INT32 nKey)
 528 {
 529     short retval;
 530
 531     switch (nKey) {
 532      case VK_LBUTTON:
 533         retval = AsyncMouseButtonsStates[0] |
 534         MouseButtonsStates[0]? 0x0001: 0;
 535         break;
 536      case VK_MBUTTON:
 537         retval = AsyncMouseButtonsStates[1] |
 538         MouseButtonsStates[1]? 0x0001: 0;
 539         break;
 540      case VK_RBUTTON:
 541         retval = AsyncMouseButtonsStates[2] |
 542         MouseButtonsStates[2]? 0x0001: 0;
 543         break;
 544      default:
 545         retval = AsyncKeyStateTable[nKey] |
 546                 ((InputKeyStateTable[nKey] & 0x80) ? 0x8000 : 0);
 547         break;
 548     }
 549
 550     memset( AsyncMouseButtonsStates, 0, 3 );  /* all states to false */
 551     memset( AsyncKeyStateTable, 0, 256 );
 552
 553     dprintf_key(stddeb, "GetAsyncKeyState(%x) -> %x\n", nKey, retval);
 554     return retval;
 555 }
 556
 557 /**********************************************************************
 558  *            GetAsyncKeyState        (USER.249)
 559  */
 560 WORD GetAsyncKeyState16(INT16 nKey)
 561 {
 562     return GetAsyncKeyState32(nKey);
 563 }
 564
 565
 566
 567 /**********************************************************************
 568  *                      TranslateAccelerator    [USER.178]
 569  *
 570  * FIXME: should send some WM_INITMENU or/and WM_INITMENUPOPUP  -messages
 571  */
 572 INT32 TranslateAccelerator32(HWND32 hWnd, HACCEL32 hAccel, LPMSG32 msg)
 573 {
 574     MSG16       msg16;
 575
 576     STRUCT32_MSG32to16(msg,&msg16);
 577     return TranslateAccelerator16(hWnd,hAccel,&msg16);
 578 }
 579
 580 INT16 TranslateAccelerator16(HWND16 hWnd, HACCEL16 hAccel, LPMSG16 msg)
 581 {
 582     ACCELHEADER *lpAccelTbl;
 583     int         i;
 584     BOOL32 sendmsg;
 585
 586     if (hAccel == 0 || msg == NULL) return 0;
 587     if (msg->message != WM_KEYDOWN &&
 588         msg->message != WM_KEYUP &&
 589         msg->message != WM_SYSKEYDOWN &&
 590         msg->message != WM_SYSKEYUP &&
 591         msg->message != WM_CHAR) return 0;
 592
 593     dprintf_accel(stddeb, "TranslateAccelerators hAccel=%04x, hWnd=%04x,\
 594 msg->hwnd=%04x, msg->message=%04x\n", hAccel,hWnd,msg->hwnd,msg->message);
 595
 596     lpAccelTbl = (LPACCELHEADER)GlobalLock16(hAccel);
 597     for (sendmsg= i = 0; i < lpAccelTbl->wCount; i++)
 598     {
 599      if(msg->wParam == lpAccelTbl->tbl[i].wEvent)
 600      {
 601       if (msg->message == WM_CHAR)
 602       {
 603         if ( !(lpAccelTbl->tbl[i].type & ALT_ACCEL) &&
 604              !(lpAccelTbl->tbl[i].type & VIRTKEY_ACCEL) )
 605         {
 606           dprintf_accel(stddeb,"found accel for WM_CHAR: ('%c')",msg->wParam&0xff);
 607           sendmsg=TRUE;
 608         }
 609       }
 610       else
 611       {
 612        if(lpAccelTbl->tbl[i].type & VIRTKEY_ACCEL)
 613        {
 614         INT32 mask = 0;
 615         dprintf_accel(stddeb,"found accel for virt_key %04x (scan %04x)",
 616                                msg->wParam,0xff & HIWORD(msg->lParam));
 617         if(GetKeyState32(VK_SHIFT) & 0x8000) mask |= SHIFT_ACCEL;
 618         if(GetKeyState32(VK_CONTROL) & 0x8000) mask |= CONTROL_ACCEL;
 619         if(GetKeyState32(VK_MENU) & 0x8000) mask |= ALT_ACCEL;
 620         if(mask == (lpAccelTbl->tbl[i].type &
 621                             (SHIFT_ACCEL | CONTROL_ACCEL | ALT_ACCEL)))
 622           sendmsg=TRUE;
 623         else
 624           dprintf_accel(stddeb,", but incorrect SHIFT/CTRL/ALT-state\n");
 625        }
 626        else
 627        {
 628          if (!(msg->lParam & 0x01000000))  /* no special_key */
 629          {
 630            if ((lpAccelTbl->tbl[i].type & ALT_ACCEL) && (msg->lParam & 0x20000000))
 631            {                                                   /* ^^ ALT pressed */
 632             dprintf_accel(stddeb,"found accel for Alt-%c", msg->wParam&0xff);
 633             sendmsg=TRUE;
 634            }
 635          }
 636        }
 637       }
 638
 639       if (sendmsg)      /* found an accelerator, but send a message... ? */
 640       {
 641         INT16  iSysStat,iStat,mesg=0;
 642         HMENU16 hMenu;
 643
 644         if (msg->message == WM_KEYUP || msg->message == WM_SYSKEYUP)
 645           mesg=1;
 646         else
 647          if (GetCapture16())
 648            mesg=2;
 649          else
 650           if (!IsWindowEnabled16(hWnd))
 651             mesg=3;
 652           else
 653           {
 654             WND* wndPtr = WIN_FindWndPtr(hWnd);
 655
 656             hMenu = (wndPtr->dwStyle & WS_CHILD) ? 0 : (HMENU32)wndPtr->wIDmenu;
 657             iSysStat = (wndPtr->hSysMenu) ? GetMenuState32(GetSubMenu16(wndPtr->hSysMenu, 0),
 658                                             lpAccelTbl->tbl[i].wIDval, MF_BYCOMMAND) : -1 ;
 659             iStat = (hMenu) ? GetMenuState32(hMenu,
 660                                             lpAccelTbl->tbl[i].wIDval, MF_BYCOMMAND) : -1 ;
 661
 662             if (iSysStat!=-1)
 663             {
 664               if (iSysStat & (MF_DISABLED|MF_GRAYED))
 665                 mesg=4;
 666               else
 667                 mesg=WM_SYSCOMMAND;
 668             }
 669             else
 670             {
 671               if (iStat!=-1)
 672               {
 673                 if (IsIconic32(hWnd))
 674                   mesg=5;
 675                 else
 676                 {
 677                  if (iStat & (MF_DISABLED|MF_GRAYED))
 678                    mesg=6;
 679                  else
 680                    mesg=WM_COMMAND;
 681                 }
 682               }
 683               else
 684                mesg=WM_COMMAND;
 685             }
 686           }
 687           if ( mesg==WM_COMMAND || mesg==WM_SYSCOMMAND )
 688           {
 689               dprintf_accel(stddeb,", sending %s, wParam=%0x\n",
 690                   mesg==WM_COMMAND ? "WM_COMMAND" : "WM_SYSCOMMAND",
 691                   lpAccelTbl->tbl[i].wIDval);
 692               SendMessage16(hWnd, mesg, lpAccelTbl->tbl[i].wIDval,0x00010000L);
 693           }
 694           else
 695           {
 696            /*  some reasons for NOT sending the WM_{SYS}COMMAND message:
 697             *   #0: unknown (please report!)
 698             *   #1: for WM_KEYUP,WM_SYSKEYUP
 699             *   #2: mouse is captured
 700             *   #3: window is disabled
 701             *   #4: it's a disabled system menu option
 702             *   #5: it's a menu option, but window is iconic
 703             *   #6: it's a menu option, but disabled
 704             */
 705             dprintf_accel(stddeb,", but won't send WM_{SYS}COMMAND, reason is #%d\n",mesg);
 706           }
 707           GlobalUnlock16(hAccel);
 708           return 1;
 709       }
 710      }
 711     }
 712     GlobalUnlock16(hAccel);
 713     return 0;
 714 }
 715
 716
 717 /******************************************************************************
 718  *      OemKeyScan                      [KEYBOARD.128][USER32.400]
 719  */
 720 DWORD OemKeyScan(WORD wOemChar)
 721 {
 722     dprintf_keyboard(stddeb,"*OemKeyScan (%d)\n",wOemChar);
 723
 724     return wOemChar;
 725 }
 726
 727 /******************************************************************************
 728  *      VkKeyScanA                      [USER32.572]
 729  */
 730 /* VkKeyScan translates an ANSI character to a virtual-key and shift code
 731  * for the current keyboard.
 732  * high-order byte yields :
 733  *      0       Unshifted
 734  *      1       Shift
 735  *      2       Ctrl
 736  *      3-5     Shift-key combinations that are not used for characters
 737  *      6       Ctrl-Alt
 738  *      7       Ctrl-Alt-Shift
 739  *      I.e. :  Shift = 1, Ctrl = 2, Alt = 4.
 740  * FIXME : works ok except for dead chars :
 741  * VkKeyScan '^'(0x5e, 94) ... got keycode 00 ... returning 00
 742  * VkKeyScan '`'(0x60, 96) ... got keycode 00 ... returning 00
 743  */
 744
 745 WORD VkKeyScan32A(CHAR cChar)
 746 {
 747         KeyCode keycode;
 748         KeySym keysym;
 749         int i,index;
 750         int highbyte=0;
 751
 752         /* char->keysym (same for ANSI chars) */
 753         keysym=(unsigned char) cChar;/* (!) cChar is signed */
 754         if (keysym<=27) keysym+=0xFF00;/*special chars : return, backspace...*/
 755
 756         keycode = XKeysymToKeycode(display, keysym);  /* keysym -> keycode */
 757         if (!keycode)
 758         { /* It didn't work ... let's try with deadchar code. */
 759           keycode = XKeysymToKeycode(display, keysym | 0xFE00);
 760         }
 761
 762         dprintf_keyboard(stddeb,"VkKeyScan '%c'(%#lx, %lu) : got keycode %#.2x ",
 763             cChar,keysym,keysym,keycode);
 764
 765         if (keycode)
 766           {
 767             for (index=-1, i=0; (i<8) && (index<0); i++) /* find shift state */
 768               if (XKeycodeToKeysym(display,keycode,i)==keysym) index=i;
 769             switch (index) {
 770             case -1 :
 771               fprintf(stderr,"Keysym %lx not found while parsing the keycode table\n",keysym); break;
 772             case 0 : break;
 773             case 1 : highbyte = 0x0100; break;
 774             case 2 : highbyte = 0X0600; break;
 775             default : fprintf(stderr,"index %d found by XKeycodeToKeysym. please report! \n",index);
 776             }
 777             /*
 778               index : 0     adds 0x0000
 779               index : 1     adds 0x0100 (shift)
 780               index : ?     adds 0x0200 (ctrl)
 781               index : 2     adds 0x0600 (ctrl+alt)
 782               index : ?     adds 0x0700 (ctrl+alt+shit (used?))
 783              */
 784           }
 785         dprintf_keyboard(stddeb," ... returning %#.2x\n", keyc2vkey[keycode]+highbyte);
 786         return keyc2vkey[keycode]+highbyte;   /* keycode -> (keyc2vkey) vkey */
 787 }
 788
 789 /******************************************************************************
 790  *      VkKeyScan                       [KEYBOARD.129]
 791  */
 792 WORD VkKeyScan16(CHAR cChar)
 793 {
 794         return VkKeyScan32A(cChar);
 795 }
 796
 797 /******************************************************************************
 798  *      VkKeyScanW                      [USER32.575]
 799  */
 800 WORD VkKeyScan32W(WCHAR cChar)
 801 {
 802         return VkKeyScan32A((CHAR)cChar); /* FIXME: check unicode */
 803 }
 804
 805 /******************************************************************************
 806  *      GetKeyboardType                 [KEYBOARD.130]
 807  */
 808 INT16 GetKeyboardType16(INT16 nTypeFlag)
 809 {
 810   return GetKeyboardType32(nTypeFlag);
 811 }
 812
 813 /******************************************************************************
 814  *      GetKeyboardType                 [USER32.254]
 815  */
 816 INT32 GetKeyboardType32(INT32 nTypeFlag)
 817 {
 818   dprintf_keyboard(stddeb,"GetKeyboardType(%d)\n",nTypeFlag);
 819   switch(nTypeFlag)
 820     {
 821     case 0:      /* Keyboard type */
 822       return 4;    /* AT-101 */
 823       break;
 824     case 1:      /* Keyboard Subtype */
 825       return 0;    /* There are no defined subtypes */
 826       break;
 827     case 2:      /* Number of F-keys */
 828       return 12;   /* We're doing an 101 for now, so return 12 F-keys */
 829       break;
 830     default:
 831       fprintf(stderr, "Unknown type on GetKeyboardType\n");
 832       return 0;    /* The book says 0 here, so 0 */
 833     }
 834 }
 835
 836
 837 /******************************************************************************
 838  *      MapVirtualKeyA                  [USER32.382]
 839  */
 840 UINT32 MapVirtualKey32A(UINT32 code, UINT32 maptype) {
 841         return MapVirtualKey16(code,maptype);
 842 }
 843
 844 /******************************************************************************
 845  *      MapVirtualKeyA                  [USER32.384]
 846  */
 847 UINT32 MapVirtualKey32W(UINT32 code, UINT32 maptype) {
 848         return MapVirtualKey16(code,maptype);
 849 }
 850
 851 /******************************************************************************
 852  *      MapVirtualKeyA                  [KEYBOARD.131]
 853  * MapVirtualKey translates keycodes from one format to another
 854  */
 855 UINT16 MapVirtualKey16(UINT16 wCode, UINT16 wMapType)
 856 {
 857 #define returnMVK(value) { dprintf_keyboard(stddeb,"returning 0x%x.\n",value); return value; }
 858
 859         dprintf_keyboard(stddeb,"MapVirtualKey wCode=0x%x wMapType=%d ... ",wCode,wMapType);
 860         switch(wMapType) {
 861                 case 0: { /* vkey-code to scan-code */
 862                         /* let's do vkey -> keycode -> scan */
 863                         KeyCode keyc;
 864                         for (keyc=min_keycode; keyc<=max_keycode; keyc++) /* see event.c */
 865                                 if ((keyc2vkey[keyc] & 0xFF)== wCode)
 866                                         returnMVK (keyc - 8);
 867                         return 0; }
 868
 869                 case 1: /* scan-code to vkey-code */
 870                         /* let's do scan -> keycode -> vkey */
 871
 872                         returnMVK (keyc2vkey[(wCode & 0xFF) + 8]);
 873
 874                 case 2: { /* vkey-code to unshifted ANSI code */
 875                         /* (was FIXME) : what does unshifted mean ? 'a' or 'A' ? */
 876                         /* My Windows returns 'A'. */
 877                         /* let's do vkey -> keycode -> (XLookupString) ansi char */
 878                         XKeyEvent e;
 879                         KeySym keysym;
 880                         char s[2];
 881                         e.display = display;
 882                         e.state = 0; /* unshifted */
 883                         e.keycode = MapVirtualKey16( wCode, 0);
 884                         if (!XLookupString(&e, s , 2 , &keysym, NULL))
 885                           returnMVK (*s);
 886
 887                         return 0;
 888                         }
 889                 default: /* reserved */
 890                         fprintf(stderr, "MapVirtualKey: unknown wMapType %d !\n",
 891                                 wMapType);
 892                         return 0;
 893         }
 894         return 0;
 895 }
 896
 897
 898 /****************************************************************************
 899  *      GetKBCodePage16   (KEYBOARD.132)
 900  */
 901 INT16 GetKBCodePage16(void)
 902 {
 903     dprintf_keyboard(stddeb,"GetKBCodePage()\n");
 904     return 850;
 905 }
 906
 907
 908 /****************************************************************************
 909  *      GetKBCodePage32   (USER32.245)
 910  */
 911 UINT32 GetKBCodePage32(void)
 912 {
 913     dprintf_keyboard(stddeb,"GetKbCodePage()\n");
 914     return 850;
 915 }
 916
 917
 918 /****************************************************************************
 919  *      GetKeyNameText32W   (USER32.247)
 920  */
 921 INT32 GetKeyNameText32W(LONG lParam, LPWSTR lpBuffer, INT32 nSize)
 922 {
 923         LPSTR buf = xmalloc(nSize);
 924         int     res = GetKeyNameText32A(lParam,buf,nSize);
 925
 926         lstrcpynAtoW(lpBuffer,buf,nSize);
 927         free(buf);
 928         return res;
 929 }
 930
 931 /****************************************************************************
 932  *      GetKeyNameText32A   (USER32.246)
 933  */
 934 INT32 GetKeyNameText32A(LONG lParam, LPSTR lpBuffer, INT32 nSize)
 935 {
 936         return GetKeyNameText16(lParam,lpBuffer,nSize);
 937 }
 938
 939 /****************************************************************************
 940  *      GetKeyNameText16   (KEYBOARD.133)
 941  */
 942 INT16 GetKeyNameText16(LONG lParam, LPSTR lpBuffer, INT16 nSize)
 943 {
 944   /*    int i; */
 945
 946         dprintf_keyboard(stddeb,"GetKeyNameText(%ld,<ptr>,%d)\n",lParam,nSize);
 947
 948         lParam >>= 16;
 949         lParam &= 0xff;
 950
 951         /*      for (i = 0 ; i != KeyTableSize ; i++)
 952                 if (KeyTable[i].scancode == lParam)  {
 953                         lstrcpyn32A( lpBuffer, KeyTable[i].name, nSize );
 954                         return strlen(lpBuffer);
 955                 }
 956                 */
 957         /* FIXME ! GetKeyNameText is still to do...
 958  */
 959         *lpBuffer = 0;
 960         return 0;
 961 }
 962
 963
 964 /****************************************************************************
 965  *      ToAscii   (KEYBOARD.4)
 966  */
 967 INT16 ToAscii16(UINT16 virtKey,UINT16 scanCode, LPBYTE lpKeyState,
 968         LPVOID lpChar, UINT16 flags)
 969 {
 970     return ToAscii32(virtKey,scanCode,lpKeyState,lpChar,flags);
 971 }
 972
 973 /****************************************************************************
 974  *      ToAscii   (USER32.545)
 975  */
 976 INT32 ToAscii32(
 977         UINT32 virtKey,UINT32 scanCode,LPBYTE lpKeyState,
 978         LPWORD lpChar,UINT32 flags
 979 ) {
 980     XKeyEvent e;
 981     KeySym keysym;
 982     static XComposeStatus cs;
 983     INT32 ret;
 984     WORD keyc;
 985
 986     e.display = display;
 987     e.keycode = 0;
 988     for (keyc=min_keycode; keyc<=max_keycode; keyc++)
 989       { /* this could be speeded up by making another table, an array of struct vkey,keycode
 990          * (vkey -> keycode) with vkeys sorted .... but it takes memory (512*3 bytes)!  DF */
 991         if ((keyc2vkey[keyc] & 0xFF)== virtKey) /* no need to make a more precise test (with the extended bit correctly set above virtKey ... VK* are different enough... */
 992           {
 993             if ((e.keycode) && ((virtKey<0x10) || (virtKey>0x12)))
 994                 /* it's normal to have 2 shift, control, and alt ! */
 995                 dprintf_keyboard(stddeb,"ToAscii : The keycodes %d and %d are matching the same vkey %#X\n",
 996                                  e.keycode,keyc,virtKey);
 997             e.keycode = keyc;
 998           }
 999       }
1000     if ((!e.keycode) && (lpKeyState[VK_NUMLOCK] & 0x01))
1001       {
1002         if ((virtKey>=VK_NUMPAD0) && (virtKey<=VK_NUMPAD9))
1003           e.keycode = XKeysymToKeycode(e.display, virtKey-VK_NUMPAD0+XK_KP_0);
1004         if (virtKey==VK_DECIMAL)
1005           e.keycode = XKeysymToKeycode(e.display, XK_KP_Decimal);
1006       }
1007     if (!e.keycode)
1008       {
1009         fprintf(stderr,"ToAscii : Unknown virtual key %X !!! \n",virtKey);
1010         return virtKey; /* whatever */
1011       }
1012     e.state = 0;
1013     if (lpKeyState[VK_SHIFT] & 0x80)
1014         e.state |= ShiftMask;
1015     dprintf_keyboard(stddeb,"ToAscii : lpKeyState[0x14(VK_CAPITAL)]=%#x\n",lpKeyState[VK_CAPITAL]);
1016     if (lpKeyState[VK_CAPITAL] & 0x01)
1017         e.state |= LockMask;
1018     if (lpKeyState[VK_CONTROL] & 0x80)
1019         if (lpKeyState[VK_MENU] & 0x80)
1020             e.state |= AltGrMask;
1021         else
1022             e.state |= ControlMask;
1023     if (lpKeyState[VK_NUMLOCK] & 0x01)
1024         e.state |= NumLockMask;
1025     dprintf_key(stddeb, "ToAscii(%04X, %04X) : faked state = %X\n",
1026                 virtKey, scanCode, e.state);
1027     ret = XLookupString(&e, (LPVOID)lpChar, 2, &keysym, &cs);
1028     if (ret == 0)
1029         {
1030         BYTE dead_char = 0;
1031
1032         ((char*)lpChar)[1] = '\0';
1033         switch (keysym)
1034             {
1035         /* symbolic ASCII is the same as defined in rfc1345 */
1036 #ifdef XK_dead_tilde
1037             case XK_dead_tilde :
1038 #endif
1039             case 0x1000FE7E : /* Xfree's XK_Dtilde */
1040                 dead_char = '~';        /* '? */
1041                 break;
1042 #ifdef XK_dead_acute
1043             case XK_dead_acute :
1044 #endif
1045             case 0x1000FE27 : /* Xfree's XK_Dacute_accent */
1046                 dead_char = 0xb4;       /* '' */
1047                 break;
1048 #ifdef XK_dead_circumflex
1049             case XK_dead_circumflex :
1050 #endif
1051             case 0x1000FE5E : /* Xfree's XK_Dcircumflex_accent */
1052                 dead_char = '^';        /* '> */
1053                 break;
1054 #ifdef XK_dead_grave
1055             case XK_dead_grave :
1056 #endif
1057             case 0x1000FE60 : /* Xfree's XK_Dgrave_accent */
1058                 dead_char = '`';        /* '! */
1059                 break;
1060 #ifdef XK_dead_diaeresis
1061             case XK_dead_diaeresis :
1062 #endif
1063             case 0x1000FE22 : /* Xfree's XK_Ddiaeresis */
1064                 dead_char = 0xa8;       /* ': */
1065                 break;
1066 #ifdef XK_dead_cedilla
1067             case XK_dead_cedilla :
1068                 dead_char = 0xb8;       /* ', */
1069                 break;
1070 #endif
1071 #ifdef XK_dead_macron
1072             case XK_dead_macron :
1073                 dead_char = '-';        /* 'm isn't defined on iso-8859-x */
1074                 break;
1075 #endif
1076 #ifdef XK_dead_breve
1077             case XK_dead_breve :
1078                 dead_char = 0xa2;       /* '( */
1079                 break;
1080 #endif
1081 #ifdef XK_dead_abovedot
1082             case XK_dead_abovedot :
1083                 dead_char = 0xff;       /* '. */
1084                 break;
1085 #endif
1086 #ifdef XK_dead_abovering
1087             case XK_dead_abovering :
1088                 dead_char = '0';        /* '0 isn't defined on iso-8859-x */
1089                 break;
1090 #endif
1091 #ifdef XK_dead_doubleacute
1092             case XK_dead_doubleacute :
1093                 dead_char = 0xbd;       /* '" */
1094                 break;
1095 #endif
1096 #ifdef XK_dead_caron
1097             case XK_dead_caron :
1098                 dead_char = 0xb7;       /* '< */
1099                 break;
1100 #endif
1101 #ifdef XK_dead_ogonek
1102             case XK_dead_ogonek :
1103                 dead_char = 0xb2;       /* '; */
1104                 break;
1105 #endif
1106 /* FIXME: I don't know this three.
1107             case XK_dead_iota :
1108                 dead_char = 'i';
1109                 break;
1110             case XK_dead_voiced_sound :
1111                 dead_char = 'v';
1112                 break;
1113             case XK_dead_semivoiced_sound :
1114                 dead_char = 's';
1115                 break;
1116 */
1117             }
1118         if (dead_char)
1119             {
1120             *(char*)lpChar = dead_char;
1121             ret = -1;
1122             }
1123         else
1124             {
1125             char        *ksname;
1126
1127             ksname = XKeysymToString(keysym);
1128             if (!ksname)
1129                 ksname = "No Name";
1130             if ((keysym >> 8) != 0xff)
1131                 {
1132                 fprintf(stderr, "Please report : no char for keysym %04lX (%s) :\n",
1133                         keysym, ksname);
1134                 fprintf(stderr, "  virtKey = %X, scanCode = %X, keycode = %X, state = %X\n",
1135                         virtKey, scanCode, e.keycode, e.state);
1136                 }
1137             }
1138         }
1139     dprintf_key(stddeb, "ToAscii about to return %d with char %x\n",
1140                 ret, *(char*)lpChar);
1141     return ret;
1142 }