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
  16 #include "windef.h"
  17 #include "wingdi.h"
  18 #include "winuser.h"
  19 #include "wine/keyboard16.h"
  20 #include "win.h"
  21 #include "heap.h"
  22 #include "keyboard.h"
  23 #include "user.h"
  24 #include "message.h"
  25 #include "callback.h"
  26 #include "builtin16.h"
  27 #include "debugtools.h"
  28 #include "struct32.h"
  29 #include "winerror.h"
  30
  31 DEFAULT_DEBUG_CHANNEL(keyboard)
  32 DECLARE_DEBUG_CHANNEL(event)
  33
  34 /**********************************************************************/
  35
  36 static LPKEYBD_EVENT_PROC DefKeybEventProc = NULL;
  37 LPBYTE pKeyStateTable = NULL;
  38
  39 /***********************************************************************
  40  *           KEYBOARD_Inquire                   (KEYBOARD.1)
  41  */
  42 WORD WINAPI KEYBOARD_Inquire(LPKBINFO kbInfo)
  43 {
  44   kbInfo->Begin_First_Range = 0;
  45   kbInfo->End_First_Range = 0;
  46   kbInfo->Begin_Second_Range = 0;
  47   kbInfo->End_Second_Range = 0;
  48   kbInfo->StateSize = 16;
  49
  50   return sizeof(KBINFO);
  51 }
  52
  53 /***********************************************************************
  54  *           KEYBOARD_Enable                    (KEYBOARD.2)
  55  */
  56 VOID WINAPI KEYBOARD_Enable( LPKEYBD_EVENT_PROC lpKeybEventProc,
  57                              LPBYTE lpKeyState )
  58 {
  59   static BOOL initDone = FALSE;
  60
  61   THUNK_Free( (FARPROC)DefKeybEventProc );
  62
  63   DefKeybEventProc = lpKeybEventProc;
  64   pKeyStateTable = lpKeyState;
  65
  66   /* all states to false */
  67   memset( lpKeyState, 0, 256 );
  68
  69   if (!initDone) USER_Driver.pInitKeyboard();
  70   initDone = TRUE;
  71 }
  72
  73 static VOID WINAPI KEYBOARD_CallKeybdEventProc( FARPROC16 proc,
  74                                                 BYTE bVk, BYTE bScan,
  75                                                 DWORD dwFlags, DWORD dwExtraInfo )
  76 {
  77     CONTEXT86 context;
  78
  79     memset( &context, 0, sizeof(context) );
  80     CS_reg(&context)  = SELECTOROF( proc );
  81     EIP_reg(&context) = OFFSETOF( proc );
  82     AH_reg(&context)  = (dwFlags & KEYEVENTF_KEYUP)? 0x80 : 0;
  83     AL_reg(&context)  = bVk;
  84     BH_reg(&context)  = (dwFlags & KEYEVENTF_EXTENDEDKEY)? 1 : 0;
  85     BL_reg(&context)  = bScan;
  86     SI_reg(&context)  = LOWORD( dwExtraInfo );
  87     DI_reg(&context)  = HIWORD( dwExtraInfo );
  88
  89     CallTo16RegisterShort( &context, 0 );
  90 }
  91
  92 VOID WINAPI WIN16_KEYBOARD_Enable( FARPROC16 proc, LPBYTE lpKeyState )
  93 {
  94     LPKEYBD_EVENT_PROC thunk =
  95       (LPKEYBD_EVENT_PROC)THUNK_Alloc( proc, (RELAY)KEYBOARD_CallKeybdEventProc );
  96
  97     KEYBOARD_Enable( thunk, lpKeyState );
  98 }
  99
 100 /***********************************************************************
 101  *           KEYBOARD_Disable                   (KEYBOARD.3)
 102  */
 103 VOID WINAPI KEYBOARD_Disable(VOID)
 104 {
 105   THUNK_Free( (FARPROC)DefKeybEventProc );
 106
 107   DefKeybEventProc = NULL;
 108   pKeyStateTable = NULL;
 109 }
 110
 111 /***********************************************************************
 112  *           KEYBOARD_SendEvent
 113  */
 114 void KEYBOARD_SendEvent( BYTE bVk, BYTE bScan, DWORD dwFlags,
 115                          DWORD posX, DWORD posY, DWORD time )
 116 {
 117   WINE_KEYBDEVENT wke;
 118   int iWndsLocks;
 119
 120   if ( !DefKeybEventProc ) return;
 121
 122   TRACE_(event)("(%d,%d,%04lX)\n", bVk, bScan, dwFlags );
 123
 124   wke.magic = WINE_KEYBDEVENT_MAGIC;
 125   wke.posX  = posX;
 126   wke.posY  = posY;
 127   wke.time  = time;
 128
 129   /* To avoid deadlocks, we have to suspend all locks on windows structures
 130      before the program control is passed to the keyboard driver */
 131   iWndsLocks = WIN_SuspendWndsLock();
 132   DefKeybEventProc( bVk, bScan, dwFlags, (DWORD)&wke );
 133   WIN_RestoreWndsLock(iWndsLocks);
 134 }
 135
 136 /**********************************************************************
 137  *           SetSpeed16      (KEYBOARD.7)
 138  */
 139 WORD WINAPI SetSpeed16(WORD unused)
 140 {
 141     FIXME("(%04x): stub\n", unused);
 142     return 0xffff;
 143 }
 144
 145 /**********************************************************************
 146  *           ScreenSwitchEnable      (KEYBOARD.100)
 147  */
 148 VOID WINAPI ScreenSwitchEnable16(WORD unused)
 149 {
 150   FIXME("(%04x): stub\n", unused);
 151 }
 152
 153 /**********************************************************************
 154  *           OemKeyScan      (KEYBOARD.128)(USER32.401)
 155  */
 156 DWORD WINAPI OemKeyScan(WORD wOemChar)
 157 {
 158   TRACE("*OemKeyScan (%d)\n", wOemChar);
 159
 160   return wOemChar;
 161 }
 162
 163 /**********************************************************************
 164  *      VkKeyScan                       [KEYBOARD.129]
 165  */
 166 /* VkKeyScan translates an ANSI character to a virtual-key and shift code
 167  * for the current keyboard.
 168  * high-order byte yields :
 169  *      0       Unshifted
 170  *      1       Shift
 171  *      2       Ctrl
 172  *      3-5     Shift-key combinations that are not used for characters
 173  *      6       Ctrl-Alt
 174  *      7       Ctrl-Alt-Shift
 175  *      I.e. :  Shift = 1, Ctrl = 2, Alt = 4.
 176  * FIXME : works ok except for dead chars :
 177  * VkKeyScan '^'(0x5e, 94) ... got keycode 00 ... returning 00
 178  * VkKeyScan '`'(0x60, 96) ... got keycode 00 ... returning 00
 179  */
 180
 181 WORD WINAPI VkKeyScan16(CHAR cChar)
 182 {
 183     return USER_Driver.pVkKeyScan(cChar);
 184 }
 185
 186 /******************************************************************************
 187  *      GetKeyboardType16      (KEYBOARD.130)
 188  */
 189 INT16 WINAPI GetKeyboardType16(INT16 nTypeFlag)
 190 {
 191   TRACE("(%d)\n", nTypeFlag);
 192   switch(nTypeFlag)
 193     {
 194     case 0:      /* Keyboard type */
 195       return 4;    /* AT-101 */
 196       break;
 197     case 1:      /* Keyboard Subtype */
 198       return 0;    /* There are no defined subtypes */
 199       break;
 200     case 2:      /* Number of F-keys */
 201       return 12;   /* We're doing an 101 for now, so return 12 F-keys */
 202       break;
 203     default:
 204       WARN("Unknown type\n");
 205       return 0;    /* The book says 0 here, so 0 */
 206     }
 207 }
 208
 209 /******************************************************************************
 210  *      MapVirtualKey16      (KEYBOARD.131)
 211  *
 212  * MapVirtualKey translates keycodes from one format to another
 213  */
 214 UINT16 WINAPI MapVirtualKey16(UINT16 wCode, UINT16 wMapType)
 215 {
 216     return USER_Driver.pMapVirtualKey(wCode,wMapType);
 217 }
 218
 219 /****************************************************************************
 220  *      GetKBCodePage16   (KEYBOARD.132)
 221  */
 222 INT16 WINAPI GetKBCodePage16(void)
 223 {
 224   TRACE("(void)\n");
 225   return 850;
 226 }
 227
 228 /****************************************************************************
 229  *      GetKeyNameText16   (KEYBOARD.133)
 230  */
 231 INT16 WINAPI GetKeyNameText16(LONG lParam, LPSTR lpBuffer, INT16 nSize)
 232 {
 233     return USER_Driver.pGetKeyNameText(lParam, lpBuffer, nSize);
 234 }
 235
 236 /****************************************************************************
 237  *      ToAscii   (KEYBOARD.4)
 238  *
 239  * The ToAscii function translates the specified virtual-key code and keyboard
 240  * state to the corresponding Windows character or characters.
 241  *
 242  * If the specified key is a dead key, the return value is negative. Otherwise,
 243  * it is one of the following values:
 244  * Value        Meaning
 245  * 0    The specified virtual key has no translation for the current state of the keyboard.
 246  * 1    One Windows character was copied to the buffer.
 247  * 2    Two characters were copied to the buffer. This usually happens when a
 248  *      dead-key character (accent or diacritic) stored in the keyboard layout cannot
 249  *      be composed with the specified virtual key to form a single character.
 250  *
 251  * FIXME : should do the above (return 2 for non matching deadchar+char combinations)
 252  *
 253  */
 254 INT16 WINAPI ToAscii16(UINT16 virtKey,UINT16 scanCode, LPBYTE lpKeyState,
 255                        LPVOID lpChar, UINT16 flags)
 256 {
 257     return USER_Driver.pToAscii( virtKey, scanCode, lpKeyState, lpChar, flags );
 258 }
 259
 260 /***********************************************************************
 261  *              KEYBOARD_GetBeepActive
 262  */
 263 BOOL KEYBOARD_GetBeepActive()
 264 {
 265     return USER_Driver.pGetBeepActive();
 266 }
 267
 268 /***********************************************************************
 269  *              KEYBOARD_SetBeepActive
 270  */
 271 void KEYBOARD_SetBeepActive(BOOL bActivate)
 272 {
 273     USER_Driver.pSetBeepActive(bActivate);
 274 }
 275
 276 /***********************************************************************
 277  *           MessageBeep16   (USER.104)
 278  */
 279 void WINAPI MessageBeep16( UINT16 i )
 280 {
 281     MessageBeep( i );
 282 }
 283
 284 /***********************************************************************
 285  *           MessageBeep   (USER32.390)
 286  */
 287 BOOL WINAPI MessageBeep( UINT i )
 288 {
 289     USER_Driver.pBeep();
 290     return TRUE;
 291 }