![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to kbdgr.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / ntddk / src / input / kbdgr|
Return to kbdgr.c CVS log | Up to [WindowsNT SDKs] / ntddk / src / input / kbdgr |
1.1 root 1: /***************************************************************************\
2: * Module Name: kbdgr.c
3: *
4: * Copyright (c) 1985-93, Microsoft Corporation
5: *
6: * History:
7: * 15-01-92 PamelaO Created.
8: * 04/21/92 a-kchang Modified.
9: \***************************************************************************/
10:
11: #include <windows.h>
12: #include "vkoem.h"
13: #include "kbd.h"
14: #include "kbdgr.h"
15:
16: /***************************************************************************\
17: * asuVK[] - Virtual Scan Code to Virtual Key conversion table for GR
18: \***************************************************************************/
19:
20: static USHORT ausVK[] = {
21: T00, T01, T02, T03, T04, T05, T06, T07,
22: T08, T09, T0A, T0B, T0C, T0D, T0E, T0F,
23: T10, T11, T12, T13, T14, T15, T16, T17,
24: T18, T19, T1A, T1B, T1C, T1D, T1E, T1F,
25: T20, T21, T22, T23, T24, T25, T26, T27,
26: T28, T29, T2A, T2B, T2C, T2D, T2E, T2F,
27: T30, T31, T32, T33, T34, T35,
28:
29: /*
30: * Right-hand Shift key must have KBDEXT bit set.
31: */
32: T36 | KBDEXT,
33:
34: T37 | KBDMULTIVK, // numpad_* + Shift/Alt -> SnapShot
35:
36: T38, T39, T3A, T3B, T3C, T3D, T3E,
37: T3F, T40, T41, T42, T43, T44,
38:
39: /*
40: * NumLock Key:
41: * KBDEXT - VK_NUMLOCK is an Extended key
42: * KBDMULTIVK - VK_NUMLOCK or VK_PAUSE (without or with CTRL)
43: */
44: T45 | KBDEXT | KBDMULTIVK,
45:
46: T46 | KBDMULTIVK,
47:
48: /*
49: * Number Pad keys:
50: * KBDNUMPAD - digits 0-9 and decimal point.
51: * KBDSPECIAL - require special processing by Windows
52: */
53: T47 | KBDNUMPAD | KBDSPECIAL, // Numpad 7 (Home)
54: T48 | KBDNUMPAD | KBDSPECIAL, // Numpad 8 (Up),
55: T49 | KBDNUMPAD | KBDSPECIAL, // Numpad 9 (PgUp),
56: T4A,
57: T4B | KBDNUMPAD | KBDSPECIAL, // Numpad 4 (Left),
58: T4C | KBDNUMPAD | KBDSPECIAL, // Numpad 5 (Clear),
59: T4D | KBDNUMPAD | KBDSPECIAL, // Numpad 6 (Right),
60: T4E,
61: T4F | KBDNUMPAD | KBDSPECIAL, // Numpad 1 (End),
62: T50 | KBDNUMPAD | KBDSPECIAL, // Numpad 2 (Down),
63: T51 | KBDNUMPAD | KBDSPECIAL, // Numpad 3 (PgDn),
64: T52 | KBDNUMPAD | KBDSPECIAL, // Numpad 0 (Ins),
65: T53 | KBDNUMPAD | KBDSPECIAL, // Numpad . (Del),
66:
67: T54, T55, T56, T57, T58
68:
69: };
70:
71: static VSC_VK aE0VscToVk[] = {
72: { 0x1C, X1C | KBDEXT }, // Numpad Enter
73: { 0x1D, X1D | KBDEXT }, // RControl
74: { 0x35, X35 | KBDEXT }, // Numpad Divide
75: { 0x37, X37 | KBDEXT }, // Snapshot
76: { 0x38, X38 | KBDEXT | KBDSPECIAL }, // RMenu (AltGr)
77: { 0x46, X46 | KBDEXT }, // Break (Ctrl + Pause)
78: { 0x47, X47 | KBDEXT }, // Home
79: { 0x48, X48 | KBDEXT }, // Up
80: { 0x49, X49 | KBDEXT }, // Prior
81: { 0x4B, X4B | KBDEXT }, // Left
82: { 0x4D, X4D | KBDEXT }, // Right
83: { 0x4F, X4F | KBDEXT }, // End
84: { 0x50, X50 | KBDEXT }, // Down
85: { 0x51, X51 | KBDEXT }, // Next
86: { 0x52, X52 | KBDEXT }, // Insert
87: { 0x53, X53 | KBDEXT }, // Delete
88: { 0, 0 }
89: };
90:
91: static VSC_VK aE1VscToVk[] = {
92: { 0x1D, Y1D }, // Pause
93: { 0 , 0 }
94: };
95:
96: /***************************************************************************\
97: * aVkToBits[] - define bitmask values for character-modifier keys
98: *
99: * typedef struct {
100: * BYTE Vk; // Virtual Key that modifies character production
101: * BYTE ModBits; // Bitmask to represent this key.
102: * } [];
103: *
104: * Vk - Virtual Key code (eg: VK_SHIFT, VK_RMENU, VK_CONTROL,...)
105: * Reserved Values:
106: * 0 null terminator
107: *
108: * ModBits - A bitmask encoding the shifter key for use in CharModifiers (blow)
109: * Reserved Values:
110: * KBDSHIFT 0
111: * KBDCTRL 1
112: * KBDALT 2
113: *
114: * Layouts that use AltGr (VK_RMENU) to modify characters do not use this
115: * method to map the right-hand Alt key to Ctrl+Alt. The KLLF_ALTGR flag
116: * is used instead (below).
117: *
118: * German keyboard has only three shifter keys (may be used in combination)
119: * SHIFT (L & R) affects alphabnumeric keys,
120: * CTRL (L & R) is used to generate control characters
121: * ALT (L & R) used for generating characters by number with numpad
122: \***************************************************************************/
123:
124: static VK_TO_BIT aVkToBits[] = {
125: { VK_SHIFT, KBDSHIFT },
126: { VK_CONTROL, KBDCTRL },
127: { VK_MENU, KBDALT },
128: { 0, 0 }
129: };
130:
131: /***************************************************************************\
132: * aModification[] - map character-modifier bitmask to character table index.
133: *
134: * typedef struct {
135: * PVK_TO_BIT pVkToBit; // Points to the aVkToBits[] table (above)
136: * WORD wMaxModBits; // max valid character-modifier bitmask.
137: * BYTE ModNumber[]; // table to map char-modifier bitmask to index.
138: * } MODIFIERS, *PMODIFIERS;
139: *
140: * Reserved index values (in ModNumber[character-modifier bitmask])
141: * SHFT_INVALID - no characters produced with this shift state.
142: *
143: * Note: index values are chosen to minimise character table sizes: the least
144: * used char-modifier key combinations are given the highest indices.
145: \***************************************************************************/
146:
147: static MODIFIERS CharModifiers = {
148: &aVkToBits[0],
149: 6,
150: {
151: // Character Char-Mod
152: // Table Index Bitmask Keys Pressed : notes
153: // =========== ======== ============== : ============
154: 0, // 000 : unshifted characters
155: 1, // 001 SHIFT : capitals, ~!@# etc.
156: 3, // 010 CTRL : control characters
157: 4, // 011 CTRL SHIFT : control characters
158: SHFT_INVALID, // 100 ALT : -- invalid --
159: SHFT_INVALID, // 101 ALT SHIFT : -- invalid --
160: 2 // 110 ALT CTRL : equivalent to AltGr
161: // 111 ALT CTRL SHIFT : -- invalid --
162: }
163: };
164:
165: /***************************************************************************\
166: * aVkToWch2[] - Virtual Key -> WCHAR for keys with max char-mod index == 2
167: * aVkToWch3[] - Virtual Key -> WCHAR for keys with max char-mod index == 3
168: * aVkToWch4[] - Virtual Key -> WCHAR for keys with max char-mod index == 4
169: * aVkToWch5[] - Virtual Key -> WCHAR for keys with max char-mod index == 5
170: *
171: * This table is searched for a matching Virtual Key, then indexed with
172: * the character-modifier index to find the corresponding characters.
173: * typedef struct _VK_TO_WCHARS3 {
174: * BYTE VirtualKey; \\ The Virtual Key code
175: * BYTE Attributes; \\ does the CapsLock key modify the character
176: * WCHAR wch[3]; \\ Array of characters, index by char-mod index
177: * };
178: *
179: * Reserved VirtualKey values (first column)
180: * 0xff - this line contains dead characters (diacritic)
181: * 0 - terminator
182: *
183: * Reserved Attribute values (second column)
184: * CAPLOK - CapsLock affects this key like Shift
185: *
186: * Reserved character values (third through last column)
187: * WCH_NONE - No character
188: * WCH_DEAD - Dead character (diacritic) value is in next line
189: *
190: \***************************************************************************/
191:
192: static VK_TO_WCHARS2 aVkToWch2[] = {
193: {'1' , CAPLOK ,'1' ,'!' },
194: {'4' , CAPLOK ,'4' ,'$' },
195: {'5' , CAPLOK ,'5' ,'%' },
196: {'A' , CAPLOK ,'a' ,'A' },
197: {'B' , CAPLOK ,'b' ,'B' },
198: {'C' , CAPLOK ,'c' ,'C' },
199: {'D' , CAPLOK ,'d' ,'D' },
200: {'E' , CAPLOK ,'e' ,'E' },
201: {'F' , CAPLOK ,'f' ,'F' },
202: {'G' , CAPLOK ,'g' ,'G' },
203: {'H' , CAPLOK ,'h' ,'H' },
204: {'I' , CAPLOK ,'i' ,'I' },
205: {'J' , CAPLOK ,'j' ,'J' },
206: {'K' , CAPLOK ,'k' ,'K' },
207: {'L' , CAPLOK ,'l' ,'L' },
208: {'N' , CAPLOK ,'n' ,'N' },
209: {'O' , CAPLOK ,'o' ,'O' },
210: {'P' , CAPLOK ,'p' ,'P' },
211: {'R' , CAPLOK ,'r' ,'R' },
212: {'S' , CAPLOK ,'s' ,'S' },
213: {'T' , CAPLOK ,'t' ,'T' },
214: {'U' , CAPLOK ,'u' ,'U' },
215: {'V' , CAPLOK ,'v' ,'V' },
216: {'W' , CAPLOK ,'w' ,'W' },
217: {'X' , CAPLOK ,'x' ,'X' },
218: {'Y' , CAPLOK ,'y' ,'Y' },
219: {'Z' , CAPLOK ,'z' ,'Z' },
220: {VK_OEM_3 , CAPLOK ,0xf6 ,0xd6 },
221: {VK_OEM_5 , 0 ,WCH_DEAD ,0xb0 },
222: { 0xff , CAPLOK ,'^' ,WCH_NONE },
223: {VK_OEM_6 , 0 ,WCH_DEAD ,WCH_DEAD },
224: { 0xff , CAPLOK ,0xb4 ,0x60 }, // Acute, Grave
225: {VK_OEM_7 , CAPLOK ,0xe4 ,0xc4 },
226: {VK_OEM_8 , 0 ,WCH_NONE ,WCH_NONE },
227: {VK_OEM_COMMA , CAPLOK ,',' ,';' },
228: {VK_OEM_PERIOD, CAPLOK ,'.' ,':' },
229: {VK_TAB , 0 ,'\t' ,'\t' },
230: {VK_ADD , 0 ,'+' ,'+' }, // Jun-03-92
231: {VK_DECIMAL , 0 ,',' ,',' },
232: {VK_DIVIDE , 0 ,'/' ,'/' },
233: {VK_MULTIPLY , 0 ,'*' ,'*' },
234: {VK_SUBTRACT , CAPLOK ,'-' ,'-' },
235: {0 , 0 ,0 ,0 }
236: };
237:
238: static VK_TO_WCHARS3 aVkToWch3[] = {
239: // | | SHIFT | CTRL+ALT |
240: // | |==========|===========|
241: {'0' , CAPLOK ,'0' ,'=' , '}' },
242: {'3' , CAPLOK ,'3' ,0xa7 , 0xb3 },
243: {'7' , CAPLOK ,'7' ,'/' , '{' },
244: {'8' , CAPLOK ,'8' ,'(' , '[' },
245: {'9' , CAPLOK ,'9' ,')' , ']' },
246: {'M' , CAPLOK ,'m' ,'M' , 0xb5 },
247: {'Q' , CAPLOK ,'q' ,'Q' , '@' },
248: {VK_OEM_102 , 0 ,'<' ,'>' , '|' },
249: {VK_OEM_4 , CAPLOK ,0xdf ,'?' , '\\' },
250: {0 , 0 ,0 ,0 , 0 }
251: };
252:
253: static VK_TO_WCHARS4 aVkToWch4[] = {
254: // | | SHIFT | CTRL+ALT | CONTROL |
255: // | |==========|===========|===========|
256: {VK_BACK , 0 ,'\b' ,'\b' , WCH_NONE , 0x7f },
257: {VK_CANCEL , 0 ,0x03 ,0x03 , WCH_NONE , 0x03 },
258: {VK_ESCAPE , 0 ,0x1b ,0x1b , WCH_NONE , 0x1b },
259: {VK_OEM_1 , CAPLOK ,0xfc ,0xdc , WCH_NONE , 0x1b },
260: {VK_OEM_2 , CAPLOK ,'#' ,0x27 , WCH_NONE , 0x1c },
261: {VK_OEM_PLUS , CAPLOK ,'+' ,'*' , '~' , 0x1d },
262: {VK_RETURN , 0 ,'\r' ,'\r' , WCH_NONE , '\n' },
263: {VK_SPACE , 0 ,' ' ,' ' , WCH_NONE , 0x20 },
264: {0 , 0 ,0 ,0 , 0 , 0 }
265: };
266:
267: static VK_TO_WCHARS5 aVkToWch5[] = {
268: // | | SHIFT | CTRL+ALT | CONTROL | SHFT+CTRL |
269: // | |========|===========|===========|===========|
270: {'2' , CAPLOK ,'2' ,'"' , 0xb2 , WCH_NONE , 0x00 },
271: {'6' , CAPLOK ,'6' ,'&' , WCH_NONE , WCH_NONE , 0x1e },
272: {VK_OEM_MINUS , 0 ,'-' ,'_' , WCH_NONE , WCH_NONE , 0x1f },
273: {0 , 0 ,0 ,0 , 0 , 0 , 0 }
274: };
275:
276: static VK_TO_WCHARS1 aVkToWch1[] = {
277: { VK_NUMPAD0 , 0 , '0' },
278: { VK_NUMPAD1 , 0 , '1' },
279: { VK_NUMPAD2 , 0 , '2' },
280: { VK_NUMPAD3 , 0 , '3' },
281: { VK_NUMPAD4 , 0 , '4' },
282: { VK_NUMPAD5 , 0 , '5' },
283: { VK_NUMPAD6 , 0 , '6' },
284: { VK_NUMPAD7 , 0 , '7' },
285: { VK_NUMPAD8 , 0 , '8' },
286: { VK_NUMPAD9 , 0 , '9' },
287: { 0 , 0 , '\0' } //null terminator
288: };
289:
290: /***************************************************************************\
291: * aVkToWcharTable: table of pointers to Character Tables
292: *
293: * Describes the character tables and the order they should be searched.
294: *
295: * Note: the order determines the behavior of VkKeyScan() : this function
296: * takes a character and attempts to find a Virtual Key and character-
297: * modifier key combination that produces that character. The table
298: * containing the numeric keypad (aVkToWch1) must appear last so that
299: * VkKeyScan('0') will be interpreted as one of keys from the main
300: * section, not the numpad. etc.
301: \***************************************************************************/
302:
303: static VK_TO_WCHAR_TABLE aVkToWcharTable[] = {
304: { (PVK_TO_WCHARS1)aVkToWch3, 3, sizeof(aVkToWch3[0]) },
305: { (PVK_TO_WCHARS1)aVkToWch4, 4, sizeof(aVkToWch4[0]) },
306: { (PVK_TO_WCHARS1)aVkToWch5, 5, sizeof(aVkToWch5[0]) },
307: { (PVK_TO_WCHARS1)aVkToWch2, 2, sizeof(aVkToWch2[0]) },
308: { (PVK_TO_WCHARS1)aVkToWch1, 1, sizeof(aVkToWch1[0]) }, // must come last
309: { NULL, 0, 0 }
310: };
311:
312: /***************************************************************************\
313: * aKeyNames[], aKeyNamesExt[] - Scan Code -> Key Name tables
314: *
315: * For the GetKeyNameText() API function
316: *
317: * Tables for non-extended and extended (KBDEXT) keys.
318: * (Keys producing printable characters are named by the character itself)
319: \***************************************************************************/
320:
321: static VSC_LPWSTR aKeyNames[] = {
322: 0x01, L"ESC",
323: 0x0e, L"R\xDC" L"CK",
324: 0x0f, L"TABULATOR",
325: 0x1c, L"EINGABE",
326: 0x1d, L"STRG",
327: 0x2a, L"UMSCHALT",
328: 0x36, L"UMSCHALT RECHTS",
329: 0x37, L" (ZEHNERTASTATUR)",
330: 0x38, L"ALT",
331: 0x39, L"LEER",
332: 0x3a, L"FESTSTELL",
333: 0x3b, L"F1",
334: 0x3c, L"F2",
335: 0x3d, L"F3",
336: 0x3e, L"F4",
337: 0x3f, L"F5",
338: 0x40, L"F6",
339: 0x41, L"F7",
340: 0x42, L"F8",
341: 0x43, L"F9",
342: 0x44, L"F10",
343: 0x45, L"PAUSE",
344: 0x46, L"ROLLEN-FESTSTELL",
345: 0x47, L"7 (ZEHNERTASTATUR)",
346: 0x48, L"8 (ZEHNERTASTATUR)",
347: 0x49, L"9 (ZEHNERTASTATUR)",
348: 0x4a, L"- (ZEHNERTASTATUR)",
349: 0x4b, L"4 (ZEHNERTASTATUR)",
350: 0x4c, L"5 (ZEHNERTASTATUR)",
351: 0x4d, L"6 (ZEHNERTASTATUR)",
352: 0x4e, L"+ (ZEHNERTASTATUR)",
353: 0x4f, L"1 (ZEHNERTASTATUR)",
354: 0x50, L"2 (ZEHNERTASTATUR)",
355: 0x51, L"3 (ZEHNERTASTATUR)",
356: 0x52, L"0 (ZEHNERTASTATUR)",
357: 0x53, L"KOMMA (ZEHNERTASTATUR)",
358: 0x57, L"F11",
359: 0x58, L"F12",
360: 0 , NULL
361: };
362:
363: static VSC_LPWSTR aKeyNamesExt[] = {
364: 0x1c, L"EINGABE (ZEHNERTASTATUR)",
365: 0x1d, L"STRG-RECHTS",
366: 0x35, L" (ZEHNERTASTATUR)",
367: 0x37, L"DRUCK",
368: 0x38, L"ALT GR",
369: 0x45, L"NUM-FESTSTELL",
370: 0x46, L"UNTBR", // ICO Break
371: 0x47, L"POS1",
372: 0x48, L"NACH-OBEN",
373: 0x49, L"BILD-NACH-OBEN",
374: 0x4b, L"NACH-LINKS",
375: 0x4d, L"NACH-RECHTS",
376: 0x4f, L"ENDE",
377: 0x50, L"NACH-UNTEN",
378: 0x51, L"BILD-NACH-UNTEN",
379: 0x52, L"EINFG",
380: 0x53, L"ENTF",
381: 0x54, L"<00>", // ICO 00
382: 0x56, L"HILFE", // ICO Help
383: 0x5c, L"L\x00D6SCH", // ICO Clear
384: 0 , NULL
385: };
386:
387: static LPWSTR aKeyNamesDead[] = {
388: L"\x00B4" L"AKUT",
389: L"`" L"GRAVIS",
390: L"^" L"ZIRKUMFLEX",
391: NULL
392: };
393:
394: static DEADKEY aDeadKey[] = {
395: DEADTRANS(L'a', L'`', 0x00E0), // GRAVE
396: DEADTRANS(L'e', L'`', 0x00E8),
397: DEADTRANS(L'i', L'`', 0x00EC),
398: DEADTRANS(L'o', L'`', 0x00F2),
399: DEADTRANS(L'u', L'`', 0x00F9),
400: DEADTRANS(L'A', L'`', 0x00C0),
401: DEADTRANS(L'E', L'`', 0x00C8),
402: DEADTRANS(L'I', L'`', 0x00CC),
403: DEADTRANS(L'O', L'`', 0x00D2),
404: DEADTRANS(L'U', L'`', 0x00D9),
405: DEADTRANS(L' ', L'`', L'`' ),
406:
407: DEADTRANS(L'a', 0x00B4, 0x00E1), // ACUTE
408: DEADTRANS(L'e', 0x00B4, 0x00E9),
409: DEADTRANS(L'i', 0x00B4, 0x00ED),
410: DEADTRANS(L'o', 0x00B4, 0x00F3),
411: DEADTRANS(L'u', 0x00B4, 0x00FA),
412: DEADTRANS(L'y', 0x00B4, 0x00FD),
413: DEADTRANS(L'A', 0x00B4, 0x00C1),
414: DEADTRANS(L'E', 0x00B4, 0x00C9),
415: DEADTRANS(L'I', 0x00B4, 0x00CD),
416: DEADTRANS(L'O', 0x00B4, 0x00D3),
417: DEADTRANS(L'U', 0x00B4, 0x00DA),
418: DEADTRANS(L'Y', 0x00B4, 0x00DD),
419: DEADTRANS(L' ', 0x00B4, 0x00B4),
420:
421: DEADTRANS(L'a', L'^', 0x00E2), // CIRCUMFLEX
422: DEADTRANS(L'e', L'^', 0x00EA),
423: DEADTRANS(L'i', L'^', 0x00EE),
424: DEADTRANS(L'o', L'^', 0x00F4),
425: DEADTRANS(L'u', L'^', 0x00FB),
426: DEADTRANS(L'A', L'^', 0x00C2),
427: DEADTRANS(L'E', L'^', 0x00CA),
428: DEADTRANS(L'I', L'^', 0x00CE),
429: DEADTRANS(L'O', L'^', 0x00D4),
430: DEADTRANS(L'U', L'^', 0x00DB),
431: DEADTRANS(L' ', L'^', L'^' ),
432: 0, 0
433: };
434:
435: /***************************************************************************\
436: * Structure describing all tables for the layout, plus some additional flags.
437: *
438: \***************************************************************************/
439:
440: static KBDTABLES KbdTables = {
441: /*
442: * Modifier keys
443: */
444: &CharModifiers,
445:
446: /*
447: * Characters tables
448: */
449: aVkToWcharTable,
450:
451: /*
452: * Diacritics
453: */
454: aDeadKey,
455:
456: /*
457: * Names of Keys
458: */
459: aKeyNames,
460: aKeyNamesExt,
461: aKeyNamesDead,
462:
463: /*
464: * Scan codes to Virtual Keys
465: */
466: ausVK,
467: sizeof(ausVK) / sizeof(ausVK[0]),
468: aE0VscToVk,
469: aE1VscToVk,
470:
471: /*
472: * layout-specific flags
473: */
474: KLLF_ALTGR // Windows must convert AltGr key to Ctrl+Alt
475: };
476:
477: /*
478: * Returns the address of the layout's KbdTables struct
479: * Must be exported.
480: */
481: PKBDTABLES KbdLayerDescriptor(VOID)
482: {
483: return &KbdTables;
484: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.