?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
riched20: Move underline drawing to a common function.
[wine.git] / dlls / winemac.drv / keyboard.c
blob7b773e3347f3ee5cca3681358d3e2bab7e1f0cfc
1 /*
2 * MACDRV 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 * Copyright 1999 Ove Kåven
10 * Copyright 2011, 2012, 2013 Ken Thomases for CodeWeavers Inc.
11 *
12 * This library is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU Lesser General Public
14 * License as published by the Free Software Foundation; either
15 * version 2.1 of the License, or (at your option) any later version.
16 *
17 * This library is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20 * Lesser General Public License for more details.
21 *
22 * You should have received a copy of the GNU Lesser General Public
23 * License along with this library; if not, write to the Free Software
24 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
25 */
26
27 #include "config.h"
28
29 #include "macdrv.h"
30 #include "winuser.h"
31 #include "wine/unicode.h"
32
33 WINE_DEFAULT_DEBUG_CHANNEL(keyboard);
34 WINE_DECLARE_DEBUG_CHANNEL(key);
35
36
37 /* Carbon-style modifier mask definitions from <Carbon/HIToolbox/Events.h>. */
38 enum {
39 cmdKeyBit = 8,
40 shiftKeyBit = 9,
41 alphaLockBit = 10,
42 optionKeyBit = 11,
43 controlKeyBit = 12,
44 };
45
46 enum {
47 cmdKey = 1 << cmdKeyBit,
48 shiftKey = 1 << shiftKeyBit,
49 alphaLock = 1 << alphaLockBit,
50 optionKey = 1 << optionKeyBit,
51 controlKey = 1 << controlKeyBit,
52 };
53
54
55 /* Mac virtual key code definitions from <Carbon/HIToolbox/Events.h>. */
56 enum {
57 kVK_ANSI_A = 0x00,
58 kVK_ANSI_S = 0x01,
59 kVK_ANSI_D = 0x02,
60 kVK_ANSI_F = 0x03,
61 kVK_ANSI_H = 0x04,
62 kVK_ANSI_G = 0x05,
63 kVK_ANSI_Z = 0x06,
64 kVK_ANSI_X = 0x07,
65 kVK_ANSI_C = 0x08,
66 kVK_ANSI_V = 0x09,
67 kVK_ISO_Section = 0x0A,
68 kVK_ANSI_B = 0x0B,
69 kVK_ANSI_Q = 0x0C,
70 kVK_ANSI_W = 0x0D,
71 kVK_ANSI_E = 0x0E,
72 kVK_ANSI_R = 0x0F,
73 kVK_ANSI_Y = 0x10,
74 kVK_ANSI_T = 0x11,
75 kVK_ANSI_1 = 0x12,
76 kVK_ANSI_2 = 0x13,
77 kVK_ANSI_3 = 0x14,
78 kVK_ANSI_4 = 0x15,
79 kVK_ANSI_6 = 0x16,
80 kVK_ANSI_5 = 0x17,
81 kVK_ANSI_Equal = 0x18,
82 kVK_ANSI_9 = 0x19,
83 kVK_ANSI_7 = 0x1A,
84 kVK_ANSI_Minus = 0x1B,
85 kVK_ANSI_8 = 0x1C,
86 kVK_ANSI_0 = 0x1D,
87 kVK_ANSI_RightBracket = 0x1E,
88 kVK_ANSI_O = 0x1F,
89 kVK_ANSI_U = 0x20,
90 kVK_ANSI_LeftBracket = 0x21,
91 kVK_ANSI_I = 0x22,
92 kVK_ANSI_P = 0x23,
93 kVK_Return = 0x24,
94 kVK_ANSI_L = 0x25,
95 kVK_ANSI_J = 0x26,
96 kVK_ANSI_Quote = 0x27,
97 kVK_ANSI_K = 0x28,
98 kVK_ANSI_Semicolon = 0x29,
99 kVK_ANSI_Backslash = 0x2A,
100 kVK_ANSI_Comma = 0x2B,
101 kVK_ANSI_Slash = 0x2C,
102 kVK_ANSI_N = 0x2D,
103 kVK_ANSI_M = 0x2E,
104 kVK_ANSI_Period = 0x2F,
105 kVK_Tab = 0x30,
106 kVK_Space = 0x31,
107 kVK_ANSI_Grave = 0x32,
108 kVK_Delete = 0x33,
109 kVK_Escape = 0x35,
110 kVK_RightCommand = 0x36, /* invented for Wine; co-opt unused key code */
111 kVK_Command = 0x37,
112 kVK_Shift = 0x38,
113 kVK_CapsLock = 0x39,
114 kVK_Option = 0x3A,
115 kVK_Control = 0x3B,
116 kVK_RightShift = 0x3C,
117 kVK_RightOption = 0x3D,
118 kVK_RightControl = 0x3E,
119 kVK_Function = 0x3F,
120 kVK_F17 = 0x40,
121 kVK_ANSI_KeypadDecimal = 0x41,
122 kVK_ANSI_KeypadMultiply = 0x43,
123 kVK_ANSI_KeypadPlus = 0x45,
124 kVK_ANSI_KeypadClear = 0x47,
125 kVK_VolumeUp = 0x48,
126 kVK_VolumeDown = 0x49,
127 kVK_Mute = 0x4A,
128 kVK_ANSI_KeypadDivide = 0x4B,
129 kVK_ANSI_KeypadEnter = 0x4C,
130 kVK_ANSI_KeypadMinus = 0x4E,
131 kVK_F18 = 0x4F,
132 kVK_F19 = 0x50,
133 kVK_ANSI_KeypadEquals = 0x51,
134 kVK_ANSI_Keypad0 = 0x52,
135 kVK_ANSI_Keypad1 = 0x53,
136 kVK_ANSI_Keypad2 = 0x54,
137 kVK_ANSI_Keypad3 = 0x55,
138 kVK_ANSI_Keypad4 = 0x56,
139 kVK_ANSI_Keypad5 = 0x57,
140 kVK_ANSI_Keypad6 = 0x58,
141 kVK_ANSI_Keypad7 = 0x59,
142 kVK_F20 = 0x5A,
143 kVK_ANSI_Keypad8 = 0x5B,
144 kVK_ANSI_Keypad9 = 0x5C,
145 kVK_JIS_Yen = 0x5D,
146 kVK_JIS_Underscore = 0x5E,
147 kVK_JIS_KeypadComma = 0x5F,
148 kVK_F5 = 0x60,
149 kVK_F6 = 0x61,
150 kVK_F7 = 0x62,
151 kVK_F3 = 0x63,
152 kVK_F8 = 0x64,
153 kVK_F9 = 0x65,
154 kVK_JIS_Eisu = 0x66,
155 kVK_F11 = 0x67,
156 kVK_JIS_Kana = 0x68,
157 kVK_F13 = 0x69,
158 kVK_F16 = 0x6A,
159 kVK_F14 = 0x6B,
160 kVK_F10 = 0x6D,
161 kVK_F12 = 0x6F,
162 kVK_F15 = 0x71,
163 kVK_Help = 0x72,
164 kVK_Home = 0x73,
165 kVK_PageUp = 0x74,
166 kVK_ForwardDelete = 0x75,
167 kVK_F4 = 0x76,
168 kVK_End = 0x77,
169 kVK_F2 = 0x78,
170 kVK_PageDown = 0x79,
171 kVK_F1 = 0x7A,
172 kVK_LeftArrow = 0x7B,
173 kVK_RightArrow = 0x7C,
174 kVK_DownArrow = 0x7D,
175 kVK_UpArrow = 0x7E,
176 };
177
178
179 /* Indexed by Mac virtual keycode values defined above. */
180 static const struct {
181 WORD vkey;
182 WORD scan;
183 BOOL fixed;
184 } default_map[128] = {
185 { 'A', 0x1E, FALSE }, /* kVK_ANSI_A */
186 { 'S', 0x1F, FALSE }, /* kVK_ANSI_S */
187 { 'D', 0x20, FALSE }, /* kVK_ANSI_D */
188 { 'F', 0x21, FALSE }, /* kVK_ANSI_F */
189 { 'H', 0x23, FALSE }, /* kVK_ANSI_H */
190 { 'G', 0x22, FALSE }, /* kVK_ANSI_G */
191 { 'Z', 0x2C, FALSE }, /* kVK_ANSI_Z */
192 { 'X', 0x2D, FALSE }, /* kVK_ANSI_X */
193 { 'C', 0x2E, FALSE }, /* kVK_ANSI_C */
194 { 'V', 0x2F, FALSE }, /* kVK_ANSI_V */
195 { VK_OEM_102, 0x56, TRUE }, /* kVK_ISO_Section */
196 { 'B', 0x30, FALSE }, /* kVK_ANSI_B */
197 { 'Q', 0x10, FALSE }, /* kVK_ANSI_Q */
198 { 'W', 0x11, FALSE }, /* kVK_ANSI_W */
199 { 'E', 0x12, FALSE }, /* kVK_ANSI_E */
200 { 'R', 0x13, FALSE }, /* kVK_ANSI_R */
201 { 'Y', 0x15, FALSE }, /* kVK_ANSI_Y */
202 { 'T', 0x14, FALSE }, /* kVK_ANSI_T */
203 { '1', 0x02, FALSE }, /* kVK_ANSI_1 */
204 { '2', 0x03, FALSE }, /* kVK_ANSI_2 */
205 { '3', 0x04, FALSE }, /* kVK_ANSI_3 */
206 { '4', 0x05, FALSE }, /* kVK_ANSI_4 */
207 { '6', 0x07, FALSE }, /* kVK_ANSI_6 */
208 { '5', 0x06, FALSE }, /* kVK_ANSI_5 */
209 { VK_OEM_PLUS, 0x0D, FALSE }, /* kVK_ANSI_Equal */
210 { '9', 0x0A, FALSE }, /* kVK_ANSI_9 */
211 { '7', 0x08, FALSE }, /* kVK_ANSI_7 */
212 { VK_OEM_MINUS, 0x0C, FALSE }, /* kVK_ANSI_Minus */
213 { '8', 0x09, FALSE }, /* kVK_ANSI_8 */
214 { '0', 0x0B, FALSE }, /* kVK_ANSI_0 */
215 { VK_OEM_6, 0x1B, FALSE }, /* kVK_ANSI_RightBracket */
216 { 'O', 0x18, FALSE }, /* kVK_ANSI_O */
217 { 'U', 0x16, FALSE }, /* kVK_ANSI_U */
218 { VK_OEM_4, 0x1A, FALSE }, /* kVK_ANSI_LeftBracket */
219 { 'I', 0x17, FALSE }, /* kVK_ANSI_I */
220 { 'P', 0x19, FALSE }, /* kVK_ANSI_P */
221 { VK_RETURN, 0x1C, TRUE }, /* kVK_Return */
222 { 'L', 0x26, FALSE }, /* kVK_ANSI_L */
223 { 'J', 0x24, FALSE }, /* kVK_ANSI_J */
224 { VK_OEM_7, 0x28, FALSE }, /* kVK_ANSI_Quote */
225 { 'K', 0x25, FALSE }, /* kVK_ANSI_K */
226 { VK_OEM_1, 0x27, FALSE }, /* kVK_ANSI_Semicolon */
227 { VK_OEM_5, 0x2B, FALSE }, /* kVK_ANSI_Backslash */
228 { VK_OEM_COMMA, 0x33, FALSE }, /* kVK_ANSI_Comma */
229 { VK_OEM_2, 0x35, FALSE }, /* kVK_ANSI_Slash */
230 { 'N', 0x31, FALSE }, /* kVK_ANSI_N */
231 { 'M', 0x32, FALSE }, /* kVK_ANSI_M */
232 { VK_OEM_PERIOD, 0x34, FALSE }, /* kVK_ANSI_Period */
233 { VK_TAB, 0x0F, TRUE }, /* kVK_Tab */
234 { VK_SPACE, 0x39, TRUE }, /* kVK_Space */
235 { VK_OEM_3, 0x29, FALSE }, /* kVK_ANSI_Grave */
236 { VK_BACK, 0x0E, TRUE }, /* kVK_Delete */
237 { 0, 0, FALSE }, /* 0x34 unused */
238 { VK_ESCAPE, 0x01, TRUE }, /* kVK_Escape */
239 { VK_RMENU, 0x38 | 0x100, TRUE }, /* kVK_RightCommand */
240 { VK_LMENU, 0x38, TRUE }, /* kVK_Command */
241 { VK_LSHIFT, 0x2A, TRUE }, /* kVK_Shift */
242 { VK_CAPITAL, 0x3A, TRUE }, /* kVK_CapsLock */
243 { 0, 0, FALSE }, /* kVK_Option */
244 { VK_LCONTROL, 0x1D, TRUE }, /* kVK_Control */
245 { VK_RSHIFT, 0x36, TRUE }, /* kVK_RightShift */
246 { 0, 0, FALSE }, /* kVK_RightOption */
247 { VK_RCONTROL, 0x1D | 0x100, TRUE }, /* kVK_RightControl */
248 { 0, 0, FALSE }, /* kVK_Function */
249 { VK_F17, 0x68, TRUE }, /* kVK_F17 */
250 { VK_DECIMAL, 0x53, TRUE }, /* kVK_ANSI_KeypadDecimal */
251 { 0, 0, FALSE }, /* 0x42 unused */
252 { VK_MULTIPLY, 0x37, TRUE }, /* kVK_ANSI_KeypadMultiply */
253 { 0, 0, FALSE }, /* 0x44 unused */
254 { VK_ADD, 0x4E, TRUE }, /* kVK_ANSI_KeypadPlus */
255 { 0, 0, FALSE }, /* 0x46 unused */
256 { VK_OEM_CLEAR, 0x59, TRUE }, /* kVK_ANSI_KeypadClear */
257 { VK_VOLUME_UP, 0 | 0x100, TRUE }, /* kVK_VolumeUp */
258 { VK_VOLUME_DOWN, 0 | 0x100, TRUE }, /* kVK_VolumeDown */
259 { VK_VOLUME_MUTE, 0 | 0x100, TRUE }, /* kVK_Mute */
260 { VK_DIVIDE, 0x35 | 0x100, TRUE }, /* kVK_ANSI_KeypadDivide */
261 { VK_RETURN, 0x1C | 0x100, TRUE }, /* kVK_ANSI_KeypadEnter */
262 { 0, 0, FALSE }, /* 0x4D unused */
263 { VK_SUBTRACT, 0x4A, TRUE }, /* kVK_ANSI_KeypadMinus */
264 { VK_F18, 0x69, TRUE }, /* kVK_F18 */
265 { VK_F19, 0x6A, TRUE }, /* kVK_F19 */
266 { VK_OEM_NEC_EQUAL, 0x0D | 0x100, TRUE }, /* kVK_ANSI_KeypadEquals */
267 { VK_NUMPAD0, 0x52, TRUE }, /* kVK_ANSI_Keypad0 */
268 { VK_NUMPAD1, 0x4F, TRUE }, /* kVK_ANSI_Keypad1 */
269 { VK_NUMPAD2, 0x50, TRUE }, /* kVK_ANSI_Keypad2 */
270 { VK_NUMPAD3, 0x51, TRUE }, /* kVK_ANSI_Keypad3 */
271 { VK_NUMPAD4, 0x4B, TRUE }, /* kVK_ANSI_Keypad4 */
272 { VK_NUMPAD5, 0x4C, TRUE }, /* kVK_ANSI_Keypad5 */
273 { VK_NUMPAD6, 0x4D, TRUE }, /* kVK_ANSI_Keypad6 */
274 { VK_NUMPAD7, 0x47, TRUE }, /* kVK_ANSI_Keypad7 */
275 { VK_F20, 0x6B, TRUE }, /* kVK_F20 */
276 { VK_NUMPAD8, 0x48, TRUE }, /* kVK_ANSI_Keypad8 */
277 { VK_NUMPAD9, 0x49, TRUE }, /* kVK_ANSI_Keypad9 */
278 { 0xFF, 0x7D, TRUE }, /* kVK_JIS_Yen */
279 { 0xC1, 0x73, TRUE }, /* kVK_JIS_Underscore */
280 { VK_SEPARATOR, 0x7E, TRUE }, /* kVK_JIS_KeypadComma */
281 { VK_F5, 0x3F, TRUE }, /* kVK_F5 */
282 { VK_F6, 0x40, TRUE }, /* kVK_F6 */
283 { VK_F7, 0x41, TRUE }, /* kVK_F7 */
284 { VK_F3, 0x3D, TRUE }, /* kVK_F3 */
285 { VK_F8, 0x42, TRUE }, /* kVK_F8 */
286 { VK_F9, 0x43, TRUE }, /* kVK_F9 */
287 { 0xFF, 0x72, TRUE }, /* kVK_JIS_Eisu */
288 { VK_F11, 0x57, TRUE }, /* kVK_F11 */
289 { VK_OEM_RESET, 0x71, TRUE }, /* kVK_JIS_Kana */
290 { VK_F13, 0x64, TRUE }, /* kVK_F13 */
291 { VK_F16, 0x67, TRUE }, /* kVK_F16 */
292 { VK_F14, 0x65, TRUE }, /* kVK_F14 */
293 { 0, 0, FALSE }, /* 0x6C unused */
294 { VK_F10, 0x44, TRUE }, /* kVK_F10 */
295 { 0, 0, FALSE }, /* 0x6E unused */
296 { VK_F12, 0x58, TRUE }, /* kVK_F12 */
297 { 0, 0, FALSE }, /* 0x70 unused */
298 { VK_F15, 0x66, TRUE }, /* kVK_F15 */
299 { VK_INSERT, 0x52 | 0x100, TRUE }, /* kVK_Help */ /* map to Insert */
300 { VK_HOME, 0x47 | 0x100, TRUE }, /* kVK_Home */
301 { VK_PRIOR, 0x49 | 0x100, TRUE }, /* kVK_PageUp */
302 { VK_DELETE, 0x53 | 0x100, TRUE }, /* kVK_ForwardDelete */
303 { VK_F4, 0x3E, TRUE }, /* kVK_F4 */
304 { VK_END, 0x4F | 0x100, TRUE }, /* kVK_End */
305 { VK_F2, 0x3C, TRUE }, /* kVK_F2 */
306 { VK_NEXT, 0x51 | 0x100, TRUE }, /* kVK_PageDown */
307 { VK_F1, 0x3B, TRUE }, /* kVK_F1 */
308 { VK_LEFT, 0x4B | 0x100, TRUE }, /* kVK_LeftArrow */
309 { VK_RIGHT, 0x4D | 0x100, TRUE }, /* kVK_RightArrow */
310 { VK_DOWN, 0x50 | 0x100, TRUE }, /* kVK_DownArrow */
311 { VK_UP, 0x48 | 0x100, TRUE }, /* kVK_UpArrow */
312 };
313
314
315 static const struct {
316 DWORD vkey;
317 const char *name;
318 } vkey_names[] = {
319 { VK_ADD, "Num +" },
320 { VK_BACK, "Backspace" },
321 { VK_CAPITAL, "Caps Lock" },
322 { VK_CONTROL, "Ctrl" },
323 { VK_DECIMAL, "Num Del" },
324 { VK_DELETE | 0x100, "Delete" },
325 { VK_DIVIDE | 0x100, "Num /" },
326 { VK_DOWN | 0x100, "Down" },
327 { VK_END | 0x100, "End" },
328 { VK_ESCAPE, "Esc" },
329 { VK_F1, "F1" },
330 { VK_F2, "F2" },
331 { VK_F3, "F3" },
332 { VK_F4, "F4" },
333 { VK_F5, "F5" },
334 { VK_F6, "F6" },
335 { VK_F7, "F7" },
336 { VK_F8, "F8" },
337 { VK_F9, "F9" },
338 { VK_F10, "F10" },
339 { VK_F11, "F11" },
340 { VK_F12, "F12" },
341 { VK_F13, "F13" },
342 { VK_F14, "F14" },
343 { VK_F15, "F15" },
344 { VK_F16, "F16" },
345 { VK_F17, "F17" },
346 { VK_F18, "F18" },
347 { VK_F19, "F19" },
348 { VK_F20, "F20" },
349 { VK_F21, "F21" },
350 { VK_F22, "F22" },
351 { VK_F23, "F23" },
352 { VK_F24, "F24" },
353 { VK_HELP | 0x100, "Help" },
354 { VK_HOME | 0x100, "Home" },
355 { VK_INSERT | 0x100, "Insert" },
356 { VK_LCONTROL, "Ctrl" },
357 { VK_LEFT | 0x100, "Left" },
358 { VK_LMENU, "Alt" },
359 { VK_LSHIFT, "Shift" },
360 { VK_LWIN | 0x100, "Win" },
361 { VK_MENU, "Alt" },
362 { VK_MULTIPLY, "Num *" },
363 { VK_NEXT | 0x100, "Page Down" },
364 { VK_NUMLOCK | 0x100, "Num Lock" },
365 { VK_NUMPAD0, "Num 0" },
366 { VK_NUMPAD1, "Num 1" },
367 { VK_NUMPAD2, "Num 2" },
368 { VK_NUMPAD3, "Num 3" },
369 { VK_NUMPAD4, "Num 4" },
370 { VK_NUMPAD5, "Num 5" },
371 { VK_NUMPAD6, "Num 6" },
372 { VK_NUMPAD7, "Num 7" },
373 { VK_NUMPAD8, "Num 8" },
374 { VK_NUMPAD9, "Num 9" },
375 { VK_OEM_CLEAR, "Num Clear" },
376 { VK_OEM_NEC_EQUAL | 0x100, "Num =" },
377 { VK_PRIOR | 0x100, "Page Up" },
378 { VK_RCONTROL | 0x100, "Right Ctrl" },
379 { VK_RETURN, "Return" },
380 { VK_RETURN | 0x100, "Num Enter" },
381 { VK_RIGHT | 0x100, "Right" },
382 { VK_RMENU | 0x100, "Right Alt" },
383 { VK_RSHIFT, "Right Shift" },
384 { VK_RWIN | 0x100, "Right Win" },
385 { VK_SEPARATOR, "Num ," },
386 { VK_SHIFT, "Shift" },
387 { VK_SPACE, "Space" },
388 { VK_SUBTRACT, "Num -" },
389 { VK_TAB, "Tab" },
390 { VK_UP | 0x100, "Up" },
391 { VK_VOLUME_DOWN | 0x100, "Volume Down" },
392 { VK_VOLUME_MUTE | 0x100, "Mute" },
393 { VK_VOLUME_UP | 0x100, "Volume Up" },
394 };
395
396
397 static BOOL char_matches_string(WCHAR wchar, UniChar *string, BOOL ignore_diacritics)
398 {
399 BOOL ret;
400 CFStringRef s1 = CFStringCreateWithCharactersNoCopy(NULL, (UniChar*)&wchar, 1, kCFAllocatorNull);
401 CFStringRef s2 = CFStringCreateWithCharactersNoCopy(NULL, string, strlenW(string), kCFAllocatorNull);
402 CFStringCompareFlags flags = kCFCompareCaseInsensitive | kCFCompareNonliteral | kCFCompareWidthInsensitive;
403 if (ignore_diacritics)
404 flags |= kCFCompareDiacriticInsensitive;
405 ret = (CFStringCompare(s1, s2, flags) == kCFCompareEqualTo);
406 CFRelease(s1);
407 CFRelease(s2);
408 return ret;
409 }
410
411
412 /* Filter Apple-specific private-use characters (see NSEvent.h) out of a
413 * string. Returns the length of the string after stripping. */
414 static int strip_apple_private_chars(LPWSTR bufW, int len)
415 {
416 int i;
417 for (i = 0; i < len; )
418 {
419 if (0xF700 <= bufW[i] && bufW[i] <= 0xF8FF)
420 {
421 memmove(&bufW[i], &bufW[i+1], (len - i - 1) * sizeof(bufW[0]));
422 len--;
423 }
424 else
425 i++;
426 }
427 return len;
428 }
429
430
431 /***********************************************************************
432 * macdrv_compute_keyboard_layout
433 */
434 void macdrv_compute_keyboard_layout(struct macdrv_thread_data *thread_data)
435 {
436 int keyc;
437 WCHAR vkey;
438 const UCKeyboardLayout *uchr;
439 const UInt32 modifier_combos[] = {
440 0,
441 shiftKey >> 8,
442 cmdKey >> 8,
443 (shiftKey | cmdKey) >> 8,
444 optionKey >> 8,
445 (shiftKey | optionKey) >> 8,
446 };
447 UniChar map[128][sizeof(modifier_combos) / sizeof(modifier_combos[0])][4 + 1];
448 int combo;
449 BYTE vkey_used[256];
450 int ignore_diacritics;
451 static const struct {
452 WCHAR wchar;
453 DWORD vkey;
454 } symbol_vkeys[] = {
455 { '-', VK_OEM_MINUS },
456 { '+', VK_OEM_PLUS },
457 { '_', VK_OEM_MINUS },
458 { ',', VK_OEM_COMMA },
459 { '.', VK_OEM_PERIOD },
460 { '=', VK_OEM_PLUS },
461 { '>', VK_OEM_PERIOD },
462 { '<', VK_OEM_COMMA },
463 { '|', VK_OEM_5 },
464 { '\\', VK_OEM_5 },
465 { '`', VK_OEM_3 },
466 { '[', VK_OEM_4 },
467 { '~', VK_OEM_3 },
468 { '?', VK_OEM_2 },
469 { ']', VK_OEM_6 },
470 { '/', VK_OEM_2 },
471 { ':', VK_OEM_1 },
472 { '}', VK_OEM_6 },
473 { '{', VK_OEM_4 },
474 { ';', VK_OEM_1 },
475 { '\'', VK_OEM_7 },
476 { ':', VK_OEM_PERIOD },
477 { ';', VK_OEM_COMMA },
478 { '"', VK_OEM_7 },
479 { 0x00B4, VK_OEM_4 }, /* 0x00B4 is ACUTE ACCENT */
480 { '\'', VK_OEM_2 },
481 { 0x00A7, VK_OEM_5 }, /* 0x00A7 is SECTION SIGN */
482 { '*', VK_OEM_PLUS },
483 { 0x00B4, VK_OEM_7 },
484 { '`', VK_OEM_4 },
485 { '[', VK_OEM_6 },
486 { '/', VK_OEM_5 },
487 { '^', VK_OEM_6 },
488 { '*', VK_OEM_2 },
489 { '{', VK_OEM_6 },
490 { '~', VK_OEM_1 },
491 { '?', VK_OEM_PLUS },
492 { '?', VK_OEM_4 },
493 { 0x00B4, VK_OEM_3 },
494 { '?', VK_OEM_COMMA },
495 { '~', VK_OEM_PLUS },
496 { ']', VK_OEM_4 },
497 { '\'', VK_OEM_3 },
498 { 0x00A7, VK_OEM_7 },
499 };
500 int i;
501
502 /* Vkeys that are suitable for assigning to arbitrary keys, organized in
503 contiguous ranges. */
504 static const struct {
505 WORD first, last;
506 } vkey_ranges[] = {
507 { 'A', 'Z' },
508 { '0', '9' },
509 { VK_OEM_1, VK_OEM_3 },
510 { VK_OEM_4, VK_ICO_CLEAR },
511 { 0xe9, 0xf5 },
512 { VK_OEM_NEC_EQUAL, VK_OEM_NEC_EQUAL },
513 { VK_F1, VK_F24 },
514 { 0, 0 }
515 };
516 int vkey_range;
517
518 if (!thread_data->keyboard_layout_uchr)
519 {
520 ERR("no keyboard layout UCHR data\n");
521 return;
522 }
523
524 memset(thread_data->keyc2vkey, 0, sizeof(thread_data->keyc2vkey));
525 memset(vkey_used, 0, sizeof(vkey_used));
526
527 for (keyc = 0; keyc < sizeof(default_map) / sizeof(default_map[0]); keyc++)
528 {
529 thread_data->keyc2scan[keyc] = default_map[keyc].scan;
530 if (default_map[keyc].fixed)
531 {
532 vkey = default_map[keyc].vkey;
533 thread_data->keyc2vkey[keyc] = vkey;
534 vkey_used[vkey] = 1;
535 TRACE("keyc 0x%04x -> vkey 0x%04x (fixed)\n", keyc, vkey);
536 }
537 }
538
539 if (thread_data->iso_keyboard)
540 {
541 /* In almost all cases, the Mac key codes indicate a physical key position
542 and this corresponds nicely to Win32 scan codes. However, the Mac key
543 codes differ in one case between ANSI and ISO keyboards. For ANSI
544 keyboards, the key to the left of the digits and above the Tab key
545 produces key code kVK_ANSI_Grave. For ISO keyboards, the key in that
546 some position produces kVK_ISO_Section. The additional key on ISO
547 keyboards, the one to the right of the left Shift key, produces
548 kVK_ANSI_Grave, which is just weird.
549
550 Since we want the key in that upper left corner to always produce the
551 same scan code (0x29), we need to swap the scan codes of those two
552 Mac key codes for ISO keyboards. */
553 DWORD temp = thread_data->keyc2scan[kVK_ANSI_Grave];
554 thread_data->keyc2scan[kVK_ANSI_Grave] = thread_data->keyc2scan[kVK_ISO_Section];
555 thread_data->keyc2scan[kVK_ISO_Section] = temp;
556 }
557
558 uchr = (const UCKeyboardLayout*)CFDataGetBytePtr(thread_data->keyboard_layout_uchr);
559
560 /* Using the keyboard layout, build a map of key code + modifiers -> characters. */
561 memset(map, 0, sizeof(map));
562 for (keyc = 0; keyc < sizeof(map) / sizeof(map[0]); keyc++)
563 {
564 if (!thread_data->keyc2scan[keyc]) continue; /* not a known Mac key code */
565 if (thread_data->keyc2vkey[keyc]) continue; /* assigned a fixed vkey */
566
567 TRACE("keyc 0x%04x: ", keyc);
568
569 for (combo = 0; combo < sizeof(modifier_combos) / sizeof(modifier_combos[0]); combo++)
570 {
571 UInt32 deadKeyState;
572 UniCharCount len;
573 OSStatus status;
574
575 deadKeyState = 0;
576 status = UCKeyTranslate(uchr, keyc, kUCKeyActionDown, modifier_combos[combo],
577 thread_data->keyboard_type, kUCKeyTranslateNoDeadKeysMask,
578 &deadKeyState, sizeof(map[keyc][combo])/sizeof(map[keyc][combo][0]) - 1,
579 &len, map[keyc][combo]);
580 if (status != noErr)
581 map[keyc][combo][0] = 0;
582
583 TRACE("%s%s", (combo ? ", " : ""), debugstr_w(map[keyc][combo]));
584 }
585
586 TRACE("\n");
587 }
588
589 /* First try to match key codes to the vkeys for the letters A through Z.
590 Try unmodified first, then with various modifier combinations in succession.
591 On the first pass, try to get a match lacking diacritical marks. On the
592 second pass, accept matches with diacritical marks. */
593 for (ignore_diacritics = 0; ignore_diacritics <= 1; ignore_diacritics++)
594 {
595 for (combo = 0; combo < sizeof(modifier_combos) / sizeof(modifier_combos[0]); combo++)
596 {
597 for (vkey = 'A'; vkey <= 'Z'; vkey++)
598 {
599 if (vkey_used[vkey])
600 continue;
601
602 for (keyc = 0; keyc < sizeof(map) / sizeof(map[0]); keyc++)
603 {
604 if (thread_data->keyc2vkey[keyc] || !map[keyc][combo][0])
605 continue;
606
607 if (char_matches_string(vkey, map[keyc][combo], ignore_diacritics))
608 {
609 thread_data->keyc2vkey[keyc] = vkey;
610 vkey_used[vkey] = 1;
611 TRACE("keyc 0x%04x -> vkey 0x%04x (%s match %s)\n", keyc, vkey,
612 debugstr_wn(&vkey, 1), debugstr_w(map[keyc][combo]));
613 break;
614 }
615 }
616 }
617 }
618 }
619
620 /* Next try to match key codes to the vkeys for the digits 0 through 9. */
621 for (combo = 0; combo < sizeof(modifier_combos) / sizeof(modifier_combos[0]); combo++)
622 {
623 for (vkey = '0'; vkey <= '9'; vkey++)
624 {
625 if (vkey_used[vkey])
626 continue;
627
628 for (keyc = 0; keyc < sizeof(map) / sizeof(map[0]); keyc++)
629 {
630 if (thread_data->keyc2vkey[keyc] || !map[keyc][combo][0])
631 continue;
632
633 if (char_matches_string(vkey, map[keyc][combo], FALSE))
634 {
635 thread_data->keyc2vkey[keyc] = vkey;
636 vkey_used[vkey] = 1;
637 TRACE("keyc 0x%04x -> vkey 0x%04x (%s match %s)\n", keyc, vkey,
638 debugstr_wn(&vkey, 1), debugstr_w(map[keyc][combo]));
639 break;
640 }
641 }
642 }
643 }
644
645 /* Now try to match key codes for certain common punctuation characters to
646 the most common OEM vkeys (e.g. '.' to VK_OEM_PERIOD). */
647 for (i = 0; i < sizeof(symbol_vkeys) / sizeof(symbol_vkeys[0]); i++)
648 {
649 vkey = symbol_vkeys[i].vkey;
650
651 if (vkey_used[vkey])
652 continue;
653
654 for (combo = 0; combo < sizeof(modifier_combos) / sizeof(modifier_combos[0]); combo++)
655 {
656 for (keyc = 0; keyc < sizeof(map) / sizeof(map[0]); keyc++)
657 {
658 if (!thread_data->keyc2scan[keyc]) continue; /* not a known Mac key code */
659 if (thread_data->keyc2vkey[keyc] || !map[keyc][combo][0])
660 continue;
661
662 if (char_matches_string(symbol_vkeys[i].wchar, map[keyc][combo], FALSE))
663 {
664 thread_data->keyc2vkey[keyc] = vkey;
665 vkey_used[vkey] = 1;
666 TRACE("keyc 0x%04x -> vkey 0x%04x (%s match %s)\n", keyc, vkey,
667 debugstr_wn(&symbol_vkeys[i].wchar, 1), debugstr_w(map[keyc][combo]));
668 break;
669 }
670 }
671
672 if (vkey_used[vkey])
673 break;
674 }
675 }
676
677 /* For those key codes still without a vkey, try to use the default vkey
678 from the default map, if it's still available. */
679 for (keyc = 0; keyc < sizeof(default_map) / sizeof(default_map[0]); keyc++)
680 {
681 DWORD vkey = default_map[keyc].vkey;
682
683 if (!thread_data->keyc2scan[keyc]) continue; /* not a known Mac key code */
684 if (thread_data->keyc2vkey[keyc]) continue; /* already assigned */
685
686 if (!vkey_used[vkey])
687 {
688 thread_data->keyc2vkey[keyc] = vkey;
689 vkey_used[vkey] = 1;
690 TRACE("keyc 0x%04x -> vkey 0x%04x (default map)\n", keyc, vkey);
691 }
692 }
693
694 /* For any unassigned key codes which would map to a letter in the default
695 map, but whose normal letter vkey wasn't available, try to find a
696 different letter. */
697 vkey = 'A';
698 for (keyc = 0; keyc < sizeof(default_map) / sizeof(default_map[0]); keyc++)
699 {
700 if (default_map[keyc].vkey < 'A' || 'Z' < default_map[keyc].vkey)
701 continue; /* not a letter in ANSI layout */
702 if (!thread_data->keyc2scan[keyc]) continue; /* not a known Mac key code */
703 if (thread_data->keyc2vkey[keyc]) continue; /* already assigned */
704
705 while (vkey <= 'Z' && vkey_used[vkey]) vkey++;
706 if (vkey <= 'Z')
707 {
708 thread_data->keyc2vkey[keyc] = vkey;
709 vkey_used[vkey] = 1;
710 TRACE("keyc 0x%04x -> vkey 0x%04x (spare letter)\n", keyc, vkey);
711 }
712 else
713 break; /* no more unused letter vkeys, so stop trying */
714 }
715
716 /* Same thing but with the digits. */
717 vkey = '0';
718 for (keyc = 0; keyc < sizeof(default_map) / sizeof(default_map[0]); keyc++)
719 {
720 if (default_map[keyc].vkey < '0' || '9' < default_map[keyc].vkey)
721 continue; /* not a digit in ANSI layout */
722 if (!thread_data->keyc2scan[keyc]) continue; /* not a known Mac key code */
723 if (thread_data->keyc2vkey[keyc]) continue; /* already assigned */
724
725 while (vkey <= '9' && vkey_used[vkey]) vkey++;
726 if (vkey <= '9')
727 {
728 thread_data->keyc2vkey[keyc] = vkey;
729 vkey_used[vkey] = 1;
730 TRACE("keyc 0x%04x -> vkey 0x%04x (spare digit)\n", keyc, vkey);
731 }
732 else
733 break; /* no more unused digit vkeys, so stop trying */
734 }
735
736 /* Last chance. Assign any available vkey. */
737 vkey_range = 0;
738 vkey = vkey_ranges[vkey_range].first;
739 for (keyc = 0; keyc < sizeof(default_map) / sizeof(default_map[0]); keyc++)
740 {
741 if (!thread_data->keyc2scan[keyc]) continue; /* not a known Mac key code */
742 if (thread_data->keyc2vkey[keyc]) continue; /* already assigned */
743
744 while (vkey && vkey_used[vkey])
745 {
746 if (vkey == vkey_ranges[vkey_range].last)
747 {
748 vkey_range++;
749 vkey = vkey_ranges[vkey_range].first;
750 }
751 else
752 vkey++;
753 }
754
755 if (!vkey)
756 {
757 WARN("No more vkeys available!\n");
758 break;
759 }
760
761 thread_data->keyc2vkey[keyc] = vkey;
762 vkey_used[vkey] = 1;
763 TRACE("keyc 0x%04x -> vkey 0x%04x (spare vkey)\n", keyc, vkey);
764 }
765 }
766
767
768 /***********************************************************************
769 * macdrv_send_keyboard_input
770 */
771 static void macdrv_send_keyboard_input(HWND hwnd, WORD vkey, WORD scan, DWORD flags, DWORD time)
772 {
773 INPUT input;
774
775 TRACE_(key)("hwnd %p vkey=%04x scan=%04x flags=%04x\n", hwnd, vkey, scan, flags);
776
777 input.type = INPUT_KEYBOARD;
778 input.ki.wVk = vkey;
779 input.ki.wScan = scan;
780 input.ki.dwFlags = flags;
781 input.ki.time = time;
782 input.ki.dwExtraInfo = 0;
783
784 __wine_send_input(hwnd, &input);
785 }
786
787
788 /***********************************************************************
789 * macdrv_key_event
790 *
791 * Handler for KEY_PRESS and KEY_RELEASE events.
792 */
793 void macdrv_key_event(HWND hwnd, const macdrv_event *event)
794 {
795 struct macdrv_thread_data *thread_data = macdrv_thread_data();
796 WORD vkey, scan;
797 DWORD flags;
798
799 TRACE_(key)("win %p/%p key %s keycode %hu modifiers 0x%08llx\n",
800 hwnd, event->window, (event->type == KEY_PRESS ? "press" : "release"),
801 event->key.keycode, event->key.modifiers);
802
803 thread_data->last_modifiers = event->key.modifiers;
804
805 if (event->key.keycode < sizeof(thread_data->keyc2vkey)/sizeof(thread_data->keyc2vkey[0]))
806 {
807 vkey = thread_data->keyc2vkey[event->key.keycode];
808 scan = thread_data->keyc2scan[event->key.keycode];
809 }
810 else
811 vkey = scan = 0;
812
813 TRACE_(key)("keycode %hu converted to vkey 0x%X scan 0x%02x\n",
814 event->key.keycode, vkey, scan);
815
816 if (!vkey) return;
817
818 flags = 0;
819 if (event->type == KEY_RELEASE) flags |= KEYEVENTF_KEYUP;
820 if (scan & 0x100) flags |= KEYEVENTF_EXTENDEDKEY;
821
822 macdrv_send_keyboard_input(hwnd, vkey, scan & 0xff, flags, event->key.time_ms);
823 }
824
825
826 /***********************************************************************
827 * macdrv_keyboard_changed
828 *
829 * Handler for KEYBOARD_CHANGED events.
830 */
831 void macdrv_keyboard_changed(const macdrv_event *event)
832 {
833 struct macdrv_thread_data *thread_data = macdrv_thread_data();
834
835 TRACE("new keyboard layout uchr data %p, type %u, iso %d\n", event->keyboard_changed.uchr,
836 event->keyboard_changed.keyboard_type, event->keyboard_changed.iso_keyboard);
837
838 if (thread_data->keyboard_layout_uchr)
839 CFRelease(thread_data->keyboard_layout_uchr);
840 thread_data->keyboard_layout_uchr = CFDataCreateCopy(NULL, event->keyboard_changed.uchr);
841 thread_data->keyboard_type = event->keyboard_changed.keyboard_type;
842 thread_data->iso_keyboard = event->keyboard_changed.iso_keyboard;
843 thread_data->dead_key_state = 0;
844
845 macdrv_compute_keyboard_layout(thread_data);
846 }
847
848
849 /***********************************************************************
850 * get_locale_keyboard_layout
851 */
852 static HKL get_locale_keyboard_layout(void)
853 {
854 ULONG_PTR layout;
855 LANGID langid;
856
857 layout = GetUserDefaultLCID();
858
859 /*
860 * Microsoft Office expects this value to be something specific
861 * for Japanese and Korean Windows with an IME the value is 0xe001
862 * We should probably check to see if an IME exists and if so then
863 * set this word properly.
864 */
865 langid = PRIMARYLANGID(LANGIDFROMLCID(layout));
866 if (langid == LANG_CHINESE || langid == LANG_JAPANESE || langid == LANG_KOREAN)
867 layout |= 0xe001 << 16; /* IME */
868 else
869 layout |= layout << 16;
870
871 return (HKL)layout;
872 }
873
874
875 /***********************************************************************
876 * match_keyboard_layout
877 */
878 static BOOL match_keyboard_layout(HKL hkl)
879 {
880 const DWORD isIME = 0xE0000000;
881 HKL current_hkl = get_locale_keyboard_layout();
882
883 /* if the layout is an IME, only match the low word (LCID) */
884 if (((ULONG_PTR)hkl & isIME) == isIME)
885 return (LOWORD(hkl) == LOWORD(current_hkl));
886 else
887 return (hkl == current_hkl);
888 }
889
890
891 /***********************************************************************
892 * ActivateKeyboardLayout (MACDRV.@)
893 */
894 HKL CDECL macdrv_ActivateKeyboardLayout(HKL hkl, UINT flags)
895 {
896 HKL oldHkl = 0;
897 struct macdrv_thread_data *thread_data = macdrv_init_thread_data();
898
899 /* FIXME: Use Text Input Services or NSTextInputContext to actually
900 change the Mac keyboard input source. */
901
902 FIXME("hkl %p flags %04x: semi-stub!\n", hkl, flags);
903 if (flags & KLF_SETFORPROCESS)
904 {
905 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
906 FIXME("KLF_SETFORPROCESS not supported\n");
907 return 0;
908 }
909
910 if (flags)
911 FIXME("flags %x not supported\n",flags);
912
913 if (hkl == (HKL)HKL_NEXT || hkl == (HKL)HKL_PREV)
914 {
915 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
916 FIXME("HKL_NEXT and HKL_PREV not supported\n");
917 return 0;
918 }
919
920 if (!match_keyboard_layout(hkl))
921 {
922 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
923 FIXME("setting keyboard of different locales not supported\n");
924 return 0;
925 }
926
927 oldHkl = thread_data->active_keyboard_layout;
928 if (!oldHkl) oldHkl = get_locale_keyboard_layout();
929
930 thread_data->active_keyboard_layout = hkl;
931
932 return oldHkl;
933 }
934
935
936 /***********************************************************************
937 * Beep (MACDRV.@)
938 */
939 void CDECL macdrv_Beep(void)
940 {
941 macdrv_beep();
942 }
943
944
945 /***********************************************************************
946 * GetKeyNameText (MACDRV.@)
947 */
948 INT CDECL macdrv_GetKeyNameText(LONG lparam, LPWSTR buffer, INT size)
949 {
950 struct macdrv_thread_data *thread_data = macdrv_init_thread_data();
951 int scan, keyc;
952
953 scan = (lparam >> 16) & 0x1FF;
954 for (keyc = 0; keyc < sizeof(thread_data->keyc2scan)/sizeof(thread_data->keyc2scan[0]); keyc++)
955 {
956 if (thread_data->keyc2scan[keyc] == scan)
957 {
958 static const WCHAR dead[] = {' ','d','e','a','d',0};
959 const UCKeyboardLayout *uchr;
960 UInt32 deadKeyState = 0;
961 UniCharCount len;
962 OSStatus status;
963
964 uchr = (const UCKeyboardLayout*)CFDataGetBytePtr(thread_data->keyboard_layout_uchr);
965 status = UCKeyTranslate(uchr, keyc, kUCKeyActionDisplay, 0, thread_data->keyboard_type,
966 0, &deadKeyState, size - 1, &len, (UniChar*)buffer);
967 if (status != noErr)
968 len = 0;
969 if (len && isgraphW(buffer[0]))
970 buffer[len] = 0;
971 else
972 {
973 DWORD vkey = thread_data->keyc2vkey[keyc];
974 int i;
975
976 if (scan & 0x100) vkey |= 0x100;
977
978 if (lparam & (1 << 25))
979 {
980 /* Caller doesn't care about distinctions between left and
981 right keys. */
982 switch (vkey)
983 {
984 case VK_LSHIFT:
985 case VK_RSHIFT:
986 vkey = VK_SHIFT; break;
987 case VK_LCONTROL:
988 case VK_RCONTROL:
989 vkey = VK_CONTROL; break;
990 case VK_LMENU:
991 case VK_RMENU:
992 vkey = VK_MENU; break;
993 }
994 }
995
996 len = 0;
997 for (i = 0; i < sizeof(vkey_names) / sizeof(vkey_names[0]); i++)
998 {
999 if (vkey_names[i].vkey == vkey)
1000 {
1001 len = MultiByteToWideChar(CP_UTF8, 0, vkey_names[i].name, -1, buffer, size);
1002 if (len) len--;
1003 break;
1004 }
1005 }
1006
1007 if (!len)
1008 {
1009 static const WCHAR format[] = {'K','e','y',' ','0','x','%','0','2','x',0};
1010 snprintfW(buffer, size, format, vkey);
1011 len = strlenW(buffer);
1012 }
1013 }
1014
1015 if (!len)
1016 break;
1017
1018 if (status == noErr && deadKeyState)
1019 {
1020 lstrcpynW(buffer + len, dead, size - len);
1021 len = strlenW(buffer);
1022 }
1023
1024 TRACE("lparam 0x%08x -> %s\n", lparam, debugstr_w(buffer));
1025 return len;
1026 }
1027 }
1028
1029 WARN("found no name for lparam 0x%08x\n", lparam);
1030 return 0;
1031 }
1032
1033
1034 /***********************************************************************
1035 * GetKeyboardLayout (MACDRV.@)
1036 */
1037 HKL CDECL macdrv_GetKeyboardLayout(DWORD thread_id)
1038 {
1039 if (!thread_id || thread_id == GetCurrentThreadId())
1040 {
1041 struct macdrv_thread_data *thread_data = macdrv_thread_data();
1042 if (thread_data && thread_data->active_keyboard_layout)
1043 return thread_data->active_keyboard_layout;
1044 }
1045 else
1046 FIXME("couldn't return keyboard layout for thread %04x\n", thread_id);
1047
1048 /* FIXME: Use TISGetInputSourceProperty() and kTISPropertyInputSourceLanguages
1049 * to get input source language ID string. Use
1050 * CFLocaleGetWindowsLocaleCodeFromLocaleIdentifier() to convert that
1051 * to a Windows locale ID and from there to a layout handle.
1052 */
1053
1054 return get_locale_keyboard_layout();
1055 }
1056
1057
1058 /***********************************************************************
1059 * GetKeyboardLayoutName (MACDRV.@)
1060 */
1061 BOOL CDECL macdrv_GetKeyboardLayoutName(LPWSTR name)
1062 {
1063 static const WCHAR formatW[] = {'%','0','8','x',0};
1064 DWORD layout;
1065
1066 layout = HandleToUlong(get_locale_keyboard_layout());
1067 if (HIWORD(layout) == LOWORD(layout)) layout = LOWORD(layout);
1068 sprintfW(name, formatW, layout);
1069 TRACE("returning %s\n", debugstr_w(name));
1070 return TRUE;
1071 }
1072
1073
1074 /***********************************************************************
1075 * MapVirtualKeyEx (MACDRV.@)
1076 */
1077 UINT CDECL macdrv_MapVirtualKeyEx(UINT wCode, UINT wMapType, HKL hkl)
1078 {
1079 struct macdrv_thread_data *thread_data = macdrv_init_thread_data();
1080 UINT ret = 0;
1081 int keyc;
1082
1083 TRACE("wCode=0x%x, wMapType=%d, hkl %p\n", wCode, wMapType, hkl);
1084
1085 switch (wMapType)
1086 {
1087 case MAPVK_VK_TO_VSC: /* vkey-code to scan-code */
1088 case MAPVK_VK_TO_VSC_EX:
1089 switch (wCode)
1090 {
1091 case VK_SHIFT: wCode = VK_LSHIFT; break;
1092 case VK_CONTROL: wCode = VK_LCONTROL; break;
1093 case VK_MENU: wCode = VK_LMENU; break;
1094 }
1095
1096 /* vkey -> keycode -> scan */
1097 for (keyc = 0; keyc < sizeof(thread_data->keyc2vkey)/sizeof(thread_data->keyc2vkey[0]); keyc++)
1098 {
1099 if (thread_data->keyc2vkey[keyc] == wCode)
1100 {
1101 ret = thread_data->keyc2scan[keyc] & 0xFF;
1102 break;
1103 }
1104 }
1105 break;
1106
1107 case MAPVK_VSC_TO_VK: /* scan-code to vkey-code */
1108 case MAPVK_VSC_TO_VK_EX:
1109 /* scan -> keycode -> vkey */
1110 for (keyc = 0; keyc < sizeof(thread_data->keyc2vkey)/sizeof(thread_data->keyc2vkey[0]); keyc++)
1111 if ((thread_data->keyc2scan[keyc] & 0xFF) == (wCode & 0xFF))
1112 {
1113 ret = thread_data->keyc2vkey[keyc];
1114 /* Only stop if it's not a numpad vkey; otherwise keep
1115 looking for a potential better vkey. */
1116 if (ret && (ret < VK_NUMPAD0 || VK_DIVIDE < ret))
1117 break;
1118 }
1119
1120 if (wMapType == MAPVK_VSC_TO_VK)
1121 switch (ret)
1122 {
1123 case VK_LSHIFT:
1124 case VK_RSHIFT:
1125 ret = VK_SHIFT; break;
1126 case VK_LCONTROL:
1127 case VK_RCONTROL:
1128 ret = VK_CONTROL; break;
1129 case VK_LMENU:
1130 case VK_RMENU:
1131 ret = VK_MENU; break;
1132 }
1133
1134 break;
1135
1136 case MAPVK_VK_TO_CHAR: /* vkey-code to character */
1137 {
1138 /* vkey -> keycode -> (UCKeyTranslate) wide char */
1139 struct macdrv_thread_data *thread_data = macdrv_thread_data();
1140 const UCKeyboardLayout *uchr;
1141 UniChar s[10];
1142 OSStatus status;
1143 UInt32 deadKeyState;
1144 UniCharCount len;
1145 BOOL deadKey = FALSE;
1146
1147 if ((VK_PRIOR <= wCode && wCode <= VK_HELP) ||
1148 (VK_F1 <= wCode && wCode <= VK_F24))
1149 break;
1150
1151 if (!thread_data || !thread_data->keyboard_layout_uchr)
1152 {
1153 WARN("No keyboard layout uchr data\n");
1154 break;
1155 }
1156
1157 uchr = (const UCKeyboardLayout*)CFDataGetBytePtr(thread_data->keyboard_layout_uchr);
1158
1159 /* Find the Mac keycode corresponding to the vkey */
1160 for (keyc = 0; keyc < sizeof(thread_data->keyc2vkey)/sizeof(thread_data->keyc2vkey[0]); keyc++)
1161 if (thread_data->keyc2vkey[keyc] == wCode) break;
1162
1163 if (keyc >= sizeof(thread_data->keyc2vkey)/sizeof(thread_data->keyc2vkey[0]))
1164 {
1165 WARN("Unknown virtual key %X\n", wCode);
1166 break;
1167 }
1168
1169 TRACE("Found keycode %u\n", keyc);
1170
1171 deadKeyState = 0;
1172 status = UCKeyTranslate(uchr, keyc, kUCKeyActionDown, 0,
1173 thread_data->keyboard_type, 0, &deadKeyState,
1174 sizeof(s)/sizeof(s[0]), &len, s);
1175 if (status == noErr && !len && deadKeyState)
1176 {
1177 deadKey = TRUE;
1178 deadKeyState = 0;
1179 status = UCKeyTranslate(uchr, keyc, kUCKeyActionDown, 0,
1180 thread_data->keyboard_type, kUCKeyTranslateNoDeadKeysMask,
1181 &deadKeyState, sizeof(s)/sizeof(s[0]), &len, s);
1182 }
1183
1184 if (status == noErr && len)
1185 ret = toupperW(s[0]) | (deadKey ? 0x80000000 : 0);
1186
1187 break;
1188 }
1189 default: /* reserved */
1190 FIXME("Unknown wMapType %d\n", wMapType);
1191 break;
1192 }
1193
1194 TRACE("returning 0x%04x\n", ret);
1195 return ret;
1196 }
1197
1198
1199 /***********************************************************************
1200 * ToUnicodeEx (MACDRV.@)
1201 *
1202 * The ToUnicode function translates the specified virtual-key code and keyboard
1203 * state to the corresponding Windows character or characters.
1204 *
1205 * If the specified key is a dead key, the return value is negative. Otherwise,
1206 * it is one of the following values:
1207 * Value Meaning
1208 * -1 The specified virtual key is a dead-key. If possible, the
1209 * non-combining form of the dead character is written to bufW.
1210 * 0 The specified virtual key has no translation for the current
1211 * state of the keyboard.
1212 * 1 One Windows character was copied to the buffer.
1213 * 2 or more Multiple characters were copied to the buffer. This usually
1214 * happens when a dead-key character (accent or diacritic) stored
1215 * in the keyboard layout cannot be composed with the specified
1216 * virtual key to form a single character.
1217 *
1218 */
1219 INT CDECL macdrv_ToUnicodeEx(UINT virtKey, UINT scanCode, const BYTE *lpKeyState,
1220 LPWSTR bufW, int bufW_size, UINT flags, HKL hkl)
1221 {
1222 struct macdrv_thread_data *thread_data = macdrv_init_thread_data();
1223 INT ret = 0;
1224 int keyc;
1225 BOOL is_menu = (flags & 0x1);
1226 OSStatus status;
1227 const UCKeyboardLayout *uchr;
1228 UInt16 keyAction;
1229 UInt32 modifierKeyState;
1230 OptionBits options;
1231 UInt32 deadKeyState, savedDeadKeyState;
1232 UniCharCount len;
1233 BOOL dead = FALSE;
1234
1235 TRACE_(key)("virtKey 0x%04x scanCode 0x%04x lpKeyState %p bufW %p bufW_size %d flags 0x%08x hkl %p\n",
1236 virtKey, scanCode, lpKeyState, bufW, bufW_size, flags, hkl);
1237
1238 if (!virtKey)
1239 goto done;
1240
1241 /* UCKeyTranslate, below, terminates a dead-key sequence if passed a
1242 modifier key press. We want it to effectively ignore modifier key
1243 presses. I think that one isn't supposed to call it at all for modifier
1244 events (e.g. NSFlagsChanged or kEventRawKeyModifiersChanged), since they
1245 are different event types than key up/down events. */
1246 switch (virtKey)
1247 {
1248 case VK_SHIFT:
1249 case VK_CONTROL:
1250 case VK_MENU:
1251 case VK_CAPITAL:
1252 case VK_LSHIFT:
1253 case VK_RSHIFT:
1254 case VK_LCONTROL:
1255 case VK_RCONTROL:
1256 case VK_LMENU:
1257 case VK_RMENU:
1258 goto done;
1259 }
1260
1261 /* There are a number of key combinations for which Windows does not
1262 produce characters, but Mac keyboard layouts may. Eat them. Do this
1263 here to avoid the expense of UCKeyTranslate() but also because these
1264 keys shouldn't terminate dead key sequences. */
1265 if ((VK_PRIOR <= virtKey && virtKey <= VK_HELP) || (VK_F1 <= virtKey && virtKey <= VK_F24))
1266 goto done;
1267
1268 /* Shift + <non-digit keypad keys>. */
1269 if ((lpKeyState[VK_SHIFT] & 0x80) && VK_MULTIPLY <= virtKey && virtKey <= VK_DIVIDE)
1270 goto done;
1271
1272 if (lpKeyState[VK_CONTROL] & 0x80)
1273 {
1274 /* Control-Tab, with or without other modifiers. */
1275 if (virtKey == VK_TAB)
1276 goto done;
1277
1278 /* Control-Shift-<key>, Control-Alt-<key>, and Control-Alt-Shift-<key>
1279 for these keys. */
1280 if ((lpKeyState[VK_SHIFT] & 0x80) || (lpKeyState[VK_MENU] & 0x80))
1281 {
1282 switch (virtKey)
1283 {
1284 case VK_CANCEL:
1285 case VK_BACK:
1286 case VK_ESCAPE:
1287 case VK_SPACE:
1288 case VK_RETURN:
1289 goto done;
1290 }
1291 }
1292 }
1293
1294 if (thread_data->keyboard_layout_uchr)
1295 uchr = (const UCKeyboardLayout*)CFDataGetBytePtr(thread_data->keyboard_layout_uchr);
1296 else
1297 uchr = NULL;
1298
1299 keyAction = (scanCode & 0x8000) ? kUCKeyActionUp : kUCKeyActionDown;
1300
1301 modifierKeyState = 0;
1302 if (lpKeyState[VK_SHIFT] & 0x80)
1303 modifierKeyState |= (shiftKey >> 8);
1304 if (lpKeyState[VK_CAPITAL] & 0x01)
1305 modifierKeyState |= (alphaLock >> 8);
1306 if (lpKeyState[VK_CONTROL] & 0x80)
1307 modifierKeyState |= (controlKey >> 8);
1308 if (lpKeyState[VK_MENU] & 0x80)
1309 modifierKeyState |= (cmdKey >> 8);
1310 if (thread_data->last_modifiers & (NX_ALTERNATEMASK | NX_DEVICELALTKEYMASK | NX_DEVICERALTKEYMASK))
1311 modifierKeyState |= (optionKey >> 8);
1312
1313 /* Find the Mac keycode corresponding to the vkey */
1314 for (keyc = 0; keyc < sizeof(thread_data->keyc2vkey)/sizeof(thread_data->keyc2vkey[0]); keyc++)
1315 if (thread_data->keyc2vkey[keyc] == virtKey) break;
1316
1317 if (keyc >= sizeof(thread_data->keyc2vkey)/sizeof(thread_data->keyc2vkey[0]))
1318 {
1319 WARN_(key)("Unknown virtual key 0x%04x\n", virtKey);
1320 goto done;
1321 }
1322
1323 TRACE_(key)("Key code 0x%04x %s, faked modifiers = 0x%04x\n", keyc,
1324 (keyAction == kUCKeyActionDown) ? "pressed" : "released", (unsigned)modifierKeyState);
1325
1326 if (is_menu)
1327 {
1328 options = kUCKeyTranslateNoDeadKeysMask;
1329 deadKeyState = 0;
1330 }
1331 else
1332 {
1333 options = 0;
1334 deadKeyState = thread_data->dead_key_state;
1335 }
1336 savedDeadKeyState = deadKeyState;
1337 status = UCKeyTranslate(uchr, keyc, keyAction, modifierKeyState,
1338 thread_data->keyboard_type, options, &deadKeyState, bufW_size,
1339 &len, bufW);
1340 if (status != noErr)
1341 {
1342 ERR_(key)("Couldn't translate keycode 0x%04x, status %ld\n", keyc, status);
1343 goto done;
1344 }
1345 if (!is_menu)
1346 thread_data->dead_key_state = deadKeyState;
1347
1348 if (len == 0 && deadKeyState)
1349 {
1350 /* Repeat the translation, but disabling dead-key generation to
1351 learn which dead key it was. */
1352 status = UCKeyTranslate(uchr, keyc, keyAction, modifierKeyState,
1353 thread_data->keyboard_type, kUCKeyTranslateNoDeadKeysMask,
1354 &savedDeadKeyState, bufW_size, &len, bufW);
1355 if (status != noErr)
1356 {
1357 ERR_(key)("Couldn't translate keycode 0x%04x, status %ld\n", keyc, status);
1358 goto done;
1359 }
1360
1361 dead = TRUE;
1362 }
1363
1364 if (len > 0)
1365 len = strip_apple_private_chars(bufW, len);
1366
1367 if (dead && len > 0) ret = -1;
1368 else ret = len;
1369
1370 /* Control-Return produces line feed instead of carriage return. */
1371 if (ret > 0 && (lpKeyState[VK_CONTROL] & 0x80) && virtKey == VK_RETURN)
1372 {
1373 int i;
1374 for (i = 0; i < len; i++)
1375 if (bufW[i] == '\r')
1376 bufW[i] = '\n';
1377 }
1378
1379 done:
1380 /* Null-terminate the buffer, if there's room. MSDN clearly states that the
1381 caller must not assume this is done, but some programs (e.g. Audiosurf) do. */
1382 if (1 <= ret && ret < bufW_size)
1383 bufW[ret] = 0;
1384
1385 TRACE_(key)("returning %d / %s\n", ret, debugstr_wn(bufW, abs(ret)));
1386 return ret;
1387 }
1388
1389
1390 /***********************************************************************
1391 * VkKeyScanEx (MACDRV.@)
1392 *
1393 * Note: Windows ignores HKL parameter and uses current active layout instead
1394 */
1395 SHORT CDECL macdrv_VkKeyScanEx(WCHAR wChar, HKL hkl)
1396 {
1397 struct macdrv_thread_data *thread_data = macdrv_init_thread_data();
1398 SHORT ret = -1;
1399 int state;
1400 const UCKeyboardLayout *uchr;
1401
1402 TRACE("%04x, %p\n", wChar, hkl);
1403
1404 uchr = (const UCKeyboardLayout*)CFDataGetBytePtr(thread_data->keyboard_layout_uchr);
1405 if (!uchr)
1406 {
1407 TRACE("no keyboard layout UCHR data; returning -1\n");
1408 return -1;
1409 }
1410
1411 for (state = 0; state < 8; state++)
1412 {
1413 UInt32 modifierKeyState = 0;
1414 int keyc;
1415
1416 if (state & 1)
1417 modifierKeyState |= (shiftKey >> 8);
1418 if ((state & 6) == 6)
1419 modifierKeyState |= (optionKey >> 8);
1420 else
1421 {
1422 if (state & 2)
1423 modifierKeyState |= (controlKey >> 8);
1424 if (state & 4)
1425 modifierKeyState |= (cmdKey >> 8);
1426 }
1427
1428 for (keyc = 0; keyc < sizeof(thread_data->keyc2vkey) / sizeof(thread_data->keyc2vkey[0]); keyc++)
1429 {
1430 UInt32 deadKeyState = 0;
1431 UniChar uchar;
1432 UniCharCount len;
1433 OSStatus status;
1434
1435 if (!thread_data->keyc2vkey[keyc]) continue;
1436
1437 status = UCKeyTranslate(uchr, keyc, kUCKeyActionDown, modifierKeyState,
1438 thread_data->keyboard_type, 0, &deadKeyState,
1439 1, &len, &uchar);
1440 if (status == noErr && len == 1 && uchar == wChar)
1441 {
1442 WORD vkey = thread_data->keyc2vkey[keyc];
1443
1444 ret = vkey | (state << 8);
1445 if ((VK_NUMPAD0 <= vkey && vkey <= VK_DIVIDE) ||
1446 keyc == kVK_ANSI_KeypadClear || keyc == kVK_ANSI_KeypadEnter ||
1447 keyc == kVK_ANSI_KeypadEquals)
1448 {
1449 /* Keep searching for a non-numpad match, which is preferred. */
1450 }
1451 else
1452 goto done;
1453 }
1454 }
1455 }
1456
1457 done:
1458 TRACE(" -> 0x%04x\n", ret);
1459 return ret;
1460 }
Windows API implementation