misc/keyboard.c

   1 /*
   2 static char RCSId[] = "$Id: keyboard.c,v 1.2 1993/09/13 18:52:02 scott Exp $";
   3 static char Copyright[] = "Copyright  Scott A. Laird, Erik Bos  1993, 1994";
   4 */
   5
   6 #include <stdlib.h>
   7 #include <stdio.h>
   8 #include <string.h>
   9 #include <ctype.h>
  10 #include "windows.h"
  11 #include "keyboard.h"
  12 #include "stddebug.h"
  13 /* #define DEBUG_KEYBOARD */
  14 #include "debug.h"
  15
  16
  17 struct KeyTableEntry {
  18         int virtualkey;
  19         int ASCII;
  20         int scancode;
  21         const char *name;
  22 };
  23
  24 static const struct KeyTableEntry KeyTable[] =
  25 {
  26         { VK_CANCEL,    0x3,    0,      "" },
  27         { VK_BACK,      0x8,    0xe,    "Backspace" },
  28         { VK_TAB,       0x9,    0xf,    "Tab" },
  29         { VK_CLEAR,     0,      0x4c,   "Clear" },
  30         { VK_RETURN,    0xd,    0x1c,   "Enter" },
  31         { VK_SHIFT,     0,      0x2a,   "Shift" },
  32         { VK_CONTROL,   0,      0x1d,   "Ctrl" },
  33         { VK_MENU,      0,      0x38,   "Alt" },
  34         { VK_CAPITAL,   0,      0x3a,   "Caps Lock" },
  35         { VK_ESCAPE,    0x1b,   0x1,    "Esc" },
  36         { VK_SPACE,     0x20,   0x39,   "Space" },
  37         { VK_PRIOR,     0,      0x49,   "Page Up" },
  38         { VK_NEXT,      0,      0x51,   "Page Down" },
  39         { VK_END,       0,      0x4f,   "End" },
  40         { VK_HOME,      0,      0x47,   "Home" },
  41         { VK_LEFT,      0,      0x4b,   "Left Arrow" },
  42         { VK_UP,        0,      0x48,   "Up Arrow" },
  43         { VK_RIGHT,     0,      0x4d,   "Right Arrow" },
  44         { VK_DOWN,      0,      0x50,   "Down Arrow" },
  45         { VK_INSERT,    0,      0x52,   "Ins" },
  46         { VK_DELETE,    0,      0x53,   "Del" },
  47         { VK_0,         0x30,   0xb,    "0" },
  48         { VK_1,         0x31,   0x2,    "1" },
  49         { VK_2,         0x32,   0x3,    "2" },
  50         { VK_3,         0x33,   0x4,    "3" },
  51         { VK_4,         0x34,   0x5,    "4" },
  52         { VK_5,         0x35,   0x6,    "5" },
  53         { VK_6,         0x36,   0x7,    "6" },
  54         { VK_7,         0x37,   0x8,    "7" },
  55         { VK_8,         0x38,   0x9,    "8" },
  56         { VK_9,         0x39,   0xa,    "9" },
  57         { VK_A,         0x41,   0x1e,   "A" },
  58         { VK_B,         0x42,   0x30,   "B" },
  59         { VK_C,         0x43,   0x2e,   "C" },
  60         { VK_D,         0x44,   0x20,   "D" },
  61         { VK_E,         0x45,   0x12,   "E" },
  62         { VK_F,         0x46,   0x21,   "F" },
  63         { VK_G,         0x47,   0x22,   "G" },
  64         { VK_H,         0x48,   0x23,   "H" },
  65         { VK_I,         0x49,   0x17,   "I" },
  66         { VK_J,         0x4a,   0x24,   "J" },
  67         { VK_K,         0x4b,   0x25,   "K" },
  68         { VK_L,         0x4c,   0x26,   "L" },
  69         { VK_M,         0x4d,   0x32,   "M" },
  70         { VK_N,         0x4e,   0x31,   "N" },
  71         { VK_O,         0x4f,   0x18,   "O" },
  72         { VK_P,         0x50,   0x19,   "P" },
  73         { VK_Q,         0x51,   0x10,   "Q" },
  74         { VK_R,         0x52,   0x13,   "R" },
  75         { VK_S,         0x53,   0x1f,   "S" },
  76         { VK_T,         0x54,   0x14,   "T" },
  77         { VK_U,         0x55,   0x16,   "U" },
  78         { VK_V,         0x56,   0x2f,   "V" },
  79         { VK_W,         0x57,   0x11,   "W" },
  80         { VK_X,         0x58,   0x2d,   "X" },
  81         { VK_Y,         0x59,   0x15,   "Y" },
  82         { VK_Z,         0x5a,   0x2c,   "Z" },
  83         { VK_NUMPAD0,   0,      0x52,   "Num 0" },
  84         { VK_NUMPAD1,   0,      0x4f,   "Num 1" },
  85         { VK_NUMPAD2,   0,      0x50,   "Num 2" },
  86         { VK_NUMPAD3,   0,      0x51,   "Num 3" },
  87         { VK_NUMPAD4,   0,      0x4b,   "Num 4" },
  88         { VK_NUMPAD5,   0,      0x4c,   "Num 5" },
  89         { VK_NUMPAD6,   0,      0x4d,   "Num 6" },
  90         { VK_NUMPAD7,   0,      0x47,   "Num 7" },
  91         { VK_NUMPAD8,   0,      0x48,   "Num 8" },
  92         { VK_NUMPAD9,   0,      0x49,   "Num 9" },
  93         { VK_MULTIPLY,  0x2a,   0x37,   "Num *" },
  94         { VK_ADD,       0x2b,   0x4e,   "Num +" },
  95         { VK_SEPARATOR, 0,      0,      "" },
  96         { VK_SUBTRACT,  0x2d,   0x4a,   "Num -" },
  97         { VK_DECIMAL,   0x2e,   0x53,   "Num Del" },
  98         { VK_DIVIDE,    0x2f,   0,      "Num /" },
  99         { VK_F1,        0,      0x3b,   "F1" },
 100         { VK_F2,        0,      0x3c,   "F2" },
 101         { VK_F3,        0,      0x3d,   "F3" },
 102         { VK_F4,        0,      0x3e,   "F4" },
 103         { VK_F5,        0,      0x3f,   "F5" },
 104         { VK_F6,        0,      0x40,   "F6" },
 105         { VK_F7,        0,      0x41,   "F7" },
 106         { VK_F8,        0,      0x42,   "F8" },
 107         { VK_F9,        0,      0x43,   "F9" },
 108         { VK_F10,       0,      0x44,   "F10" },
 109         { VK_F11,       0,      0x57,   "F11" },
 110         { VK_F12,       0,      0x58,   "F12" },
 111         { VK_NUMLOCK,   0,      0x45,   "Num Lock" },
 112         { VK_SCROLL,    0,      0x46,   "Scroll Lock" },
 113         /* Allowable ranges for OEM-specific virtual-key codes */
 114 /*      -                   0xBA-0xC0           OEM specific */
 115         { 0xba,         0x3b,   0x27,   ";" },
 116         { 0xbb,         0x3d,   0xd,    "=" },
 117         { 0xbc,         0x2c,   0x33,   "," },
 118         { 0xbd,         0x2d,   0xc,    "-" },
 119         { 0xbe,         0x2e,   0x34,   "." },
 120         { 0xbf,         0x2f,   0x35,   "/" },
 121         { 0xc0,         0x60,   0x29,   "`" },
 122 /*      -                   0xDB-0xE4           OEM specific */
 123         { 0xdb,         0x5b,   0x1a,   "[" },
 124         { 0xdc,         0x5c,   0x2b,   "\\" },
 125         { 0xdd,         0x5d,   0x1b,   "]" },
 126         { 0xde,         0x27,   0x28,   "'" },
 127         { 0xe2,         0x5c,   0x56,   "\\" },
 128 /*      -                   0xE6                OEM specific */
 129 /*      -                   0xE9-0xF5           OEM specific */
 130 };
 131
 132 #define KeyTableSize    sizeof(KeyTable) / sizeof(struct KeyTableEntry)
 133
 134 int ToAscii(WORD wVirtKey, WORD wScanCode, LPSTR lpKeyState,
 135         LPVOID lpChar, WORD wFlags)
 136 {
 137         char shift = lpKeyState[VK_SHIFT] < 0;
 138         int i;
 139
 140         dprintf_keyboard(stddeb, "ToAscii (%x,%x) -> ", wVirtKey, wScanCode);
 141
 142         /* FIXME: codepage is broken */
 143
 144         *(BYTE*)lpChar = 0;
 145         switch (wVirtKey)
 146           {
 147 #define vkcase2(k1,k2,val) case val : *(BYTE*)lpChar = shift ? k2 : k1; break;
 148 #define vkcase(k, val) vkcase2(val, k, val)
 149           WINE_VKEY_MAPPINGS
 150 #undef vkcase
 151 #undef vkcase2
 152           default :
 153             for (i = 0 ; ; i++)
 154               {
 155               if (i == KeyTableSize)
 156                 {
 157                   dprintf_keyboard(stddeb, "0\n");
 158                   return 0;
 159                 }
 160               if (KeyTable[i].virtualkey == wVirtKey)
 161                 {
 162                   if (!isprint(KeyTable[i].ASCII) && !isspace(KeyTable[i].ASCII))
 163                     {
 164                       dprintf_keyboard(stddeb, "0\n");
 165                       return 0;
 166                     }
 167                   dprintf_keyboard(stddeb,"\"%s\" ", KeyTable[i].name);
 168
 169                   *(BYTE*)lpChar = KeyTable[i].ASCII;
 170                   *(((BYTE*)lpChar) + 1) = 0;
 171
 172                   if (isalpha(*(BYTE*)lpChar))
 173                     if( (lpKeyState[VK_CAPITAL]<0 && !lpKeyState[VK_SHIFT]) ||
 174                         (!lpKeyState[VK_CAPITAL] && lpKeyState[VK_SHIFT]<0) )
 175                         *(BYTE*)lpChar = toupper( *(BYTE*)lpChar );
 176                     else
 177                         *(BYTE*)lpChar = tolower( *(BYTE*)lpChar );
 178                   break;
 179                 }
 180              }
 181           }
 182         if (lpKeyState[VK_CONTROL] < 0)
 183           *(BYTE*)lpChar = *(BYTE*)lpChar & 0x1f;
 184         dprintf_keyboard(stddeb, "1 (%x)\n", *(BYTE*)lpChar);
 185         return 1;
 186 }
 187
 188 DWORD OemKeyScan(WORD wOemChar)
 189 {
 190     dprintf_keyboard(stddeb,"*OemKeyScan (%d)\n",wOemChar);
 191
 192         return wOemChar;
 193 }
 194
 195 /* VkKeyScan translates an ANSI character to a virtual-key and shift code
 196  * for the current keyboard.
 197  * FIXME high-order byte should yield :
 198  *      0       Unshifted
 199  *      1       Shift
 200  *      2       Ctrl
 201  *      3-5     Shift-key combinations that are not used for characters
 202  *      6       Ctrl-Alt
 203  *      7       Ctrl-Alt-Shift
 204  *      I.e. :  Shift = 1, Ctrl = 2, Alt = 4.
 205  */
 206
 207 WORD VkKeyScan(WORD cChar)
 208 {
 209         int i;
 210
 211         dprintf_keyboard(stddeb,"VkKeyScan (%d)\n",cChar);
 212
 213         for (i = 0 ; i != KeyTableSize ; i++)
 214                 if (KeyTable[i].ASCII == cChar)
 215                         return KeyTable[i].virtualkey;
 216
 217         return -1;
 218 }
 219
 220 int GetKeyboardType(int nTypeFlag)
 221 {
 222   dprintf_keyboard(stddeb,"GetKeyboardType(%d)\n",nTypeFlag);
 223   switch(nTypeFlag)
 224     {
 225     case 0:      /* Keyboard type */
 226       return 4;    /* AT-101 */
 227       break;
 228     case 1:      /* Keyboard Subtype */
 229       return 0;    /* There are no defined subtypes */
 230       break;
 231     case 2:      /* Number of F-keys */
 232       return 12;   /* We're doing an 101 for now, so return 12 F-keys */
 233       break;
 234     default:
 235       fprintf(stderr, "Unknown type on GetKeyboardType\n");
 236       return 0;    /* The book says 0 here, so 0 */
 237     }
 238 }
 239
 240 /* MapVirtualKey translates keycodes from one format to another. */
 241
 242 WORD MapVirtualKey(WORD wCode, WORD wMapType)
 243 {
 244         int i;
 245
 246         switch(wMapType) {
 247                 case 0: /* vkey-code to scan-code */
 248                         for (i = 0 ; i != KeyTableSize ; i++)
 249                                 if (KeyTable[i].virtualkey == wCode)
 250                                         return KeyTable[i].scancode;
 251                         return 0;
 252
 253                 case 1: /* scan-code to vkey-code */
 254                         for (i = 0 ; i != KeyTableSize ; i++)
 255                                 if (KeyTable[i].scancode == wCode)
 256                                         return KeyTable[i].virtualkey;
 257                         return 0;
 258
 259                 case 2: /* vkey-code to unshifted ANSI code */
 260                         /* FIXME : what does unshifted mean ? 'a' or 'A' ? */
 261                         for (i = 0 ; i != KeyTableSize ; i++)
 262                                 if (KeyTable[i].virtualkey == wCode)
 263                                         return KeyTable[i].ASCII;
 264                         return 0;
 265
 266                 default: /* reserved */
 267                         fprintf(stderr, "MapVirtualKey: unknown wMapType %d !\n",
 268                                 wMapType);
 269                         return 0;
 270         }
 271         return 0;
 272 }
 273
 274 int GetKbCodePage(void)
 275 {
 276         dprintf_keyboard(stddeb,"GetKbCodePage()\n");
 277         return 850;
 278 }
 279
 280 int GetKeyNameText(LONG lParam, LPSTR lpBuffer, int nSize)
 281 {
 282         int i;
 283
 284         dprintf_keyboard(stddeb,"GetKeyNameText(%ld,<ptr>,%d)\n",lParam,nSize);
 285
 286         lParam >>= 16;
 287         lParam &= 0xff;
 288
 289         for (i = 0 ; i != KeyTableSize ; i++)
 290                 if (KeyTable[i].scancode == lParam)  {
 291                         lstrcpyn32A( lpBuffer, KeyTable[i].name, nSize );
 292                         return strlen(lpBuffer);
 293                 }
 294
 295         *lpBuffer = 0;
 296         return 0;
 297 }