KEYBOARD.H (22536B)
1 // 2 // Copyright 2020 Electronic Arts Inc. 3 // 4 // TiberianDawn.DLL and RedAlert.dll and corresponding source code is free 5 // software: you can redistribute it and/or modify it under the terms of 6 // the GNU General Public License as published by the Free Software Foundation, 7 // either version 3 of the License, or (at your option) any later version. 8 9 // TiberianDawn.DLL and RedAlert.dll and corresponding source code is distributed 10 // in the hope that it will be useful, but with permitted additional restrictions 11 // under Section 7 of the GPL. See the GNU General Public License in LICENSE.TXT 12 // distributed with this program. You should have received a copy of the 13 // GNU General Public License along with permitted additional restrictions 14 // with this program. If not, see https://github.com/electronicarts/CnC_Remastered_Collection 15 16 /*********************************************************************************************** 17 * * 18 * Project Name : Westwood Keyboard Library * 19 * * 20 * File Name : KEYBOARD.H * 21 * * 22 * Programmer : Philip W. Gorrow * 23 * * 24 * Start Date : 10/16/95 * 25 * * 26 * Last Update : October 16, 1995 [PWG] * 27 * * 28 *---------------------------------------------------------------------------------------------* 29 * Functions: * 30 * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */ 31 32 #ifndef KEYBOARD_H 33 #define KEYBOARD_H 34 35 #include <WWSTD.H> 36 37 typedef enum { 38 WWKEY_SHIFT_BIT = 0x100, 39 WWKEY_CTRL_BIT = 0x200, 40 WWKEY_ALT_BIT = 0x400, 41 WWKEY_RLS_BIT = 0x800, 42 WWKEY_VK_BIT = 0x1000, 43 WWKEY_DBL_BIT = 0x2000, 44 WWKEY_BTN_BIT = 0x8000, 45 } WWKey_Type; 46 47 class WWKeyboardClass 48 { 49 public: 50 /*===================================================================*/ 51 /* Define the base constructor and destructors for the class */ 52 /*===================================================================*/ 53 WWKeyboardClass(); 54 55 /*===================================================================*/ 56 /* Define the functions which work with the Keyboard Class */ 57 /*===================================================================*/ 58 BOOL Check(void); // checks keybuff for meta key 59 int Get(void); // gets a meta key from the keybuffer 60 BOOL Put(int key); // dumps a key into the keybuffer 61 BOOL Put_Key_Message( UINT vk_key, BOOL release = FALSE, // handles keyboard related message 62 BOOL dbl = FALSE); // and mouse clicks and dbl clicks 63 int Check_Num(void); // checks keybuff for a keynum key 64 int Get_VK(void); // gets keynum key from key buff 65 int Check_ACII(void); // checks keybuff for an ascii key 66 int Get_ASCII(void); // gets an ascii key from keybuff 67 int Check_Bits(void); // checks keybuff for key w/ bits 68 int Get_Bits(void); // get key from keybuff w/ bits 69 int To_ASCII(int num); // converts keynum to ascii value 70 int Option_On(int option); // turns specified option on 71 int Option_Off(int option); // turns specified option off 72 void Clear(void); // clears all keys from keybuffer 73 int Down(int key); // tests to see if a key is down 74 void AI(void); // messaging logic for key manager 75 76 /*===================================================================*/ 77 /* Define the main hook for the message processing loop. */ 78 /*===================================================================*/ 79 void Message_Handler(HWND hwnd, UINT message, UINT wParam, LONG lParam); 80 81 /*===================================================================*/ 82 /* Define public routines which can be used on keys in general. */ 83 /*===================================================================*/ 84 VOID Split(int &key, int &shift, int &ctrl, int &alt, int &rls, int &dbl); 85 BOOL Is_Mouse_Key(int key); 86 87 88 /*===================================================================*/ 89 /* Define the public access variables which are used with the */ 90 /* Keyboard Class. */ 91 /*===================================================================*/ 92 int MouseQX; 93 int MouseQY; 94 95 unsigned char VKRemap[256]; // gives vk for any ascii char 96 private: 97 /*===================================================================*/ 98 /* Define the private access functions which are used by keyboard */ 99 /*===================================================================*/ 100 int Buff_Get(void); 101 102 103 /*===================================================================*/ 104 /* Define the private access variables which are used with the */ 105 /* Keyboard Class. */ 106 /*===================================================================*/ 107 unsigned char AsciiRemap[2048]; // remap for shft/ctrl/alt key combos 108 unsigned short Buffer[256]; // buffer which holds actual keypresses 109 unsigned char ToggleKeys[256]; // determines toggles which affect key 110 long Head; // the head position in keyboard buffer 111 long Tail; // the tail position in keyboard buffer 112 int MState; 113 int Conditional; 114 HANDLE CurrentCursor; 115 }; 116 117 118 #define VK_NONE 0x00 119 #define VK_LBUTTON 0x01 120 #define VK_RBUTTON 0x02 121 #define VK_CANCEL 0x03 122 #define VK_MBUTTON 0x04 123 #define VK_NONE_05 0x05 124 #define VK_NONE_06 0x06 125 #define VK_NONE_07 0x07 126 #define VK_BACK 0x08 127 #define VK_TAB 0x09 128 #define VK_NONE_0A 0x0A 129 #define VK_NONE_0B 0x0B 130 #define VK_CLEAR 0x0C 131 #define VK_RETURN 0x0D 132 #define VK_NONE_0E 0x0E 133 #define VK_NONE_0F 0x0F 134 #define VK_SHIFT 0x10 135 #define VK_CONTROL 0x11 136 #define VK_MENU 0x12 137 #define VK_PAUSE 0x13 138 #define VK_CAPITAL 0x14 139 #define VK_NONE_15 0x15 140 #define VK_NONE_16 0x16 141 #define VK_NONE_17 0x17 142 #define VK_NONE_18 0x18 143 #define VK_NONE_19 0x19 144 #define VK_NONE_1A 0x1A 145 #define VK_ESCAPE 0x1B 146 #define VK_NONE_1C 0x1C 147 #define VK_NONE_1D 0x1D 148 #define VK_NONE_1E 0x1E 149 #define VK_NONE_1F 0x1F 150 #define VK_SPACE 0x20 151 #define VK_PRIOR 0x21 152 #define VK_NEXT 0x22 153 #define VK_END 0x23 154 #define VK_HOME 0x24 155 #define VK_LEFT 0x25 156 #define VK_UP 0x26 157 #define VK_RIGHT 0x27 158 #define VK_DOWN 0x28 159 #define VK_SELECT 0x29 160 #define VK_PRINT 0x2A 161 #define VK_EXECUTE 0x2B 162 #define VK_SNAPSHOT 0x2C 163 #define VK_INSERT 0x2D 164 #define VK_DELETE 0x2E 165 #define VK_HELP 0x2F 166 #define VK_0 0x30 167 #define VK_1 0x31 168 #define VK_2 0x32 169 #define VK_3 0x33 170 #define VK_4 0x34 171 #define VK_5 0x35 172 #define VK_6 0x36 173 #define VK_7 0x37 174 #define VK_8 0x38 175 #define VK_9 0x39 176 #define VK_NONE_3B 0x3B 177 #define VK_NONE_3C 0x3C 178 #define VK_NONE_3D 0x3D 179 #define VK_NONE_3E 0x3E 180 #define VK_NONE_3F 0x3F 181 #define VK_NONE_40 0x40 182 #define VK_A 0x41 183 #define VK_B 0x42 184 #define VK_C 0x43 185 #define VK_D 0x44 186 #define VK_E 0x45 187 #define VK_F 0x46 188 #define VK_G 0x47 189 #define VK_H 0x48 190 #define VK_I 0x49 191 #define VK_J 0x4A 192 #define VK_K 0x4B 193 #define VK_L 0x4C 194 #define VK_M 0x4D 195 #define VK_N 0x4E 196 #define VK_O 0x4F 197 #define VK_P 0x50 198 #define VK_Q 0x51 199 #define VK_R 0x52 200 #define VK_S 0x53 201 #define VK_T 0x54 202 #define VK_U 0x55 203 #define VK_V 0x56 204 #define VK_W 0x57 205 #define VK_X 0x58 206 #define VK_Y 0x59 207 #define VK_Z 0x5A 208 #define VK_NONE_5B 0x5B 209 #define VK_NONE_5C 0x5C 210 #define VK_NONE_5D 0x5D 211 #define VK_NONE_5E 0x5E 212 #define VK_NONE_5F 0x5F 213 #define VK_NUMPAD0 0x60 214 #define VK_NUMPAD1 0x61 215 #define VK_NUMPAD2 0x62 216 #define VK_NUMPAD3 0x63 217 #define VK_NUMPAD4 0x64 218 #define VK_NUMPAD5 0x65 219 #define VK_NUMPAD6 0x66 220 #define VK_NUMPAD7 0x67 221 #define VK_NUMPAD8 0x68 222 #define VK_NUMPAD9 0x69 223 #define VK_MULTIPLY 0x6A 224 #define VK_ADD 0x6B 225 #define VK_SEPARATOR 0x6C 226 #define VK_SUBTRACT 0x6D 227 #define VK_DECIMAL 0x6E 228 #define VK_DIVIDE 0x6F 229 #define VK_F1 0x70 230 #define VK_F2 0x71 231 #define VK_F3 0x72 232 #define VK_F4 0x73 233 #define VK_F5 0x74 234 #define VK_F6 0x75 235 #define VK_F7 0x76 236 #define VK_F8 0x77 237 #define VK_F9 0x78 238 #define VK_F10 0x79 239 #define VK_F11 0x7A 240 #define VK_F12 0x7B 241 #define VK_F13 0x7C 242 #define VK_F14 0x7D 243 #define VK_F15 0x7E 244 #define VK_F16 0x7F 245 #define VK_F17 0x80 246 #define VK_F18 0x81 247 #define VK_F19 0x82 248 #define VK_F20 0x83 249 #define VK_F21 0x84 250 #define VK_F22 0x85 251 #define VK_F23 0x86 252 #define VK_F24 0x87 253 #define VK_NONE_88 0x88 254 #define VK_NONE_89 0x89 255 #define VK_NONE_8A 0x8A 256 #define VK_NONE_8B 0x8B 257 #define VK_NONE_8C 0x8C 258 #define VK_NONE_8D 0x8D 259 #define VK_NONE_8E 0x8E 260 #define VK_NONE_8F 0x8F 261 #define VK_NUMLOCK 0x90 262 #define VK_SCROLL 0x91 263 #define VK_NONE_92 0x92 264 #define VK_NONE_93 0x93 265 #define VK_NONE_94 0x94 266 #define VK_NONE_95 0x95 267 #define VK_NONE_96 0x96 268 #define VK_NONE_97 0x97 269 #define VK_NONE_98 0x98 270 #define VK_NONE_99 0x99 271 #define VK_NONE_9A 0x9A 272 #define VK_NONE_9B 0x9B 273 #define VK_NONE_9C 0x9C 274 #define VK_NONE_9D 0x9D 275 #define VK_NONE_9E 0x9E 276 #define VK_NONE_9F 0x9F 277 #define VK_NONE_A0 0xA0 278 #define VK_NONE_A1 0xA1 279 #define VK_NONE_A2 0xA2 280 #define VK_NONE_A3 0xA3 281 #define VK_NONE_A4 0xA4 282 #define VK_NONE_A5 0xA5 283 #define VK_NONE_A6 0xA6 284 #define VK_NONE_A7 0xA7 285 #define VK_NONE_A8 0xA8 286 #define VK_NONE_A9 0xA9 287 #define VK_NONE_AA 0xAA 288 #define VK_NONE_AB 0xAB 289 #define VK_NONE_AC 0xAC 290 #define VK_NONE_AD 0xAD 291 #define VK_NONE_AE 0xAE 292 #define VK_NONE_AF 0xAF 293 #define VK_NONE_B0 0xB0 294 #define VK_NONE_B1 0xB1 295 #define VK_NONE_B2 0xB2 296 #define VK_NONE_B3 0xB3 297 #define VK_NONE_B4 0xB4 298 #define VK_NONE_B5 0xB5 299 #define VK_NONE_B6 0xB6 300 #define VK_NONE_B7 0xB7 301 #define VK_NONE_B8 0xB8 302 #define VK_NONE_B9 0xB9 303 #define VK_NONE_BA 0xBA 304 #define VK_NONE_BB 0xBB 305 #define VK_NONE_BC 0xBC 306 #define VK_NONE_BD 0xBD 307 #define VK_NONE_BE 0xBE 308 #define VK_NONE_BF 0xBF 309 #define VK_NONE_C0 0xC0 310 #define VK_NONE_C1 0xC1 311 #define VK_NONE_C2 0xC2 312 #define VK_NONE_C3 0xC3 313 #define VK_NONE_C4 0xC4 314 #define VK_NONE_C5 0xC5 315 #define VK_NONE_C6 0xC6 316 #define VK_NONE_C7 0xC7 317 #define VK_NONE_C8 0xC8 318 #define VK_NONE_C9 0xC9 319 #define VK_NONE_CA 0xCA 320 #define VK_NONE_CB 0xCB 321 #define VK_NONE_CC 0xCC 322 #define VK_NONE_CD 0xCD 323 #define VK_NONE_CE 0xCE 324 #define VK_NONE_CF 0xCF 325 #define VK_NONE_D0 0xD0 326 #define VK_NONE_D1 0xD1 327 #define VK_NONE_D2 0xD2 328 #define VK_NONE_D3 0xD3 329 #define VK_NONE_D4 0xD4 330 #define VK_NONE_D5 0xD5 331 #define VK_NONE_D6 0xD6 332 #define VK_NONE_D7 0xD7 333 #define VK_NONE_D8 0xD8 334 #define VK_NONE_D9 0xD9 335 #define VK_NONE_DA 0xDA 336 #define VK_NONE_DB 0xDB 337 #define VK_NONE_DC 0xDC 338 #define VK_NONE_DD 0xDD 339 #define VK_NONE_DE 0xDE 340 #define VK_NONE_DF 0xDF 341 #define VK_NONE_E0 0xE0 342 #define VK_NONE_E1 0xE1 343 #define VK_NONE_E2 0xE2 344 #define VK_NONE_E3 0xE3 345 #define VK_NONE_E4 0xE4 346 #define VK_NONE_E5 0xE5 347 #define VK_NONE_E6 0xE6 348 #define VK_NONE_E7 0xE7 349 #define VK_NONE_E8 0xE8 350 #define VK_NONE_E9 0xE9 351 #define VK_NONE_EA 0xEA 352 #define VK_NONE_EB 0xEB 353 #define VK_NONE_EC 0xEC 354 #define VK_NONE_ED 0xED 355 #define VK_NONE_EE 0xEE 356 #define VK_NONE_EF 0xEF 357 #define VK_NONE_F0 0xF0 358 #define VK_NONE_F1 0xF1 359 #define VK_NONE_F2 0xF2 360 #define VK_NONE_F3 0xF3 361 #define VK_NONE_F4 0xF4 362 #define VK_NONE_F5 0xF5 363 #define VK_NONE_F6 0xF6 364 #define VK_NONE_F7 0xF7 365 #define VK_NONE_F8 0xF8 366 #define VK_NONE_F9 0xF9 367 #define VK_NONE_FA 0xFA 368 #define VK_NONE_FB 0xFB 369 #define VK_NONE_FC 0xFC 370 #define VK_NONE_FD 0xFD 371 #define VK_NONE_FE 0xFE 372 #define VK_NONE_FF 0xFF 373 374 #define VK_UPLEFT VK_HOME 375 #define VK_UPRIGHT VK_PRIOR 376 #define VK_DOWNLEFT VK_END 377 #define VK_DOWNRIGHT VK_NEXT 378 #define VK_ALT VK_MENU 379 380 enum { 381 // 382 // Define all the KA types as variations of the VK types. This is 383 // so the KA functions will work properly under windows 95. 384 // 385 KA_NONE = 0, 386 KA_MORE = 1, 387 KA_SETBKGDCOL = 2, 388 KA_SETFORECOL = 6, 389 KA_FORMFEED = 12, 390 KA_SPCTAB = 20, 391 KA_SETX = 25, 392 KA_SETY = 26, 393 394 KA_SPACE = 32, /* */ 395 KA_EXCLAMATION, /* ! */ 396 KA_DQUOTE, /* " */ 397 KA_POUND, /* # */ 398 KA_DOLLAR, /* $ */ 399 KA_PERCENT, /* % */ 400 KA_AMPER, /* & */ 401 KA_SQUOTE, /* ' */ 402 KA_LPAREN, /* ( */ 403 KA_RPAREN, /* ) */ 404 KA_ASTERISK, /* * */ 405 KA_PLUS, /* + */ 406 KA_COMMA, /* , */ 407 KA_MINUS, /* - */ 408 KA_PERIOD, /* . */ 409 KA_SLASH, /* / */ 410 411 KA_0, KA_1, KA_2, KA_3, KA_4, KA_5, KA_6, KA_7, KA_8, KA_9, 412 KA_COLON, /* : */ 413 KA_SEMICOLON, /* ; */ 414 KA_LESS_THAN, /* < */ 415 KA_EQUAL, /* = */ 416 KA_GREATER_THAN, /* > */ 417 KA_QUESTION, /* ? */ 418 419 KA_AT, /* @ */ 420 KA_A, /* A */ 421 KA_B, /* B */ 422 KA_C, /* C */ 423 KA_D, /* D */ 424 KA_E, /* E */ 425 KA_F, /* F */ 426 KA_G, /* G */ 427 KA_H, /* H */ 428 KA_I, /* I */ 429 KA_J, /* J */ 430 KA_K, /* K */ 431 KA_L, /* L */ 432 KA_M, /* M */ 433 KA_N, /* N */ 434 KA_O, /* O */ 435 436 KA_P, /* P */ 437 KA_Q, /* Q */ 438 KA_R, /* R */ 439 KA_S, /* S */ 440 KA_T, /* T */ 441 KA_U, /* U */ 442 KA_V, /* V */ 443 KA_W, /* W */ 444 KA_X, /* X */ 445 KA_Y, /* Y */ 446 KA_Z, /* Z */ 447 KA_LBRACKET, /* [ */ 448 KA_BACKSLASH, /* \ */ 449 KA_RBRACKET, /* ] */ 450 KA_CARROT, /* ^ */ 451 KA_UNDERLINE, /* _ */ 452 453 KA_GRAVE, /* ` */ 454 KA_a, /* a */ 455 KA_b, /* b */ 456 KA_c, /* c */ 457 KA_d, /* d */ 458 KA_e, /* e */ 459 KA_f, /* f */ 460 KA_g, /* g */ 461 KA_h, /* h */ 462 KA_i, /* i */ 463 KA_j, /* j */ 464 KA_k, /* k */ 465 KA_l, /* l */ 466 KA_m, /* m */ 467 KA_n, /* n */ 468 KA_o, /* o */ 469 470 KA_p, /* p */ 471 KA_q, /* q */ 472 KA_r, /* r */ 473 KA_s, /* s */ 474 KA_t, /* t */ 475 KA_u, /* u */ 476 KA_v, /* v */ 477 KA_w, /* w */ 478 KA_x, /* x */ 479 KA_y, /* y */ 480 KA_z, /* z */ 481 KA_LBRACE, /* { */ 482 KA_BAR, /* | */ 483 KA_RBRACE, /* ] */ 484 KA_TILDA, /* ~ */ 485 486 KA_ESC = VK_ESCAPE | WWKEY_VK_BIT, 487 KA_EXTEND = VK_ESCAPE | WWKEY_VK_BIT, 488 KA_RETURN = VK_RETURN | WWKEY_VK_BIT, 489 KA_BACKSPACE = VK_BACK | WWKEY_VK_BIT, 490 KA_TAB = VK_TAB | WWKEY_VK_BIT, 491 KA_DELETE = VK_DELETE | WWKEY_VK_BIT, /* <DELETE> */ 492 KA_INSERT = VK_INSERT | WWKEY_VK_BIT, /* <INSERT> */ 493 KA_PGDN = VK_NEXT | WWKEY_VK_BIT, /* <PAGE DOWN> */ 494 KA_DOWNRIGHT = VK_NEXT | WWKEY_VK_BIT, 495 KA_DOWN = VK_DOWN | WWKEY_VK_BIT, /* <DOWN ARROW> */ 496 KA_END = VK_END | WWKEY_VK_BIT, /* <END> */ 497 KA_DOWNLEFT = VK_END | WWKEY_VK_BIT, 498 KA_RIGHT = VK_RIGHT | WWKEY_VK_BIT, /* <RIGHT ARROW> */ 499 KA_KEYPAD5 = VK_SELECT | WWKEY_VK_BIT, /* NUMERIC KEY PAD <5> */ 500 KA_LEFT = VK_LEFT | WWKEY_VK_BIT, /* <LEFT ARROW> */ 501 KA_PGUP = VK_PRIOR | WWKEY_VK_BIT, /* <PAGE UP> */ 502 KA_UPRIGHT = VK_PRIOR | WWKEY_VK_BIT, 503 KA_UP = VK_UP | WWKEY_VK_BIT, /* <UP ARROW> */ 504 KA_HOME = VK_HOME | WWKEY_VK_BIT, /* <HOME> */ 505 KA_UPLEFT = VK_HOME | WWKEY_VK_BIT, 506 KA_F12 = VK_F12 | WWKEY_VK_BIT, 507 KA_F11 = VK_F11 | WWKEY_VK_BIT, 508 KA_F10 = VK_F10 | WWKEY_VK_BIT, 509 KA_F9 = VK_F9 | WWKEY_VK_BIT, 510 KA_F8 = VK_F8 | WWKEY_VK_BIT, 511 KA_F7 = VK_F7 | WWKEY_VK_BIT, 512 KA_F6 = VK_F6 | WWKEY_VK_BIT, 513 KA_F5 = VK_F5 | WWKEY_VK_BIT, 514 KA_F4 = VK_F4 | WWKEY_VK_BIT, 515 KA_F3 = VK_F3 | WWKEY_VK_BIT, 516 KA_F2 = VK_F2 | WWKEY_VK_BIT, 517 KA_F1 = VK_F1 | WWKEY_VK_BIT, 518 KA_LMOUSE = VK_LBUTTON | WWKEY_VK_BIT, 519 KA_RMOUSE = VK_RBUTTON | WWKEY_VK_BIT, 520 521 KA_SHIFT_BIT = WWKEY_SHIFT_BIT, 522 KA_CTRL_BIT = WWKEY_CTRL_BIT, 523 KA_ALT_BIT = WWKEY_ALT_BIT, 524 KA_RLSE_BIT = WWKEY_RLS_BIT, 525 526 // 527 // Define all the KN types as variations of the KA types. This is 528 // so the KN functions will work properly under windows 95. 529 // 530 KN_NONE = 0, 531 KN_GRAVE = KA_GRAVE, 532 KN_1 = KA_1, 533 KN_2 = KA_2, 534 KN_3 = KA_3, 535 KN_4 = KA_4, 536 KN_5 = KA_5, 537 KN_6 = KA_6, 538 KN_7 = KA_7, 539 KN_8 = KA_8, 540 KN_9 = KA_9, 541 KN_0 = KA_0, 542 KN_MINUS = KA_MINUS, /* - */ 543 KN_EQUAL = KA_EQUAL, /* = */ 544 545 KN_BACKSPACE = KA_BACKSPACE, 546 547 KN_TAB = KA_TAB, /* <TAB> */ 548 KN_Q = KA_q, 549 KN_W = KA_w, 550 KN_E = KA_e, 551 KN_R = KA_r, 552 KN_T = KA_t, 553 KN_Y = KA_y, 554 KN_U = KA_u, 555 KN_I = KA_i, 556 KN_O = KA_o, 557 KN_P = KA_p, 558 KN_LBRACKET = KA_LBRACKET, /* [ */ 559 KN_RBRACKET = KA_RBRACKET, /* ] */ 560 KN_BACKSLASH = KA_BACKSLASH, /* \ */ 561 562 563 KN_A = KA_a, 564 KN_S = KA_s, 565 KN_D = KA_d, 566 KN_F = KA_f, 567 KN_G = KA_g, 568 KN_H = KA_h, 569 KN_J = KA_j, 570 KN_K = KA_k, 571 KN_L = KA_l, 572 KN_SEMICOLON = KA_SEMICOLON, /* ; */ 573 KN_SQUOTE = KA_SQUOTE, /* ' */ 574 KN_BACKSLASH2 = KA_BACKSLASH, 575 KN_RETURN = KA_RETURN, 576 KN_Z = KA_z, 577 KN_X = KA_x, 578 KN_C = KA_c, 579 KN_V = KA_v, 580 KN_B = KA_b, 581 KN_N = KA_n, 582 KN_M = KA_m, 583 KN_COMMA = KA_COMMA, /* , */ 584 KN_PERIOD = KA_PERIOD, /* . */ 585 KN_SLASH = KA_SLASH, /* / */ 586 KN_SPACE = KA_SPACE, 587 KN_LMOUSE = KA_LMOUSE, 588 KN_RMOUSE = KA_RMOUSE, 589 590 KN_HOME = KA_HOME, /* num key pad 7 */ 591 KN_UPLEFT = KA_UPLEFT, 592 KN_LEFT = KA_LEFT, /* num key pad 4 */ 593 KN_END = KA_END, /* num key pad 1 */ 594 KN_DOWNLEFT = KA_DOWNLEFT, 595 596 KN_KEYPAD_SLASH = KA_SLASH, /* num key pad / */ 597 KN_UP = KA_UP, /* num key pad 8 */ 598 KN_CENTER = KA_KEYPAD5, /* num key pad 5 */ 599 KN_DOWN = KA_DOWN, /* num key pad 2 */ 600 KN_INSERT = KA_INSERT, /* num key pad 0 */ 601 KN_KEYPAD_ASTERISK= KA_ASTERISK, /* num key pad * */ 602 KN_PGUP = KA_PGUP, /* num key pad 9 */ 603 KN_UPRIGHT = KA_UPRIGHT, 604 KN_RIGHT = KA_RIGHT, /* num key pad 6 */ 605 KN_PGDN = KA_PGDN, /* num key pad 3 */ 606 KN_DOWNRIGHT = KA_DOWNRIGHT, 607 KN_DELETE = KA_DELETE, /* num key pad . */ 608 609 KN_KEYPAD_MINUS = KA_MINUS, /* num key pad - */ 610 KN_KEYPAD_PLUS = KA_PLUS, /* num key pad + */ 611 612 613 KN_KEYPAD_RETURN = KA_RETURN, /* num key pad <ENTER> */ 614 615 KN_ESC = KA_ESC, 616 KN_F1 = KA_F1, 617 KN_F2 = KA_F2, 618 KN_F3 = KA_F3, 619 KN_F4 = KA_F4, 620 KN_F5 = KA_F5, 621 KN_F6 = KA_F6, 622 KN_F7 = KA_F7, 623 KN_F8 = KA_F8, 624 KN_F9 = KA_F9, 625 KN_F10 = KA_F10, 626 KN_F11 = KA_F11, 627 KN_F12 = KA_F12, 628 629 KN_PRNTSCRN = VK_PRINT | WWKEY_VK_BIT, 630 KN_CAPSLOCK = VK_CAPITAL | WWKEY_VK_BIT, 631 KN_SCROLLLOCK = VK_SCROLL | WWKEY_VK_BIT, /* <SCROLL LOCK> */ 632 KN_PAUSE = VK_PAUSE | WWKEY_VK_BIT, /* <PAUSE> */ 633 KN_LSHIFT = VK_SHIFT | WWKEY_VK_BIT, 634 KN_RSHIFT = VK_SHIFT | WWKEY_VK_BIT, 635 KN_LCTRL = VK_CONTROL | WWKEY_VK_BIT, 636 KN_RCTRL = VK_CONTROL | WWKEY_VK_BIT, 637 KN_LALT = VK_MENU | WWKEY_VK_BIT, 638 KN_RALT = VK_MENU | WWKEY_VK_BIT, 639 KN_E_INSERT = VK_INSERT | WWKEY_VK_BIT, 640 KN_E_DELETE = VK_DELETE | WWKEY_VK_BIT, 641 KN_E_LEFT = VK_LEFT | WWKEY_VK_BIT, /* extended <LEFT ARROW> */ 642 KN_E_HOME = VK_HOME | WWKEY_VK_BIT, /* extended <HOME> */ 643 KN_E_END = VK_END | WWKEY_VK_BIT, /* extended <END> */ 644 KN_E_UP = VK_UP | WWKEY_VK_BIT, /* extended <UP ARROW> */ 645 KN_E_DOWN = VK_DOWN | WWKEY_VK_BIT, /* extended <DOWN ARROW> */ 646 KN_E_PGUP = VK_PRIOR | WWKEY_VK_BIT, /* extended <PAGE UP> */ 647 KN_E_PGDN = VK_NEXT | WWKEY_VK_BIT, /* extended <PAGE DOWN> */ 648 KN_E_RIGHT = VK_RIGHT | WWKEY_VK_BIT, /* extended <RIGHT ARROW> */ 649 KN_NUMLOCK = VK_NUMLOCK | WWKEY_VK_BIT, /* <NUM LOCK> */ 650 651 KN_SHIFT_BIT = WWKEY_SHIFT_BIT, 652 KN_CTRL_BIT = WWKEY_CTRL_BIT | WWKEY_VK_BIT, 653 KN_ALT_BIT = WWKEY_ALT_BIT | WWKEY_VK_BIT, 654 KN_RLSE_BIT = WWKEY_RLS_BIT, 655 KN_BUTTON = WWKEY_BTN_BIT, 656 }; 657 658 659 extern WWKeyboardClass *_Kbd; 660 661 662 /* 663 ** The following routines provide some compatability with the old westwood 664 ** library. 665 */ 666 int Check_Key(void); 667 int Check_Key_Num(void); 668 int Get_Key_Num(void); 669 int Get_Key(void); 670 int KN_To_KA(int key); 671 void Clear_KeyBuffer(void); 672 int Key_Down(int key); 673 int KN_To_VK(int key); 674 675 #endif