![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to kbd.h CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / ntddk / src / input / inc|
Return to kbd.h CVS log | Up to [WindowsNT SDKs] / ntddk / src / input / inc |
1.1 root 1: /****************************** Module Header ******************************\
2: * Module Name: kbd.h
3: *
4: * Copyright (c) 1985-91, Microsoft Corporation
5: *
6: * Keyboard table values that form the basis for languages and keyboard types.
7: * The basis is US, kbd type 4 - all others are a variation on this.
8: * This file is included by all kbd**.h files.
9: *
10: * History:
11: * 10-Jan-1991 GregoryW
12: * 23-Apr-1991 IanJa VSC_TO_VK _* macros from oemtab.c
13: \***************************************************************************/
14:
15: #ifndef _KBD_
16: #define _KBD_
17:
18: /****************************************************************************\
19: *
20: * Keyboard Layers. Used in kdb??.dll and in usersrv.dll
21: *
22: \****************************************************************************/
23:
24: /*
25: * Key Event (KE) structure
26: * Stores a Virtual Key event
27: */
28: typedef struct tagKE {
29: BYTE bScanCode; // Virtual Scan Code (Set 1)
30: USHORT usFlaggedVk; // Vk | Flags
31: } KE, *PKE;
32:
33: typedef BOOL (* KEPROC)(PKE pKe);
34:
35: /*
36: * KE.usFlaggedVk values, also used in the keyboard layer tables.
37: */
38: #define KBDEXT (USHORT)0x0100
39: #define KBDMULTIVK (USHORT)0x0200
40: #define KBDSPECIAL (USHORT)0x0400
41: #define KBDNUMPAD (USHORT)0x0800
42: #define KBDBREAK (USHORT)0x8000
43:
44: /*
45: * Key message lParam bits
46: */
47: #define EXTENDED_BIT 0x01000000
48: #define DONTCARE_BIT 0x02000000
49: #define FAKE_KEYSTROKE 0x02000000
50:
51: /*
52: * Keyboard Shift State defines. These correspond to the bit mask defined
53: * by the VkKeyScan() API.
54: */
55: #define KBDBASE 0
56: #define KBDSHIFT 1
57: #define KBDCTRL 2
58: #define KBDALT 4
59:
60: /*
61: * Handy diacritics
62: */
63: #define GRAVE 0x0300
64: #define ACUTE 0x0301
65: #define CIRCUMFLEX 0x0302
66: #define TILDE 0x0303
67: #define MACRON 0x0304
68: #define OVERSCORE 0x0305
69: #define BREVE 0x0306
70: #define DOT_ABOVE 0x0307
71: #define UMLAUT 0x0308
72: #define DIARESIS UMLAUT
73: #define HOOK_ABOVE 0x0309
74: #define RING 0x030A
75: #define DOUBLE_ACUTE 0x030B
76: #define HACEK 0x030C
77:
78: #define CEDILLA 0x0327
79: #define OGONEK 0x0328
80: #define TONOS 0x0384
81: #define DIARESIS_TONOS 0x0385
82:
83:
84: #define wszGRAVE L"\x0300"
85: #define wszACUTE L"\x0301"
86: #define wszCIRCUMFLEX L"\x0302"
87: #define wszTILDE L"\x0303"
88: #define wszMACRON L"\x0304"
89: #define wszOVERSCORE L"\x0305"
90: #define wszBREVE L"\x0306"
91: #define wszDOT_ABOVE L"\x0307"
92: #define wszUMLAUT L"\x0308"
93: #define wszHOOK_ABOVE L"\x0309"
94: #define wszRING L"\x030A"
95: #define wszDOUBLE_ACUTE L"\x030B"
96: #define wszHACEK L"\x030C"
97:
98: #define wszCEDILLA L"\x0327"
99: #define wszOGONEK L"\x0328"
100: #define wszTONOS L"\x0384"
101: #define wszDIARESIS_TONOS L"\x0385"
102:
103: /*
104: * function prototypes
105: */
106: VOID VSCFromSC(PKE pke);
107: BYTE VKFromVSC(PKE pke, BYTE bPrefix, LPBYTE afKeyState);
108: BOOL KEOEMProcs(PKE pke);
109: BOOL KELocaleProcs(PKE pke);
110: VOID _KeyEvent(USHORT usVk, WORD wScanCode, DWORD ExtraInfo);
111:
112: /***************************************************************************\
113: * MODIFIER KEYS
114: *
115: * All keyboards have "Modifier" keys which are used to alter the behaviour of
116: * some of the other keys. These shifter keys are usually:
117: * Shift (left and/or right Shift key)
118: * Ctrl (left and/or right Ctrl key)
119: * Alt (left and/or right Alt key)
120: * AltGr (right Alt key only)
121: *
122: * NOTE:
123: * All keyboards use the Shift key.
124: * All keyboards use a Ctrl key to generate ASCII control characters.
125: * All keyboards with a number pad use the Alt key and the NumPad to
126: * generate characters by number.
127: * Keyboards using AltGr as a Modifier Key usually translate the Virtual
128: * ScanCode to Virtual Keys VK_CTRL + VK_ALT at input time: the Modifier
129: * tables should be written to treat Ctrl + Alt as a valid shifter
130: * key combination in these cases.
131: *
132: * By holding down 0 or more of these Modifier keys, a "shift state" is
133: * obtained : the shift state may affect the translation of Virtual Scancodes
134: * to Virtual Keys and/or the translation of Virtuals Key to Characters.
135: *
136: * EXAMPLES:
137: *
138: * Each key on a particular keyboard may be marked with up to five different
139: * characters in five different positions:
140: *
141: * .-------.
142: * /| |\
143: * : | 2 4 | :
144: * | | | |
145: * | | | |
146: * | | 1 3 | |
147: * | |_______| |
148: * | / \ |
149: * |/ 5 \|
150: * `-----------'
151: *
152: * A key may also be able to generate a character that is not marked on it:
153: * these are ASCII Control chars, lower-case letters and/or "invisible keys".
154: * .-------.
155: * An example of an "Invisible Key": /| |\
156: * : | > | :
157: * The German M24 keyboard 2 should produce the | | | |
158: * '|' character when ALT SHIFT is is held down | | | |
159: * while the '<' key (shown here) is pressed: | | < \ | |
160: * This keyboard has four other invisible | |_______| |
161: * characters. France, Italy and Spain also | / \ |
162: * support invisible characters on the M24 |/ \|
163: * Keyboard 2 with ALT SHIFT depressed. `-----------'
164: *
165: * The keyboard table must list the keys that contribute to it's shift state,
166: * and indicate which combinations are valid. This is done with
167: * aCharModifiers[] - convert combinations of Modifier Keys to Bitmasks.
168: * and
169: * aModification[]; - convert Modifier Bitmasks to enumerated Modifications
170: *
171: * AN EXAMPLE OF VALID AND INVALID MODIFIER KEY COMBINATIONS
172: *
173: * The US English keyboard has 3 Modifier keys:
174: * Shift (left or right); Ctrl (left or right); and Alt (left or right).
175: *
176: * The only valid combinations of these Modifier Keys are:
177: * none pressed : Character at position (1) on the key.
178: * Shift : Character at position (2) on the key.
179: * Ctrl : Ascii Control characters
180: * Shift + Ctrl : Ascii Control characters
181: * Alt : Character-by-number on the numpad
182: *
183: * The invalid combinations (that do not generate any characters) are:
184: * Shift + Alt
185: * Alt + Ctrl
186: * Shift + Alt + Ctrl
187: *
188: * Something (???) :
189: * -----------------
190: * Modifier keys Character produced
191: * ------------------------- ------------------
192: * 0 No shifter key depressed position 1
193: * 1 Shift key is depressed position 2
194: * 2 AltGr (r.h. Alt) depressed position 4 or 5 (whichever is marked)
195: *
196: * However, note that 3 shifter keys (SHIFT, can be combined in a
197: * characters, depending on the Keyboards
198: * Consider the following keyboards:
199: *
200: * .-------. STRANGE KBD PECULIAR KBD
201: * /| |\ ================== ==================
202: * : | 2 4 | : 1 -
203: * | | | | 2 - SHIFT SHIFT
204: * | | | | 3 - MENU MENU
205: * | | 1 3 | | 4 - SHIFT + MENU SHIFT + MENU
206: * | |_______| | 5 - no such keys CTRL + MENU
207: * | / \ |
208: * |/ 5 \|
209: * `-----------'
210: * Both STRANGE and PECULIAR keyboards could have aVkToBits[] =
211: * { VK_SHIFT , KBDSHIFT }, // 0x01
212: * { VK_CONTROL, KBDCTRL }, // 0x02
213: * { VK_MENU , KBDALT }, // 0x04
214: * { 0, 0 }
215: *
216: * The STRANGE keyboard has 4 distinct shift states, while the PECULIAR kbd
217: * has 5. However, note that 3 shifter bits can be combined in a
218: * total of 2^3 == 8 ways. Each such combination must be related to one (or
219: * none) of the enumerated shift states.
220: * Each shifter key combination can be represented by three binary bits:
221: * Bit 0 is set if VK_SHIFT is down
222: * Bit 1 is set if VK_CONTROL is down
223: * Bit 2 is set if VK_MENU is down
224: *
225: * Example: If the STRANGE keyboard generates no characters in combination
226: * when just the ALT key is held down, nor when the SHIFT, CTRL and ALT keys
227: * are all held down, then the tables might look like this:
228: *
229: * VK_MENU,
230: * VK_CTRL, 0
231: * };
232: * aModification[] = {
233: * 0, // 0 0 0 = 000 <none>
234: * 1, // 0 0 1 = 001 SHIFT
235: * SHFT_INVALID, // 0 1 0 = 010 ALT
236: * 2, // 0 1 1 = 011 SHIFT ALT
237: * 3, // 1 0 0 = 100 CTRL
238: * 4, // 1 0 1 = 101 SHIFT CTRL
239: * 5, // 1 1 0 = 110 CTRL ALT
240: * SHFT_INVALID // 1 1 1 = 111 SHIFT CTRL ALT
241: * };
242: *
243: *
244: \***************************************************************************/
245:
246: /***************************************************************************\
247: * VK_TO_BIT - associate a Virtual Key with a Modifier bitmask.
248: *
249: * Vk - the Virtual key (eg: VK_SHIFT, VK_RMENU, VK_CONTROL etc.)
250: * Special Values:
251: * 0 null terminator
252: * ModBits - a combination of KBDALT, KBDCTRL, KBDSHIFT and kbd-specific bits
253: * Any kbd-specific shift bits must be the lowest-order bits other
254: * than KBDSHIFT, KBDCTRL and KBDALT (0, 1 & 2)
255: *
256: * Those languages that use AltGr (VK_RMENU) to shift keys convert it to
257: * CTRL+ALT with the KBDSPECIAL bit in the ausVK[] entry for VK_RMENU
258: * and by having an entry in aVkToPfnOem[] to simulate the right Vk sequence.
259: *
260: \***************************************************************************/
261: typedef struct {
262: BYTE Vk;
263: BYTE ModBits;
264: } VK_TO_BIT, *PVK_TO_BIT;
265:
266: /***************************************************************************\
267: * pModNumber - a table to map shift bits to enumerated shift states
268: *
269: * Table attributes: Ordered table
270: *
271: * Maps all possible shifter key combinations to an enumerated shift state.
272: * The size of the table depends on the value of the highest order bit used
273: * in aCharModifiers[*].ModBits
274: *
275: * Special values for aModification[*]
276: * SHFT_INVALID - no characters produced with this shift state.
277: LATER: (ianja) no SHFT_CTRL - control characters encoded in tables like others
278: * SHFT_CTRL - standard control character production (all keyboards must
279: * be able to produce CTRL-C == 0x0003 etc.)
280: * Other - enumerated shift state (not less than 0)
281: *
282: * This table is indexed by the Modifier Bits to obtain an Modification Number.
283: *
284: * CONTROL MENU SHIFT
285: *
286: * aModification[] = {
287: * 0, // 0 0 0 = 000 <none>
288: * 1, // 0 0 1 = 001 SHIFT
289: * SHFT_INVALID, // 0 1 0 = 010 ALT
290: * 2, // 0 1 1 = 011 SHIFT ALT
291: * 3, // 1 0 0 = 100 CTRL
292: * 4, // 1 0 1 = 101 SHIFT CTRL
293: * 5, // 1 1 0 = 110 CTRL ALT
294: * SHFT_INVALID // 1 1 1 = 111 SHIFT CTRL ALT
295: * };
296: *
297: \***************************************************************************/
298: typedef struct {
299: PVK_TO_BIT pVkToBit; // Virtual Keys -> Mod bits
300: WORD wMaxModBits; // max Modification bit combination value
301: BYTE ModNumber[]; // Mod bits -> Modification Number
302: } MODIFIERS, *PMODIFIERS;
303:
304: WORD GetModifierBits(PMODIFIERS pModifiers, LPBYTE afKeyState);
305: WORD GetModificationNumber(PMODIFIERS pModifiers, WORD wModBits);
306:
307: #define SHFT_INVALID 0x0F
308:
309: /***************************************************************************\
310: * apulCvt_VK[] - obtain VK translation table from shift state
311: * A VK translation table is used to change the value of the Virtual Key
312: * according to the shift state. OEM only (not locale-specific)
313: \***************************************************************************/
314: extern PULONG *gapulCvt_VK;
315: extern ULONG *gapulCvt_VK_101[];
316: extern ULONG *gapulCvt_VK_84[];
317:
318: /***************************************************************************\
319: * awNumPadCvt[] - Translate cursor movement keys to numpad keys
320: \***************************************************************************/
321: extern MODIFIERS Modifiers_VK;
322: extern BYTE aVkNumpad[];
323:
324: /***************************************************************************\
325: * VSC_VK - Associate a Virtual Scancode with a Virtual Key
326: * Vsc - Virtual Scancode
327: * Vk - Virtual Key | flags
328: * Used by VKFromVSC() for scancodes prefixed 0xE0 or 0xE1
329: \***************************************************************************/
330: typedef struct VSC_VK {
331: BYTE Vsc;
332: USHORT Vk;
333: } VSC_VK, *PVSC_VK;
334:
335: /***************************************************************************\
336: * VK_VSC - Associate a Virtual Key with a Virtual Scancode
337: * Vk - Virtual Key
338: * Vsc - Virtual Scancode
339: * Used by MapVirtualKey for Virtual Keys not appearing in ausVK[]
340: \***************************************************************************/
341: typedef struct VK_VSC {
342: BYTE Vk;
343: BYTE Vsc;
344: } VK_VSC, *PVK_VSC;
345:
346: /***************************************************************************\
347: *
348: * VK_TO_WCHARS<n> - Associate a Virtual Key with <n> UNICODE characters
349: *
350: * VirtualKey - The Virtual Key.
351: * wch[] - An array of characters, one for each shift state that
352: * applies to the specified Virtual Key.
353: *
354: * Special values for VirtualKey:
355: * -1 - This entry contains dead chars for the previous entry
356: * 0 - Terminates a VK_TO_WCHARS[] table
357: *
358: * Special values for Attributes:
359: * CAPLOK - The CAPS-LOCK/SHIFT-LOCK key affects this key like SHIFT
360: *
361: * Special values for wch[*]:
362: * WCH_NONE - No character is generated by pressing this key with the
363: * current shift state.
364: * WCH_DEAD - The character is a dead-key: the next VK_TO_WCHARS[] entry
365: * will contain the values of the dead characters (diaresis)
366: * that can be produced by the Virtual Key.
367: *
368: \***************************************************************************/
369: #define WCH_NONE 0xF000
370: #define WCH_DEAD 0xF001
371:
372: #define CAPLOK 0x01
373:
374: /*
375: * Macro for VK to WCHAR with "n" shift states
376: */
377: #define TYPEDEF_VK_TO_WCHARS(n) typedef struct _VK_TO_WCHARS##n { \
378: BYTE VirtualKey; \
379: BYTE Attributes; \
380: WCHAR wch[n]; \
381: } VK_TO_WCHARS##n, *PVK_TO_WCHARS##n;
382:
383: /*
384: * To facilitate coding the table scanning routine.
385: */
386:
387: /*
388: * Table element types (for various numbers of shift states), used
389: * to facilitate static initializations of tables.
390: * VK_TO_WCHARS1 and PVK_TO_WCHARS1 may be used as the generic type
391: */
392: TYPEDEF_VK_TO_WCHARS(1) // VK_TO_WCHARS1, *PVK_TO_WCHARS1;
393: TYPEDEF_VK_TO_WCHARS(2) // VK_TO_WCHARS2, *PVK_TO_WCHARS2;
394: TYPEDEF_VK_TO_WCHARS(3) // VK_TO_WCHARS3, *PVK_TO_WCHARS3;
395: TYPEDEF_VK_TO_WCHARS(4) // VK_TO_WCHARS4, *PVK_TO_WCHARS4;
396: TYPEDEF_VK_TO_WCHARS(5) // VK_TO_WCHARS5, *PVK_TO_WCHARS5;
397: TYPEDEF_VK_TO_WCHARS(6) // VK_TO_WCHARS6, *PVK_TO_WCHARS5;
398:
399: /***************************************************************************\
400: *
401: * VK_TO_WCHAR_TABLE - Describe a table of VK_TO_WCHARS1
402: *
403: * pVkToWchars - points to the table.
404: * nModifications - the number of shift-states supported by this table.
405: * (this is the number of elements in pVkToWchars[*].wch[])
406: *
407: * A keyboard may have several such tables: all keys with the same number of
408: * shift-states are grouped together in one table.
409: *
410: * Special values for pVktoWchars:
411: * NULL - Terminates a VK_TO_WCHAR_TABLE[] list.
412: *
413: \***************************************************************************/
414:
415: typedef struct _VK_TO_WCHAR_TABLE {
416: PVK_TO_WCHARS1 pVkToWchars;
417: BYTE nModifications;
418: BYTE cbSize;
419: } VK_TO_WCHAR_TABLE, *PVK_TO_WCHAR_TABLE;
420:
421: /***************************************************************************\
422: *
423: * Dead Key (diaresis) tables
424: *
425: * LATER IanJa: supplant by an NLS API that composes Diacritic+Base -> WCHAR
426: *
427: \***************************************************************************/
428: typedef struct {
429: DWORD dwBoth; // diacritic & char
430: WCHAR wchComposed;
431: } DEADKEY, *PDEADKEY;
432:
433: #define DEADTRANS(ch, accent, comp) { MAKELONG(ch, accent), comp}
434:
435: /***************************************************************************\
436: * VSC_LPWSTR - associate a Virtual Scancode with a Text string
437: *
438: * Uses:
439: * GetKeyNameText(), aKeyNames[] Map virtual scancode to name of key
440: *
441: \***************************************************************************/
442: typedef struct {
443: BYTE vsc;
444: LPWSTR pwsz;
445: } VSC_LPWSTR, *PVSC_LPWSTR;
446:
447: /***************************************************************************\
448: *
449: * VK_F - associate a Virtual Key with a bitmask
450: *
451: * Uses:
452: * Special handle of Virtual Keys - fake different VK sequences
453: *
454: * Vk - A virtual key that is to produce key event simulation.
455: * fKEProc - A bitmask identifying the Key Event simulator procedure(s) to use.
456: * The postion of each set bit is an index into a table of procedure
457: * addresses. Using a bitmask here allows one key to have more than
458: * one Key Event simulator procedure.
459: *
460: \***************************************************************************/
461: typedef struct {
462: BYTE Vk;
463: BYTE fKEProc;
464: } VK_F, *PVK_F;
465:
466: #define KLLF_ALTGR 0x00000001
467:
468: /***************************************************************************\
469: * KBDTABLES
470: *
471: * This structure describes all the tables that implement the keyboard layer.
472: *
473: * When switching to a new layer, we get a new KBDTABLES structure: all key
474: * processing tables are accessed indirectly through this structure.
475: *
476: \***************************************************************************/
477:
478: typedef struct tagKbdLayer {
479: /*
480: * Modifier keys
481: */
482: PMODIFIERS pCharModifiers;
483:
484: /*
485: * Characters
486: */
487: VK_TO_WCHAR_TABLE *pVkToWcharTable; // ptr to tbl of ptrs to tbl
488:
489: /*
490: * Diacritics
491: */
492: PDEADKEY pDeadKey;
493:
494: /*
495: * Names of Keys
496: */
497: VSC_LPWSTR *pKeyNames;
498: VSC_LPWSTR *pKeyNamesExt;
499: LPWSTR *pKeyNamesDead;
500:
501: /*
502: * Scan codes to Virtual Keys
503: */
504: USHORT *pusVSCtoVK;
505: BYTE bMaxVSCtoVK;
506: PVSC_VK pVSCtoVK_E0; // Scancode has E0 prefix
507: PVSC_VK pVSCtoVK_E1; // Scancode has E1 prefix
508:
509: /*
510: * Locale-specific special processing
511: */
512: DWORD fLocaleFlags;
513: } KBDTABLES, *PKBDTABLES;
514:
515: /*
516: * OEM-specific special processing (keystroke simulators and filters)
517: */
518: extern VK_F aVkToFOEM[];
519: extern KEPROC aKEProcOEM[];
520:
521: /***************************************************************************\
522: * Macros for ausVK[] values (used below)
523: *
524: * These macros prefix each argument with VK_ to produce the name of a Virtual
525: * Key defined in "winuser.h" (eg: ESCAPE becomes VK_ESCAPE).
526: \***************************************************************************/
527: #ifndef KBD_TYPE
528: #define KBD_TYPE 4
529: #endif
530:
531: /*
532: * _NE() selects the Virtual Key according to keyboard type
533: */
534: #if (KBD_TYPE == 1)
535: #define _NE(v1,v2,v3,v4,v5,v6) (VK_##v1)
536: #elif (KBD_TYPE == 2)
537: #define _NE(v1,v2,v3,v4,v5,v6) (VK_##v2)
538: #elif (KBD_TYPE == 3)
539: #define _NE(v1,v2,v3,v4,v5,v6) (VK_##v3)
540: #elif (KBD_TYPE == 4)
541: #define _NE(v1,v2,v3,v4,v5,v6) (VK_##v4)
542: #elif (KBD_TYPE == 5)
543: #define _NE(v1,v2,v3,v4,v5,v6) (VK_##v5)
544: #elif (KBD_TYPE == 6)
545: #define _NE(v1,v2,v3,v4,v5,v6) (VK_##v6)
546: #endif
547:
548: /*
549: * _EQ() selects the same Virtual Key for all keyboard types
550: */
551: #define _EQ( v4 ) (VK_##v4)
552:
553: /*
554: * A bit of trickery for virtual key names 'A' to 'Z' and '0' to '9' so
555: * that they are not converted to a VK_* name.
556: * With this macro, VK_'A' equates to 'A' etc.
557: */
558: #define VK_
559: #define VK__none_ 0xFF
560:
561: /***************************************************************************\
562: * T** - Values for ausVK[] (Virtual Scan Code to Virtual Key conversion)
563: *
564: * These values are for Scancode Set 3 and the USA.
565: * Other languages substitute their own values where required (files kbd**.h)
566: *
567: * Six sets of keyboards are supported, according to KBD_TYPE:
568: *
569: * KBD_TYPE Keyboard (examples)
570: * ======== =======================================================
571: * 1 AT&T '301' & '302'; Olivetti 83-key; PC-XT 84-key; etc.
572: * 2 Olivetti M24 102-key
573: * 3 HP Vectra (DIN); Olivetti 86-key; etc.
574: * 4 * Enhanced 101/102-key; Olivetti A; etc.
575: * 5 Nokia (Ericsson) type 5 (1050, etc.)
576: * 6 Nokia (Ericsson) type 6 (9140)
577: *
578: * * If KBD_TYPE is not defined, the default is type 4.
579: *
580: * _EQ() : all keyboard types have the same virtual key for this scancode
581: * _NE() : different virtual keys for this scancode, depending on kbd type
582: *
583: * +------+ +--------+--------+--------+--------+--------+--------+
584: * | Scan | | kbd | kbd | kbd | kbd | kbd | kbd |
585: * | code | | type 1 | type 2 | type 3 | type 4 | type 5 | type 6 |
586: \****+-------+-+--------+--------+--------+--------+--------+--------+******/
587:
588: #define T00 _EQ( _none_ )
589: #define T01 _EQ( ESCAPE )
590: #define T02 _EQ( '1' )
591: #define T03 _EQ( '2' )
592: #define T04 _EQ( '3' )
593: #define T05 _EQ( '4' )
594: #define T06 _EQ( '5' )
595: #define T07 _EQ( '6' )
596: #define T08 _EQ( '7' )
597: #define T09 _EQ( '8' )
598: #define T0A _EQ( '9' )
599: #define T0B _EQ( '0' )
600: #define T0C _EQ( OEM_MINUS )
601: #define T0D _NE(OEM_PLUS,OEM_4, OEM_PLUS,OEM_PLUS,OEM_PLUS,OEM_PLUS)
602: #define T0E _EQ( BACK )
603: #define T0F _EQ( TAB )
604: #define T10 _EQ( 'Q' )
605: #define T11 _EQ( 'W' )
606: #define T12 _EQ( 'E' )
607: #define T13 _EQ( 'R' )
608: #define T14 _EQ( 'T' )
609: #define T15 _EQ( 'Y' )
610: #define T16 _EQ( 'U' )
611: #define T17 _EQ( 'I' )
612: #define T18 _EQ( 'O' )
613: #define T19 _EQ( 'P' )
614: #define T1A _NE(OEM_4, OEM_6, OEM_4, OEM_4, OEM_4, OEM_4 )
615: #define T1B _NE(OEM_6, OEM_1, OEM_6, OEM_6, OEM_6, OEM_6 )
616: #define T1C _EQ( RETURN )
617: #define T1D _EQ( LCONTROL )
618: #define T1E _EQ( 'A' )
619: #define T1F _EQ( 'S' )
620: #define T20 _EQ( 'D' )
621: #define T21 _EQ( 'F' )
622: #define T22 _EQ( 'G' )
623: #define T23 _EQ( 'H' )
624: #define T24 _EQ( 'J' )
625: #define T25 _EQ( 'K' )
626: #define T26 _EQ( 'L' )
627: #define T27 _NE(OEM_1, OEM_PLUS,OEM_1, OEM_1, OEM_1, OEM_1 )
628: #define T28 _NE(OEM_7, OEM_3, OEM_7, OEM_7, OEM_3, OEM_3 )
629: #define T29 _NE(OEM_3, OEM_7, OEM_3, OEM_3, OEM_7, OEM_7 )
630: #define T2A _EQ( LSHIFT )
631: #define T2B _EQ( OEM_5 )
632: #define T2C _EQ( 'Z' )
633: #define T2D _EQ( 'X' )
634: #define T2E _EQ( 'C' )
635: #define T2F _EQ( 'V' )
636: #define T30 _EQ( 'B' )
637: #define T31 _EQ( 'N' )
638: #define T32 _EQ( 'M' )
639: #define T33 _EQ( OEM_COMMA )
640: #define T34 _EQ( OEM_PERIOD )
641: #define T35 _EQ( OEM_2 )
642: #define T36 _EQ( RSHIFT )
643: #define T37 _EQ( MULTIPLY )
644: #define T38 _EQ( LMENU )
645: #define T39 _EQ( ' ' )
646: #define T3A _EQ( CAPITAL )
647: #define T3B _EQ( F1 )
648: #define T3C _EQ( F2 )
649: #define T3D _EQ( F3 )
650: #define T3E _EQ( F4 )
651: #define T3F _EQ( F5 )
652: #define T40 _EQ( F6 )
653: #define T41 _EQ( F7 )
654: #define T42 _EQ( F8 )
655: #define T43 _EQ( F9 )
656: #define T44 _EQ( F10 )
657: #define T45 _EQ( NUMLOCK )
658: #define T46 _EQ( OEM_SCROLL )
659: #define T47 _EQ( HOME )
660: #define T48 _EQ( UP )
661: #define T49 _EQ( PRIOR )
662: #define T4A _EQ( SUBTRACT )
663: #define T4B _EQ( LEFT )
664: #define T4C _EQ( CLEAR )
665: #define T4D _EQ( RIGHT )
666: #define T4E _EQ( ADD )
667: #define T4F _EQ( END )
668: #define T50 _EQ( DOWN )
669: #define T51 _EQ( NEXT )
670: #define T52 _EQ( INSERT )
671: #define T53 _EQ( DELETE )
672: #define T54 _EQ( SNAPSHOT )
673: #define T55 _EQ( _none_ )
674: #define T56 _NE(OEM_102, HELP, OEM_102, OEM_102, _none_, OEM_PA2 )
675: #define T57 _NE(F11, RETURN, F11, F11, _none_, HELP )
676: #define T58 _NE(F12, LEFT, F12, F12, _none_, OEM_102 )
677: #define T59 _EQ( CLEAR )
678: #define T5A _EQ( NONAME )// WSCtrl
679: #define T5B _EQ( NONAME )// Finish
680: #define T5C _EQ( NONAME )// Jump
681: #define T5D _EQ( EREOF )
682: #define T5E _EQ( _none_ )
683: #define T5F _EQ( NONAME )
684: #define T60 _EQ( _none_ )
685: #define T61 _EQ( _none_ )
686: #define T62 _EQ( _none_ )
687: #define T63 _EQ( _none_ )
688: #define T64 _EQ( F13 )
689: #define T65 _EQ( F14 )
690: #define T66 _EQ( F15 )
691: #define T67 _EQ( F16 )
692: #define T68 _EQ( F17 )
693: #define T69 _EQ( F18 )
694: #define T6A _EQ( F19 )
695: #define T6B _EQ( F20 )
696: #define T6C _EQ( F21 )
697: #define T6D _EQ( F22 )
698: #define T6E _EQ( F23 )
699: #define T6F _EQ( _none_ )
700: #define T70 _EQ( _none_ )
701: #define T71 _EQ( _none_ )
702: #define T72 _EQ( _none_ )
703: #define T73 _EQ( _none_ )
704: #define T74 _EQ( _none_ )
705: #define T75 _EQ( _none_ )
706: #define T76 _EQ( F24 )
707: #define T77 _EQ( _none_ )
708: #define T78 _EQ( _none_ )
709: #define T79 _EQ( _none_ )
710: #define T7A _EQ( _none_ )
711: #define T7B _EQ( _none_ )
712: #define T7C _EQ( TAB )
713:
714: #define X1C _EQ( RETURN )
715: #define X1D _EQ( RCONTROL )
716: #define X35 _EQ( DIVIDE )
717: #define X37 _EQ( SNAPSHOT )
718: #define X38 _EQ( RMENU )
719: #define X46 _EQ( CANCEL )
720: #define X47 _EQ( HOME )
721: #define X48 _EQ( UP )
722: #define X49 _EQ( PRIOR )
723: #define X4B _EQ( LEFT )
724: #define X4D _EQ( RIGHT )
725: #define X4F _EQ( END )
726: #define X50 _EQ( DOWN )
727: #define X51 _NE(NEXT, F1, NEXT, NEXT, _none_, OEM_PA2 )
728: #define X52 _EQ( INSERT )
729: #define X53 _EQ( DELETE )
730:
731: /*
732: * The break key is sent to us as E1,LCtrl,NumLock
733: * We must conevrt the E1+LCtrl to BREAK, then ignore the Numlock
734: * which must be ignored. Alternatively, translate Ctrl-Numlock
735: * to break, but don't let the CTRL through as a WM_KEYUP/DOWN) ?
736: */
737: #define Y1D _EQ( PAUSE )
738:
739: #define SCANCODE_LSHIFT 0x2A
740: #define SCANCODE_RSHIFT 0x36
741: #define SCANCODE_SIMULATED (FAKE_KEYSTROKE >> 16)
742:
743: #define SCANCODE_NUMPAD_FIRST 0x47
744: #define SCANCODE_NUMPAD_LAST 0x52
745:
746: #endif // _KBD_
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.