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

   1 /*
   2  * KEYBOARD driver
   3  *
   4  * Copyright 1993 Bob Amstadt
   5  * Copyright 1996 Albrecht Kleine
   6  * Copyright 1997 David Faure
   7  * Copyright 1998 Morten Welinder
   8  * Copyright 1998 Ulrich Weigand
   9  *
  10  */
  11
  12 #include <stdlib.h>
  13 #include <string.h>
  14 #include <ctype.h>
  15 #include <X11/keysym.h>
  16 #include "ts_xlib.h"
  17 #include "ts_xresource.h"
  18 #include "ts_xutil.h"
  19 #include <X11/Xatom.h>
  20
  21 #include "windows.h"
  22 #include "win.h"
  23 #include "gdi.h"
  24 #include "heap.h"
  25 #include "keyboard.h"
  26 #include "message.h"
  27 #include "debug.h"
  28 #include "debugtools.h"
  29 #include "struct32.h"
  30 #include "winerror.h"
  31
  32 static LPKEYBD_EVENT_PROC DefKeybEventProc = NULL;
  33 static LPBYTE pKeyStateTable = NULL;
  34
  35 int min_keycode, max_keycode, keysyms_per_keycode;
  36 WORD keyc2vkey[256];
  37
  38 static int NumLockMask, AltGrMask; /* mask in the XKeyEvent state */
  39 static int kcControl, kcAlt, kcShift, kcNumLock, kcCapsLock; /* keycodes */
  40
  41 /* Keyboard translation tables */
  42 static const int special_key[] =
  43 {
  44     VK_BACK, VK_TAB, 0, VK_CLEAR, 0, VK_RETURN, 0, 0,           /* FF08 */
  45     0, 0, 0, VK_PAUSE, VK_SCROLL, 0, 0, 0,                      /* FF10 */
  46     0, 0, 0, VK_ESCAPE                                          /* FF18 */
  47 };
  48
  49 static const int cursor_key[] =
  50 {
  51     VK_HOME, VK_LEFT, VK_UP, VK_RIGHT, VK_DOWN, VK_PRIOR,
  52                                        VK_NEXT, VK_END          /* FF50 */
  53 };
  54
  55 static const int misc_key[] =
  56 {
  57     VK_SELECT, VK_SNAPSHOT, VK_EXECUTE, VK_INSERT, 0, 0, 0, 0,  /* FF60 */
  58     VK_CANCEL, VK_HELP, VK_CANCEL, VK_MENU                      /* FF68 */
  59 };
  60
  61 static const int keypad_key[] =
  62 {
  63     0, VK_NUMLOCK,                                              /* FF7E */
  64     0, 0, 0, 0, 0, 0, 0, 0,                                     /* FF80 */
  65     0, 0, 0, 0, 0, VK_RETURN, 0, 0,                             /* FF88 */
  66     0, 0, 0, 0, 0, VK_HOME, VK_LEFT, VK_UP,                     /* FF90 */
  67     VK_RIGHT, VK_DOWN, VK_PRIOR, VK_NEXT, VK_END, 0,
  68                                  VK_INSERT, VK_DELETE,          /* FF98 */
  69     0, 0, 0, 0, 0, 0, 0, 0,                                     /* FFA0 */
  70     0, 0, VK_MULTIPLY, VK_ADD, VK_SEPARATOR, VK_SUBTRACT,
  71                                VK_DECIMAL, VK_DIVIDE,           /* FFA8 */
  72     VK_NUMPAD0, VK_NUMPAD1, VK_NUMPAD2, VK_NUMPAD3, VK_NUMPAD4,
  73                             VK_NUMPAD5, VK_NUMPAD6, VK_NUMPAD7, /* FFB0 */
  74     VK_NUMPAD8, VK_NUMPAD9                                      /* FFB8 */
  75 };
  76
  77 static const int function_key[] =
  78 {
  79     VK_F1, VK_F2,                                               /* FFBE */
  80     VK_F3, VK_F4, VK_F5, VK_F6, VK_F7, VK_F8, VK_F9, VK_F10,    /* FFC0 */
  81     VK_F11, VK_F12, VK_F13, VK_F14, VK_F15, VK_F16              /* FFC8 */
  82 };
  83
  84 static const int modifier_key[] =
  85 {
  86     VK_SHIFT, VK_SHIFT, VK_CONTROL, VK_CONTROL, VK_CAPITAL, 0, /* FFE1 */
  87     VK_MENU, VK_MENU, VK_MENU, VK_MENU                         /* FFE7 */
  88 };
  89
  90 static WORD EVENT_event_to_vkey( XKeyEvent *e)
  91 {
  92     KeySym keysym;
  93
  94     TSXLookupString(e, NULL, 0, &keysym, NULL);
  95
  96     if ((keysym >= 0xFFAE) && (keysym <= 0xFFB9) && (e->state & NumLockMask))
  97         /* Only the Keypad keys 0-9 and . send different keysyms
  98          * depending on the NumLock state */
  99         return keypad_key[(keysym & 0xFF) - 0x7E];
 100
 101     return keyc2vkey[e->keycode];
 102 }
 103
 104 /**********************************************************************
 105  *              KEYBOARD_Init
 106  */
 107 static void KEYBOARD_Init(void)
 108 {
 109     int i;
 110     KeySym *ksp;
 111     XModifierKeymap *mmp;
 112     KeySym keysym;
 113     KeyCode *kcp;
 114     XKeyEvent e2;
 115     WORD vkey, OEMvkey;
 116     int keyc;
 117
 118     TSXDisplayKeycodes(display, &min_keycode, &max_keycode);
 119     ksp = TSXGetKeyboardMapping(display, min_keycode,
 120                               max_keycode + 1 - min_keycode, &keysyms_per_keycode);
 121     /* We are only interested in keysyms_per_keycode.
 122        There is no need to hold a local copy of the keysyms table */
 123     TSXFree(ksp);
 124     mmp = TSXGetModifierMapping(display);
 125     kcp = mmp->modifiermap;
 126     for (i = 0; i < 8; i += 1) /* There are 8 modifier keys */
 127     {
 128         int j;
 129
 130         for (j = 0; j < mmp->max_keypermod; j += 1, kcp += 1)
 131             if (*kcp)
 132             {
 133                 int k;
 134
 135                 for (k = 0; k < keysyms_per_keycode; k += 1)
 136                     if (TSXKeycodeToKeysym(display, *kcp, k) == XK_Mode_switch)
 137                     {
 138                         AltGrMask = 1 << i;
 139                         TRACE(key, "AltGrMask is %x\n", AltGrMask);
 140                     }
 141                     else if (TSXKeycodeToKeysym(display, *kcp, k) == XK_Num_Lock)
 142                     {
 143                         NumLockMask = 1 << i;
 144                         TRACE(key, "NumLockMask is %x\n", NumLockMask);
 145                     }
 146             }
 147     }
 148     TSXFreeModifiermap(mmp);
 149
 150     /* Now build two conversion arrays :
 151      * keycode -> vkey + extended
 152      * vkey + extended -> keycode */
 153
 154     e2.display = display;
 155     e2.state = 0;
 156
 157     OEMvkey = VK_OEM_7; /* next is available.  */
 158     for (keyc = min_keycode; keyc <= max_keycode; keyc++)
 159     {
 160         e2.keycode = (KeyCode)keyc;
 161         TSXLookupString(&e2, NULL, 0, &keysym, NULL);
 162         vkey = 0;
 163         if (keysym)  /* otherwise, keycode not used */
 164         {
 165             if ((keysym >> 8) == 0xFF)         /* non-character key */
 166             {
 167                 int key = keysym & 0xff;
 168
 169                 if (key >= 0x08 && key <= 0x1B)         /* special key */
 170                     vkey = special_key[key - 0x08];
 171                 else if (key >= 0x50 && key <= 0x57)    /* cursor key */
 172                     vkey = cursor_key[key - 0x50];
 173                 else if (key >= 0x60 && key <= 0x6B)    /* miscellaneous key */
 174                     vkey = misc_key[key - 0x60];
 175                 else if (key >= 0x7E && key <= 0xB9)    /* keypad key */
 176                     vkey = keypad_key[key - 0x7E];
 177                 else if (key >= 0xBE && key <= 0xCD)    /* function key */
 178                 {
 179                     vkey = function_key[key - 0xBE];
 180                     vkey |= 0x100; /* set extended bit */
 181                 }
 182                 else if (key >= 0xE1 && key <= 0xEA)    /* modifier key */
 183                     vkey = modifier_key[key - 0xE1];
 184                 else if (key == 0xFF)                   /* DEL key */
 185                     vkey = VK_DELETE;
 186                 /* extended must also be set for ALT_R, CTRL_R,
 187                    INS, DEL, HOME, END, PAGE_UP, PAGE_DOWN, ARROW keys,
 188                    keypad / and keypad ENTER (SDK 3.1 Vol.3 p 138) */
 189                 /* FIXME should we set extended bit for NumLock ? My
 190                  * Windows does ... DF */
 191                 switch (keysym)
 192                 {
 193                 case XK_Control_R :
 194                 case XK_Alt_R :
 195                 case XK_Insert :
 196                 case XK_Delete :
 197                 case XK_Home :
 198                 case XK_End :
 199                 case XK_Prior :
 200                 case XK_Next :
 201                 case XK_Left :
 202                 case XK_Up :
 203                 case XK_Right :
 204                 case XK_Down :
 205                 case XK_KP_Divide :
 206                 case XK_KP_Enter :
 207                     vkey |= 0x100;
 208                 }
 209             }
 210             for (i = 0; (i < keysyms_per_keycode) && (!vkey); i++)
 211             {
 212                 keysym = TSXLookupKeysym(&e2, i);
 213                 if ((keysym >= VK_0 && keysym <= VK_9)
 214                     || (keysym >= VK_A && keysym <= VK_Z)
 215                     || keysym == VK_SPACE)
 216                     vkey = keysym;
 217             }
 218
 219             for (i = 0; (i < keysyms_per_keycode) && (!vkey); i++)
 220             {
 221                 keysym = TSXLookupKeysym(&e2, i);
 222                 switch (keysym)
 223                 {
 224                 case ';':             vkey = VK_OEM_1; break;
 225                 case '/':             vkey = VK_OEM_2; break;
 226                 case '`':             vkey = VK_OEM_3; break;
 227                 case '[':             vkey = VK_OEM_4; break;
 228                 case '\\':            vkey = VK_OEM_5; break;
 229                 case ']':             vkey = VK_OEM_6; break;
 230                 case '\'':            vkey = VK_OEM_7; break;
 231                 case ',':             vkey = VK_OEM_COMMA; break;
 232                 case '.':             vkey = VK_OEM_PERIOD; break;
 233                 case '-':             vkey = VK_OEM_MINUS; break;
 234                 case '+':             vkey = VK_OEM_PLUS; break;
 235                 }
 236             }
 237
 238             if (!vkey)
 239             {
 240                 /* Others keys: let's assign OEM virtual key codes in the allowed range,
 241                  * that is ([0xba,0xc0], [0xdb,0xe4], 0xe6 (given up) et [0xe9,0xf5]) */
 242                 switch (++OEMvkey)
 243                 {
 244                 case 0xc1 : OEMvkey=0xdb; break;
 245                 case 0xe5 : OEMvkey=0xe9; break;
 246                 case 0xf6 : OEMvkey=0xf5; WARN(keyboard,"No more OEM vkey available!\n");
 247                 }
 248
 249                 vkey = OEMvkey;
 250
 251                 if (TRACE_ON(keyboard))
 252                 {
 253                     dbg_decl_str(keyboard, 1024);
 254
 255                     TRACE(keyboard, "OEM specific virtual key %X assigned "
 256                                  "to keycode %X:\n", OEMvkey, e2.keycode);
 257                     for (i = 0; i < keysyms_per_keycode; i += 1)
 258                     {
 259                         char    *ksname;
 260
 261                         keysym = TSXLookupKeysym(&e2, i);
 262                         ksname = TSXKeysymToString(keysym);
 263                         if (!ksname)
 264                             ksname = "NoSymbol";
 265                         dsprintf(keyboard, "%lX (%s) ", keysym, ksname);
 266                     }
 267                     TRACE(keyboard, "(%s)\n", dbg_str(keyboard));
 268                 }
 269             }
 270         }
 271         keyc2vkey[e2.keycode] = vkey;
 272     } /* for */
 273     /* Now store one keycode for each modifier. Used to simulate keypresses. */
 274     kcControl = TSXKeysymToKeycode(display, XK_Control_L);
 275     kcAlt = TSXKeysymToKeycode(display, XK_Alt_L);
 276     kcShift = TSXKeysymToKeycode(display, XK_Shift_L);
 277     kcNumLock = TSXKeysymToKeycode(display, XK_Num_Lock);
 278     kcCapsLock = TSXKeysymToKeycode(display, XK_Caps_Lock);
 279 }
 280
 281 /***********************************************************************
 282  *           KEYBOARD_Inquire                   (KEYBOARD.1)
 283  */
 284 WORD WINAPI KEYBOARD_Inquire(LPKBINFO kbInfo)
 285 {
 286     kbInfo->Begin_First_Range = 0;
 287     kbInfo->End_First_Range = 0;
 288     kbInfo->Begin_Second_Range = 0;
 289     kbInfo->End_Second_Range = 0;
 290     kbInfo->StateSize = 16;
 291
 292     return sizeof(KBINFO);
 293 }
 294
 295 /***********************************************************************
 296  *           KEYBOARD_Enable                    (KEYBOARD.2)
 297  */
 298 VOID WINAPI KEYBOARD_Enable( LPKEYBD_EVENT_PROC lpKeybEventProc,
 299                              LPBYTE lpKeyState )
 300 {
 301     static BOOL32 initDone = FALSE;
 302
 303     DefKeybEventProc = lpKeybEventProc;
 304     pKeyStateTable = lpKeyState;
 305
 306     /* all states to false */
 307     memset( lpKeyState, 0, sizeof(lpKeyState) );
 308
 309     if (!initDone) KEYBOARD_Init();
 310     initDone = TRUE;
 311 }
 312
 313 /***********************************************************************
 314  *           KEYBOARD_Disable                   (KEYBOARD.3)
 315  */
 316 VOID WINAPI KEYBOARD_Disable(VOID)
 317 {
 318     DefKeybEventProc = NULL;
 319     pKeyStateTable = NULL;
 320 }
 321
 322 /***********************************************************************
 323  *           KEYBOARD_SendEvent
 324  */
 325 void KEYBOARD_SendEvent( BYTE bVk, BYTE bScan, DWORD dwFlags,
 326                          DWORD posX, DWORD posY, DWORD time )
 327 {
 328     WINE_KEYBDEVENT wke;
 329
 330     if ( !DefKeybEventProc ) return;
 331
 332     TRACE( event, "(%d,%d,%04lX)\n", bVk, bScan, dwFlags );
 333
 334     wke.magic = WINE_KEYBDEVENT_MAGIC;
 335     wke.posX  = posX;
 336     wke.posY  = posY;
 337     wke.time  = time;
 338
 339     DefKeybEventProc( bVk, bScan, dwFlags, (DWORD)&wke );
 340 }
 341
 342
 343 static BOOL32 NumState=FALSE, CapsState=FALSE;
 344
 345 /**********************************************************************
 346  *              KEYBOARD_GenerateMsg
 347  *
 348  * Generate Down+Up messages when NumLock or CapsLock is pressed.
 349  *
 350  * Convention : called with vkey only VK_NUMLOCK or VK_CAPITAL
 351  *
 352  */
 353 void KEYBOARD_GenerateMsg( WORD vkey, int Evtype, INT32 event_x, INT32 event_y,
 354                            DWORD event_time )
 355 {
 356   BOOL32 * State = (vkey==VK_NUMLOCK? &NumState : &CapsState);
 357
 358   if (*State) {
 359     /* The INTERMEDIARY state means : just after a 'press' event, if a 'release' event comes,
 360        don't treat it. It's from the same key press. Then the state goes to ON.
 361        And from there, a 'release' event will switch off the toggle key. */
 362     *State=FALSE;
 363     TRACE(keyboard,"INTERM : don\'t treat release of toggle key. InputKeyStateTable[%#x] = %#x\n",vkey,pKeyStateTable[vkey]);
 364   } else
 365     {
 366         if ( pKeyStateTable[vkey] & 0x1 ) /* it was ON */
 367           {
 368             if (Evtype!=KeyPress)
 369               {
 370                 TRACE(keyboard,"ON + KeyRelease => generating DOWN and UP messages.\n");
 371                 KEYBOARD_SendEvent( vkey, 0, 0,
 372                                     event_x, event_y, event_time );
 373                 KEYBOARD_SendEvent( vkey, 0, KEYEVENTF_KEYUP,
 374                                     event_x, event_y, event_time );
 375                 *State=FALSE;
 376                 pKeyStateTable[vkey] &= ~0x01; /* Toggle state to off. */
 377               }
 378           }
 379         else /* it was OFF */
 380           if (Evtype==KeyPress)
 381             {
 382               TRACE(keyboard,"OFF + Keypress => generating DOWN and UP messages.\n");
 383               KEYBOARD_SendEvent( vkey, 0, 0,
 384                                   event_x, event_y, event_time );
 385               KEYBOARD_SendEvent( vkey, 0, KEYEVENTF_KEYUP,
 386                                   event_x, event_y, event_time );
 387               *State=TRUE; /* Goes to intermediary state before going to ON */
 388               pKeyStateTable[vkey] |= 0x01; /* Toggle state to on. */
 389             }
 390     }
 391 }
 392
 393 /***********************************************************************
 394  *           KEYBOARD_UpdateOneState
 395  *
 396  * Updates internal state for <vkey>, depending on key <state> under X
 397  *
 398  */
 399 void KEYBOARD_UpdateOneState ( int vkey, int state )
 400 {
 401     /* Do something if internal table state != X state for keycode */
 402     if (((pKeyStateTable[vkey] & 0x80)!=0) != state)
 403     {
 404         TRACE(keyboard,"Adjusting state for vkey %#.2x. State before %#.2x \n",
 405               vkey, pKeyStateTable[vkey]);
 406
 407         /* Fake key being pressed inside wine */
 408         KEYBOARD_SendEvent( vkey, 0, state? 0 : KEYEVENTF_KEYUP,
 409                             0, 0, GetTickCount() );
 410
 411         TRACE(keyboard,"State after %#.2x \n",pKeyStateTable[vkey]);
 412     }
 413 }
 414
 415 /***********************************************************************
 416  *           KEYBOARD_UpdateState
 417  *
 418  * Update modifiers state (Ctrl, Alt, Shift)
 419  * when window is activated (called by EVENT_FocusIn in event.c)
 420  *
 421  * This handles the case where one uses Ctrl+... Alt+... or Shift+.. to switch
 422  * from wine to another application and back.
 423  * Toggle keys are handled in HandleEvent. (because XQueryKeymap says nothing
 424  *  about them)
 425  */
 426 void KEYBOARD_UpdateState ( void )
 427 {
 428 /* extract a bit from the char[32] bit suite */
 429 #define KeyState(keycode) ((keys_return[keycode/8] & (1<<(keycode%8)))!=0)
 430
 431     char keys_return[32];
 432
 433     TRACE(keyboard,"called\n");
 434     if (!TSXQueryKeymap(display, keys_return)) {
 435         ERR(keyboard,"Error getting keymap !");
 436         return;
 437     }
 438
 439     /* Adjust the ALT and CONTROL state if any has been changed outside wine */
 440     KEYBOARD_UpdateOneState(VK_MENU, KeyState(kcAlt));
 441     KEYBOARD_UpdateOneState(VK_CONTROL, KeyState(kcControl));
 442     KEYBOARD_UpdateOneState(VK_SHIFT, KeyState(kcShift));
 443 #undef KeyState
 444 }
 445
 446 /***********************************************************************
 447  *           KEYBOARD_HandleEvent
 448  *
 449  * Handle a X key event
 450  */
 451 void KEYBOARD_HandleEvent( WND *pWnd, XKeyEvent *event )
 452 {
 453     char Str[24];
 454     XComposeStatus cs;
 455     KeySym keysym;
 456     WORD vkey = 0, bScan;
 457     DWORD dwFlags;
 458     static BOOL32 force_extended = FALSE; /* hack for AltGr translation */
 459
 460     int ascii_chars;
 461
 462     INT32 event_x = (pWnd? pWnd->rectWindow.left : 0) + event->x;
 463     INT32 event_y = (pWnd? pWnd->rectWindow.top  : 0) + event->y;
 464     DWORD event_time = event->time - MSG_WineStartTicks;
 465
 466     /* this allows support for dead keys */
 467     if ((event->keycode >> 8) == 0x10)
 468         event->keycode=(event->keycode & 0xff);
 469
 470     ascii_chars = TSXLookupString(event, Str, 1, &keysym, &cs);
 471
 472     TRACE(key, "EVENT_key : state = %X\n", event->state);
 473     if (keysym == XK_Mode_switch)
 474         {
 475         TRACE(key, "Alt Gr key event received\n");
 476         event->keycode = kcControl; /* Simulate Control */
 477         KEYBOARD_HandleEvent( pWnd, event );
 478
 479         event->keycode = kcAlt; /* Simulate Alt */
 480         force_extended = TRUE;
 481         KEYBOARD_HandleEvent( pWnd, event );
 482         force_extended = FALSE;
 483         return;
 484         }
 485
 486     Str[ascii_chars] = '\0';
 487     if (TRACE_ON(key)){
 488         char    *ksname;
 489
 490         ksname = TSXKeysymToString(keysym);
 491         if (!ksname)
 492           ksname = "No Name";
 493         TRACE(key, "%s : keysym=%lX (%s), ascii chars=%u / %X / '%s'\n",
 494                      (event->type == KeyPress) ? "KeyPress" : "KeyRelease",
 495                      keysym, ksname, ascii_chars, Str[0] & 0xff, Str);
 496     }
 497
 498     vkey = EVENT_event_to_vkey(event);
 499     if (force_extended) vkey |= 0x100;
 500
 501     TRACE(key, "keycode 0x%x converted to vkey 0x%x\n",
 502                     event->keycode, vkey);
 503
 504    if (vkey)
 505    {
 506     switch (vkey & 0xff)
 507     {
 508     case VK_NUMLOCK:
 509       KEYBOARD_GenerateMsg( VK_NUMLOCK, event->type, event_x, event_y,
 510                             event_time );
 511       break;
 512     case VK_CAPITAL:
 513       TRACE(keyboard,"Caps Lock event. (type %d). State before : %#.2x\n",event->type,pKeyStateTable[vkey]);
 514       KEYBOARD_GenerateMsg( VK_CAPITAL, event->type, event_x, event_y,
 515                             event_time );
 516       TRACE(keyboard,"State after : %#.2x\n",pKeyStateTable[vkey]);
 517       break;
 518     default:
 519         /* Adjust the NUMLOCK state if it has been changed outside wine */
 520         if (!(pKeyStateTable[VK_NUMLOCK] & 0x01) != !(event->state & NumLockMask))
 521           {
 522             TRACE(keyboard,"Adjusting NumLock state. \n");
 523             KEYBOARD_GenerateMsg( VK_NUMLOCK, KeyPress, event_x, event_y,
 524                                   event_time );
 525             KEYBOARD_GenerateMsg( VK_NUMLOCK, KeyRelease, event_x, event_y,
 526                                   event_time );
 527           }
 528         /* Adjust the CAPSLOCK state if it has been changed outside wine */
 529         if (!(pKeyStateTable[VK_CAPITAL] & 0x01) != !(event->state & LockMask))
 530           {
 531               TRACE(keyboard,"Adjusting Caps Lock state.\n");
 532             KEYBOARD_GenerateMsg( VK_CAPITAL, KeyPress, event_x, event_y,
 533                                   event_time );
 534             KEYBOARD_GenerateMsg( VK_CAPITAL, KeyRelease, event_x, event_y,
 535                                   event_time );
 536           }
 537         /* Not Num nor Caps : end of intermediary states for both. */
 538         NumState = FALSE;
 539         CapsState = FALSE;
 540
 541         bScan = event->keycode - min_keycode; /* Windows starts from 0, X from
 542                                                  min_keycode (8 usually) */
 543         dwFlags = 0;
 544         if ( event->type == KeyRelease ) dwFlags |= KEYEVENTF_KEYUP;
 545         if ( vkey & 0x100 )              dwFlags |= KEYEVENTF_EXTENDEDKEY;
 546         if ( force_extended )            dwFlags |= KEYEVENTF_WINE_FORCEEXTENDED;
 547
 548         KEYBOARD_SendEvent( vkey & 0xff, bScan, dwFlags,
 549                             event_x, event_y, event_time );
 550     }
 551    }
 552 }
 553
 554
 555 /**********************************************************************
 556  *           ScreenSwitchEnable      (KEYBOARD.100)
 557  */
 558 VOID WINAPI ScreenSwitchEnable(WORD unused)
 559 {
 560     FIXME(keyboard,"(%04x): stub\n",unused);
 561 }
 562
 563 /**********************************************************************
 564  *           OemKeyScan      (KEYBOARD.128)(USER32.401)
 565  */
 566 DWORD WINAPI OemKeyScan(WORD wOemChar)
 567 {
 568     TRACE(keyboard,"*OemKeyScan (%d)\n",wOemChar);
 569
 570     return wOemChar;
 571 }
 572
 573 /**********************************************************************
 574  *      VkKeyScan                       [KEYBOARD.129]
 575  */
 576 /* VkKeyScan translates an ANSI character to a virtual-key and shift code
 577  * for the current keyboard.
 578  * high-order byte yields :
 579  *      0       Unshifted
 580  *      1       Shift
 581  *      2       Ctrl
 582  *      3-5     Shift-key combinations that are not used for characters
 583  *      6       Ctrl-Alt
 584  *      7       Ctrl-Alt-Shift
 585  *      I.e. :  Shift = 1, Ctrl = 2, Alt = 4.
 586  * FIXME : works ok except for dead chars :
 587  * VkKeyScan '^'(0x5e, 94) ... got keycode 00 ... returning 00
 588  * VkKeyScan '`'(0x60, 96) ... got keycode 00 ... returning 00
 589  */
 590
 591 WORD WINAPI VkKeyScan16(CHAR cChar)
 592 {
 593         KeyCode keycode;
 594         KeySym keysym;
 595         int i,index;
 596         int highbyte=0;
 597
 598         /* char->keysym (same for ANSI chars) */
 599         keysym=(unsigned char) cChar;/* (!) cChar is signed */
 600         if (keysym<=27) keysym+=0xFF00;/*special chars : return, backspace...*/
 601
 602         keycode = TSXKeysymToKeycode(display, keysym);  /* keysym -> keycode */
 603         if (!keycode)
 604         { /* It didn't work ... let's try with deadchar code. */
 605           keycode = TSXKeysymToKeycode(display, keysym | 0xFE00);
 606         }
 607
 608         TRACE(keyboard,"VkKeyScan '%c'(%#lx, %lu): got keycode %#.2x\n",
 609                          cChar,keysym,keysym,keycode);
 610
 611         if (keycode)
 612           {
 613             for (index=-1, i=0; (i<8) && (index<0); i++) /* find shift state */
 614               if (TSXKeycodeToKeysym(display,keycode,i)==keysym) index=i;
 615             switch (index) {
 616             case -1 :
 617               WARN(keyboard,"Keysym %lx not found while parsing the keycode table\n",keysym); break;
 618             case 0 : break;
 619             case 1 : highbyte = 0x0100; break;
 620             case 2 : highbyte = 0X0600; break;
 621             default : ERR(keyboard,"index %d found by XKeycodeToKeysym. please report! \n",index);
 622             }
 623             /*
 624               index : 0     adds 0x0000
 625               index : 1     adds 0x0100 (shift)
 626               index : ?     adds 0x0200 (ctrl)
 627               index : 2     adds 0x0600 (ctrl+alt)
 628               index : ?     adds 0x0700 (ctrl+alt+shift (used?))
 629              */
 630           }
 631         TRACE(keyboard," ... returning %#.2x\n", keyc2vkey[keycode]+highbyte);
 632         return keyc2vkey[keycode]+highbyte;   /* keycode -> (keyc2vkey) vkey */
 633 }
 634
 635 /******************************************************************************
 636  *      GetKeyboardType16      (KEYBOARD.130)
 637  */
 638 INT16 WINAPI GetKeyboardType16(INT16 nTypeFlag)
 639 {
 640   TRACE(keyboard,"(%d)\n",nTypeFlag);
 641   switch(nTypeFlag)
 642     {
 643     case 0:      /* Keyboard type */
 644       return 4;    /* AT-101 */
 645       break;
 646     case 1:      /* Keyboard Subtype */
 647       return 0;    /* There are no defined subtypes */
 648       break;
 649     case 2:      /* Number of F-keys */
 650       return 12;   /* We're doing an 101 for now, so return 12 F-keys */
 651       break;
 652     default:
 653       WARN(keyboard, "Unknown type\n");
 654       return 0;    /* The book says 0 here, so 0 */
 655     }
 656 }
 657
 658 /******************************************************************************
 659  *      MapVirtualKey16      (KEYBOARD.131)
 660  *
 661  * MapVirtualKey translates keycodes from one format to another
 662  */
 663 UINT16 WINAPI MapVirtualKey16(UINT16 wCode, UINT16 wMapType)
 664 {
 665 #define returnMVK(value) { TRACE(keyboard,"returning 0x%x.\n",value); return value; }
 666
 667         TRACE(keyboard,"MapVirtualKey wCode=0x%x wMapType=%d ... \n",
 668                          wCode,wMapType);
 669         switch(wMapType) {
 670                 case 0: { /* vkey-code to scan-code */
 671                         /* let's do vkey -> keycode -> scan */
 672                         int keyc;
 673                         for (keyc=min_keycode; keyc<=max_keycode; keyc++)
 674                                 if ((keyc2vkey[keyc] & 0xFF) == wCode)
 675                                         returnMVK (keyc - min_keycode);
 676                         return 0; }
 677
 678                 case 1: /* scan-code to vkey-code */
 679                         /* let's do scan -> keycode -> vkey */
 680
 681                         returnMVK (keyc2vkey[(wCode & 0xFF) + min_keycode]);
 682
 683                 case 2: { /* vkey-code to unshifted ANSI code */
 684                         /* (was FIXME) : what does unshifted mean ? 'a' or 'A' ? */
 685                         /* My Windows returns 'A'. */
 686                         /* let's do vkey -> keycode -> (XLookupString) ansi char */
 687                         XKeyEvent e;
 688                         KeySym keysym;
 689                         char s[2];
 690                         e.display = display;
 691                         e.state = 0; /* unshifted */
 692                         e.keycode = MapVirtualKey16( wCode, 0);
 693                         if (!TSXLookupString(&e, s , 2 , &keysym, NULL))
 694                           returnMVK (*s);
 695
 696                         return 0;
 697                         }
 698                 default: /* reserved */
 699                         WARN(keyboard, "Unknown wMapType %d !\n",
 700                                 wMapType);
 701                         return 0;
 702         }
 703         return 0;
 704 }
 705
 706
 707 /****************************************************************************
 708  *      GetKBCodePage16   (KEYBOARD.132)
 709  */
 710 INT16 WINAPI GetKBCodePage16(void)
 711 {
 712     TRACE(keyboard,"(void)\n");
 713     return 850;
 714 }
 715
 716 /****************************************************************************
 717  *      GetKeyboardLayoutName16   (USER.477)
 718  */
 719 INT16 WINAPI GetKeyboardLayoutName16(LPSTR pwszKLID)
 720 {
 721         FIXME(keyboard,"always returns primary U.S. English layout\n");
 722         strcpy(pwszKLID,"00000409");
 723         return 1;
 724 }
 725
 726 /****************************************************************************
 727  *      GetKeyNameText16   (KEYBOARD.133)
 728  */
 729 INT16 WINAPI GetKeyNameText16(LONG lParam, LPSTR lpBuffer, INT16 nSize)
 730 {
 731   /*    int i; */
 732
 733         FIXME(keyboard,"(%ld,<ptr>,%d): stub\n",lParam,nSize);
 734
 735         /*
 736         lParam >>= 16;
 737         lParam &= 0xff;
 738
 739                 for (i = 0 ; i != KeyTableSize ; i++)
 740                 if (KeyTable[i].scancode == lParam)  {
 741                         lstrcpyn32A( lpBuffer, KeyTable[i].name, nSize );
 742                         return strlen(lpBuffer);
 743                 }
 744                 */
 745
 746         *lpBuffer = 0;
 747         return 0;
 748 }
 749
 750 /****************************************************************************
 751  *      ToAscii   (KEYBOARD.4)
 752  */
 753 INT16 WINAPI ToAscii16(UINT16 virtKey,UINT16 scanCode, LPBYTE lpKeyState,
 754                        LPVOID lpChar, UINT16 flags)
 755 {
 756     XKeyEvent e;
 757     KeySym keysym;
 758     static XComposeStatus cs;
 759     INT32 ret;
 760     int keyc;
 761
 762     if (scanCode==0) {
 763         /* This happens when doing Alt+letter : a fake 'down arrow' key press
 764            event is generated by windows. Just ignore it. */
 765         TRACE(keyboard,"scanCode=0, doing nothing\n");
 766         return 0;
 767     }
 768     e.display = display;
 769     e.keycode = 0;
 770     e.state = 0;
 771     if (lpKeyState[VK_SHIFT] & 0x80)
 772         e.state |= ShiftMask;
 773     if (lpKeyState[VK_CAPITAL] & 0x01)
 774         e.state |= LockMask;
 775     if (lpKeyState[VK_CONTROL] & 0x80)
 776     {
 777         if (lpKeyState[VK_MENU] & 0x80)
 778             e.state |= AltGrMask;
 779         else
 780             e.state |= ControlMask;
 781     }
 782     if (lpKeyState[VK_NUMLOCK] & 0x01)
 783         e.state |= NumLockMask;
 784     TRACE(key, "(%04X, %04X) : faked state = %X\n",
 785                 virtKey, scanCode, e.state);
 786     /* We exit on the first keycode found, to speed up the thing. */
 787     for (keyc=min_keycode; (keyc<=max_keycode) && (!e.keycode) ; keyc++)
 788       { /* Find a keycode that could have generated this virtual key */
 789           if  ((keyc2vkey[keyc] & 0xFF) == virtKey)
 790           { /* we can filter the extended bit, VK* are different enough... */
 791               e.keycode = keyc; /* Store it temporarily */
 792               if ((EVENT_event_to_vkey(&e) & 0xFF) != virtKey)
 793                   e.keycode = 0; /* Wrong one (ex: because of the NumLock
 794                          state), so set it to 0, we'll find another one */
 795           }
 796       }
 797     if ((!e.keycode) && (lpKeyState[VK_NUMLOCK] & 0x01))
 798     {
 799         if ((virtKey>=VK_NUMPAD0) && (virtKey<=VK_NUMPAD9))
 800           e.keycode = TSXKeysymToKeycode(e.display, virtKey-VK_NUMPAD0+XK_KP_0);
 801         if (virtKey==VK_DECIMAL)
 802           e.keycode = TSXKeysymToKeycode(e.display, XK_KP_Decimal);
 803       }
 804     if (!e.keycode)
 805       {
 806         WARN(keyboard,"Unknown virtual key %X !!! \n",virtKey);
 807         return virtKey; /* whatever */
 808       }
 809     ret = TSXLookupString(&e, (LPVOID)lpChar, 2, &keysym, &cs);
 810     if (ret == 0)
 811         {
 812         BYTE dead_char = 0;
 813
 814         ((char*)lpChar)[1] = '\0';
 815         switch (keysym)
 816             {
 817         /* symbolic ASCII is the same as defined in rfc1345 */
 818 #ifdef XK_dead_tilde
 819             case XK_dead_tilde :
 820 #endif
 821             case 0x1000FE7E : /* Xfree's XK_Dtilde */
 822                 dead_char = '~';        /* '? */
 823                 break;
 824 #ifdef XK_dead_acute
 825             case XK_dead_acute :
 826 #endif
 827             case 0x1000FE27 : /* Xfree's XK_Dacute_accent */
 828                 dead_char = 0xb4;       /* '' */
 829                 break;
 830 #ifdef XK_dead_circumflex
 831             case XK_dead_circumflex :
 832 #endif
 833             case 0x1000FE5E : /* Xfree's XK_Dcircumflex_accent */
 834                 dead_char = '^';        /* '> */
 835                 break;
 836 #ifdef XK_dead_grave
 837             case XK_dead_grave :
 838 #endif
 839             case 0x1000FE60 : /* Xfree's XK_Dgrave_accent */
 840                 dead_char = '`';        /* '! */
 841                 break;
 842 #ifdef XK_dead_diaeresis
 843             case XK_dead_diaeresis :
 844 #endif
 845             case 0x1000FE22 : /* Xfree's XK_Ddiaeresis */
 846                 dead_char = 0xa8;       /* ': */
 847                 break;
 848 #ifdef XK_dead_cedilla
 849             case XK_dead_cedilla :
 850                 dead_char = 0xb8;       /* ', */
 851                 break;
 852 #endif
 853 #ifdef XK_dead_macron
 854             case XK_dead_macron :
 855                 dead_char = '-';        /* 'm isn't defined on iso-8859-x */
 856                 break;
 857 #endif
 858 #ifdef XK_dead_breve
 859             case XK_dead_breve :
 860                 dead_char = 0xa2;       /* '( */
 861                 break;
 862 #endif
 863 #ifdef XK_dead_abovedot
 864             case XK_dead_abovedot :
 865                 dead_char = 0xff;       /* '. */
 866                 break;
 867 #endif
 868 #ifdef XK_dead_abovering
 869             case XK_dead_abovering :
 870                 dead_char = '0';        /* '0 isn't defined on iso-8859-x */
 871                 break;
 872 #endif
 873 #ifdef XK_dead_doubleacute
 874             case XK_dead_doubleacute :
 875                 dead_char = 0xbd;       /* '" */
 876                 break;
 877 #endif
 878 #ifdef XK_dead_caron
 879             case XK_dead_caron :
 880                 dead_char = 0xb7;       /* '< */
 881                 break;
 882 #endif
 883 #ifdef XK_dead_ogonek
 884             case XK_dead_ogonek :
 885                 dead_char = 0xb2;       /* '; */
 886                 break;
 887 #endif
 888 /* FIXME: I don't know this three.
 889             case XK_dead_iota :
 890                 dead_char = 'i';
 891                 break;
 892             case XK_dead_voiced_sound :
 893                 dead_char = 'v';
 894                 break;
 895             case XK_dead_semivoiced_sound :
 896                 dead_char = 's';
 897                 break;
 898 */
 899             }
 900         if (dead_char)
 901             {
 902             *(char*)lpChar = dead_char;
 903             ret = -1;
 904             }
 905         else
 906             {
 907             char        *ksname;
 908
 909             ksname = TSXKeysymToString(keysym);
 910             if (!ksname)
 911                 ksname = "No Name";
 912             if ((keysym >> 8) != 0xff)
 913                 {
 914                 ERR(keyboard, "Please report: no char for keysym %04lX (%s) :\n",
 915                         keysym, ksname);
 916                 ERR(keyboard, "(virtKey=%X,scanCode=%X,keycode=%X,state=%X)\n",
 917                         virtKey, scanCode, e.keycode, e.state);
 918                 }
 919             }
 920         }
 921     TRACE(key, "ToAscii about to return %d with char %x\n",
 922                 ret, *(char*)lpChar);
 923     return ret;
 924 }
 925