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