?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
include: Windows SDK C headers have snprintf.
[wine.git] / dlls / winemac.drv / keyboard.c
blobaed4ff0d6e4b629b92804088a675df51c0503591
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 #include "wine/server.h"
33
34 WINE_DEFAULT_DEBUG_CHANNEL(keyboard);
35 WINE_DECLARE_DEBUG_CHANNEL(key);
36
37
38 /* Carbon-style modifier mask definitions from <Carbon/HIToolbox/Events.h>. */
39 enum {
40 cmdKeyBit = 8,
41 shiftKeyBit = 9,
42 alphaLockBit = 10,
43 optionKeyBit = 11,
44 controlKeyBit = 12,
45 };
46
47 enum {
48 cmdKey = 1 << cmdKeyBit,
49 shiftKey = 1 << shiftKeyBit,
50 alphaLock = 1 << alphaLockBit,
51 optionKey = 1 << optionKeyBit,
52 controlKey = 1 << controlKeyBit,
53 };
54
55
56 /* Mac virtual key code definitions from <Carbon/HIToolbox/Events.h>. */
57 enum {
58 kVK_ANSI_A = 0x00,
59 kVK_ANSI_S = 0x01,
60 kVK_ANSI_D = 0x02,
61 kVK_ANSI_F = 0x03,
62 kVK_ANSI_H = 0x04,
63 kVK_ANSI_G = 0x05,
64 kVK_ANSI_Z = 0x06,
65 kVK_ANSI_X = 0x07,
66 kVK_ANSI_C = 0x08,
67 kVK_ANSI_V = 0x09,
68 kVK_ISO_Section = 0x0A,
69 kVK_ANSI_B = 0x0B,
70 kVK_ANSI_Q = 0x0C,
71 kVK_ANSI_W = 0x0D,
72 kVK_ANSI_E = 0x0E,
73 kVK_ANSI_R = 0x0F,
74 kVK_ANSI_Y = 0x10,
75 kVK_ANSI_T = 0x11,
76 kVK_ANSI_1 = 0x12,
77 kVK_ANSI_2 = 0x13,
78 kVK_ANSI_3 = 0x14,
79 kVK_ANSI_4 = 0x15,
80 kVK_ANSI_6 = 0x16,
81 kVK_ANSI_5 = 0x17,
82 kVK_ANSI_Equal = 0x18,
83 kVK_ANSI_9 = 0x19,
84 kVK_ANSI_7 = 0x1A,
85 kVK_ANSI_Minus = 0x1B,
86 kVK_ANSI_8 = 0x1C,
87 kVK_ANSI_0 = 0x1D,
88 kVK_ANSI_RightBracket = 0x1E,
89 kVK_ANSI_O = 0x1F,
90 kVK_ANSI_U = 0x20,
91 kVK_ANSI_LeftBracket = 0x21,
92 kVK_ANSI_I = 0x22,
93 kVK_ANSI_P = 0x23,
94 kVK_Return = 0x24,
95 kVK_ANSI_L = 0x25,
96 kVK_ANSI_J = 0x26,
97 kVK_ANSI_Quote = 0x27,
98 kVK_ANSI_K = 0x28,
99 kVK_ANSI_Semicolon = 0x29,
100 kVK_ANSI_Backslash = 0x2A,
101 kVK_ANSI_Comma = 0x2B,
102 kVK_ANSI_Slash = 0x2C,
103 kVK_ANSI_N = 0x2D,
104 kVK_ANSI_M = 0x2E,
105 kVK_ANSI_Period = 0x2F,
106 kVK_Tab = 0x30,
107 kVK_Space = 0x31,
108 kVK_ANSI_Grave = 0x32,
109 kVK_Delete = 0x33,
110 kVK_Escape = 0x35,
111 kVK_RightCommand = 0x36, /* invented for Wine; co-opt unused key code */
112 kVK_Command = 0x37,
113 kVK_Shift = 0x38,
114 kVK_CapsLock = 0x39,
115 kVK_Option = 0x3A,
116 kVK_Control = 0x3B,
117 kVK_RightShift = 0x3C,
118 kVK_RightOption = 0x3D,
119 kVK_RightControl = 0x3E,
120 kVK_Function = 0x3F,
121 kVK_F17 = 0x40,
122 kVK_ANSI_KeypadDecimal = 0x41,
123 kVK_ANSI_KeypadMultiply = 0x43,
124 kVK_ANSI_KeypadPlus = 0x45,
125 kVK_ANSI_KeypadClear = 0x47,
126 kVK_VolumeUp = 0x48,
127 kVK_VolumeDown = 0x49,
128 kVK_Mute = 0x4A,
129 kVK_ANSI_KeypadDivide = 0x4B,
130 kVK_ANSI_KeypadEnter = 0x4C,
131 kVK_ANSI_KeypadMinus = 0x4E,
132 kVK_F18 = 0x4F,
133 kVK_F19 = 0x50,
134 kVK_ANSI_KeypadEquals = 0x51,
135 kVK_ANSI_Keypad0 = 0x52,
136 kVK_ANSI_Keypad1 = 0x53,
137 kVK_ANSI_Keypad2 = 0x54,
138 kVK_ANSI_Keypad3 = 0x55,
139 kVK_ANSI_Keypad4 = 0x56,
140 kVK_ANSI_Keypad5 = 0x57,
141 kVK_ANSI_Keypad6 = 0x58,
142 kVK_ANSI_Keypad7 = 0x59,
143 kVK_F20 = 0x5A,
144 kVK_ANSI_Keypad8 = 0x5B,
145 kVK_ANSI_Keypad9 = 0x5C,
146 kVK_JIS_Yen = 0x5D,
147 kVK_JIS_Underscore = 0x5E,
148 kVK_JIS_KeypadComma = 0x5F,
149 kVK_F5 = 0x60,
150 kVK_F6 = 0x61,
151 kVK_F7 = 0x62,
152 kVK_F3 = 0x63,
153 kVK_F8 = 0x64,
154 kVK_F9 = 0x65,
155 kVK_JIS_Eisu = 0x66,
156 kVK_F11 = 0x67,
157 kVK_JIS_Kana = 0x68,
158 kVK_F13 = 0x69,
159 kVK_F16 = 0x6A,
160 kVK_F14 = 0x6B,
161 kVK_F10 = 0x6D,
162 kVK_F12 = 0x6F,
163 kVK_F15 = 0x71,
164 kVK_Help = 0x72,
165 kVK_Home = 0x73,
166 kVK_PageUp = 0x74,
167 kVK_ForwardDelete = 0x75,
168 kVK_F4 = 0x76,
169 kVK_End = 0x77,
170 kVK_F2 = 0x78,
171 kVK_PageDown = 0x79,
172 kVK_F1 = 0x7A,
173 kVK_LeftArrow = 0x7B,
174 kVK_RightArrow = 0x7C,
175 kVK_DownArrow = 0x7D,
176 kVK_UpArrow = 0x7E,
177 };
178
179 extern const CFStringRef kTISTypeKeyboardLayout;
180
181 /* Indexed by Mac virtual keycode values defined above. */
182 static const struct {
183 WORD vkey;
184 WORD scan;
185 BOOL fixed;
186 } default_map[128] = {
187 { 'A', 0x1E, FALSE }, /* kVK_ANSI_A */
188 { 'S', 0x1F, FALSE }, /* kVK_ANSI_S */
189 { 'D', 0x20, FALSE }, /* kVK_ANSI_D */
190 { 'F', 0x21, FALSE }, /* kVK_ANSI_F */
191 { 'H', 0x23, FALSE }, /* kVK_ANSI_H */
192 { 'G', 0x22, FALSE }, /* kVK_ANSI_G */
193 { 'Z', 0x2C, FALSE }, /* kVK_ANSI_Z */
194 { 'X', 0x2D, FALSE }, /* kVK_ANSI_X */
195 { 'C', 0x2E, FALSE }, /* kVK_ANSI_C */
196 { 'V', 0x2F, FALSE }, /* kVK_ANSI_V */
197 { VK_OEM_102, 0x56, TRUE }, /* kVK_ISO_Section */
198 { 'B', 0x30, FALSE }, /* kVK_ANSI_B */
199 { 'Q', 0x10, FALSE }, /* kVK_ANSI_Q */
200 { 'W', 0x11, FALSE }, /* kVK_ANSI_W */
201 { 'E', 0x12, FALSE }, /* kVK_ANSI_E */
202 { 'R', 0x13, FALSE }, /* kVK_ANSI_R */
203 { 'Y', 0x15, FALSE }, /* kVK_ANSI_Y */
204 { 'T', 0x14, FALSE }, /* kVK_ANSI_T */
205 { '1', 0x02, FALSE }, /* kVK_ANSI_1 */
206 { '2', 0x03, FALSE }, /* kVK_ANSI_2 */
207 { '3', 0x04, FALSE }, /* kVK_ANSI_3 */
208 { '4', 0x05, FALSE }, /* kVK_ANSI_4 */
209 { '6', 0x07, FALSE }, /* kVK_ANSI_6 */
210 { '5', 0x06, FALSE }, /* kVK_ANSI_5 */
211 { VK_OEM_PLUS, 0x0D, FALSE }, /* kVK_ANSI_Equal */
212 { '9', 0x0A, FALSE }, /* kVK_ANSI_9 */
213 { '7', 0x08, FALSE }, /* kVK_ANSI_7 */
214 { VK_OEM_MINUS, 0x0C, FALSE }, /* kVK_ANSI_Minus */
215 { '8', 0x09, FALSE }, /* kVK_ANSI_8 */
216 { '0', 0x0B, FALSE }, /* kVK_ANSI_0 */
217 { VK_OEM_6, 0x1B, FALSE }, /* kVK_ANSI_RightBracket */
218 { 'O', 0x18, FALSE }, /* kVK_ANSI_O */
219 { 'U', 0x16, FALSE }, /* kVK_ANSI_U */
220 { VK_OEM_4, 0x1A, FALSE }, /* kVK_ANSI_LeftBracket */
221 { 'I', 0x17, FALSE }, /* kVK_ANSI_I */
222 { 'P', 0x19, FALSE }, /* kVK_ANSI_P */
223 { VK_RETURN, 0x1C, TRUE }, /* kVK_Return */
224 { 'L', 0x26, FALSE }, /* kVK_ANSI_L */
225 { 'J', 0x24, FALSE }, /* kVK_ANSI_J */
226 { VK_OEM_7, 0x28, FALSE }, /* kVK_ANSI_Quote */
227 { 'K', 0x25, FALSE }, /* kVK_ANSI_K */
228 { VK_OEM_1, 0x27, FALSE }, /* kVK_ANSI_Semicolon */
229 { VK_OEM_5, 0x2B, FALSE }, /* kVK_ANSI_Backslash */
230 { VK_OEM_COMMA, 0x33, FALSE }, /* kVK_ANSI_Comma */
231 { VK_OEM_2, 0x35, FALSE }, /* kVK_ANSI_Slash */
232 { 'N', 0x31, FALSE }, /* kVK_ANSI_N */
233 { 'M', 0x32, FALSE }, /* kVK_ANSI_M */
234 { VK_OEM_PERIOD, 0x34, FALSE }, /* kVK_ANSI_Period */
235 { VK_TAB, 0x0F, TRUE }, /* kVK_Tab */
236 { VK_SPACE, 0x39, TRUE }, /* kVK_Space */
237 { VK_OEM_3, 0x29, FALSE }, /* kVK_ANSI_Grave */
238 { VK_BACK, 0x0E, TRUE }, /* kVK_Delete */
239 { 0, 0, FALSE }, /* 0x34 unused */
240 { VK_ESCAPE, 0x01, TRUE }, /* kVK_Escape */
241 { VK_RMENU, 0x38 | 0x100, TRUE }, /* kVK_RightCommand */
242 { VK_LMENU, 0x38, TRUE }, /* kVK_Command */
243 { VK_LSHIFT, 0x2A, TRUE }, /* kVK_Shift */
244 { VK_CAPITAL, 0x3A, TRUE }, /* kVK_CapsLock */
245 { 0, 0, FALSE }, /* kVK_Option */
246 { VK_LCONTROL, 0x1D, TRUE }, /* kVK_Control */
247 { VK_RSHIFT, 0x36, TRUE }, /* kVK_RightShift */
248 { 0, 0, FALSE }, /* kVK_RightOption */
249 { VK_RCONTROL, 0x1D | 0x100, TRUE }, /* kVK_RightControl */
250 { 0, 0, FALSE }, /* kVK_Function */
251 { VK_F17, 0x68, TRUE }, /* kVK_F17 */
252 { VK_DECIMAL, 0x53, TRUE }, /* kVK_ANSI_KeypadDecimal */
253 { 0, 0, FALSE }, /* 0x42 unused */
254 { VK_MULTIPLY, 0x37, TRUE }, /* kVK_ANSI_KeypadMultiply */
255 { 0, 0, FALSE }, /* 0x44 unused */
256 { VK_ADD, 0x4E, TRUE }, /* kVK_ANSI_KeypadPlus */
257 { 0, 0, FALSE }, /* 0x46 unused */
258 { VK_OEM_CLEAR, 0x59, TRUE }, /* kVK_ANSI_KeypadClear */
259 { VK_VOLUME_UP, 0 | 0x100, TRUE }, /* kVK_VolumeUp */
260 { VK_VOLUME_DOWN, 0 | 0x100, TRUE }, /* kVK_VolumeDown */
261 { VK_VOLUME_MUTE, 0 | 0x100, TRUE }, /* kVK_Mute */
262 { VK_DIVIDE, 0x35 | 0x100, TRUE }, /* kVK_ANSI_KeypadDivide */
263 { VK_RETURN, 0x1C | 0x100, TRUE }, /* kVK_ANSI_KeypadEnter */
264 { 0, 0, FALSE }, /* 0x4D unused */
265 { VK_SUBTRACT, 0x4A, TRUE }, /* kVK_ANSI_KeypadMinus */
266 { VK_F18, 0x69, TRUE }, /* kVK_F18 */
267 { VK_F19, 0x6A, TRUE }, /* kVK_F19 */
268 { VK_OEM_NEC_EQUAL, 0x0D | 0x100, TRUE }, /* kVK_ANSI_KeypadEquals */
269 { VK_NUMPAD0, 0x52, TRUE }, /* kVK_ANSI_Keypad0 */
270 { VK_NUMPAD1, 0x4F, TRUE }, /* kVK_ANSI_Keypad1 */
271 { VK_NUMPAD2, 0x50, TRUE }, /* kVK_ANSI_Keypad2 */
272 { VK_NUMPAD3, 0x51, TRUE }, /* kVK_ANSI_Keypad3 */
273 { VK_NUMPAD4, 0x4B, TRUE }, /* kVK_ANSI_Keypad4 */
274 { VK_NUMPAD5, 0x4C, TRUE }, /* kVK_ANSI_Keypad5 */
275 { VK_NUMPAD6, 0x4D, TRUE }, /* kVK_ANSI_Keypad6 */
276 { VK_NUMPAD7, 0x47, TRUE }, /* kVK_ANSI_Keypad7 */
277 { VK_F20, 0x6B, TRUE }, /* kVK_F20 */
278 { VK_NUMPAD8, 0x48, TRUE }, /* kVK_ANSI_Keypad8 */
279 { VK_NUMPAD9, 0x49, TRUE }, /* kVK_ANSI_Keypad9 */
280 { 0xFF, 0x7D, TRUE }, /* kVK_JIS_Yen */
281 { 0xC1, 0x73, TRUE }, /* kVK_JIS_Underscore */
282 { VK_SEPARATOR, 0x7E, TRUE }, /* kVK_JIS_KeypadComma */
283 { VK_F5, 0x3F, TRUE }, /* kVK_F5 */
284 { VK_F6, 0x40, TRUE }, /* kVK_F6 */
285 { VK_F7, 0x41, TRUE }, /* kVK_F7 */
286 { VK_F3, 0x3D, TRUE }, /* kVK_F3 */
287 { VK_F8, 0x42, TRUE }, /* kVK_F8 */
288 { VK_F9, 0x43, TRUE }, /* kVK_F9 */
289 { 0xFF, 0x72, TRUE }, /* kVK_JIS_Eisu */
290 { VK_F11, 0x57, TRUE }, /* kVK_F11 */
291 { VK_OEM_RESET, 0x71, TRUE }, /* kVK_JIS_Kana */
292 { VK_F13, 0x64, TRUE }, /* kVK_F13 */
293 { VK_F16, 0x67, TRUE }, /* kVK_F16 */
294 { VK_F14, 0x65, TRUE }, /* kVK_F14 */
295 { 0, 0, FALSE }, /* 0x6C unused */
296 { VK_F10, 0x44, TRUE }, /* kVK_F10 */
297 { 0, 0, FALSE }, /* 0x6E unused */
298 { VK_F12, 0x58, TRUE }, /* kVK_F12 */
299 { 0, 0, FALSE }, /* 0x70 unused */
300 { VK_F15, 0x66, TRUE }, /* kVK_F15 */
301 { VK_INSERT, 0x52 | 0x100, TRUE }, /* kVK_Help */ /* map to Insert */
302 { VK_HOME, 0x47 | 0x100, TRUE }, /* kVK_Home */
303 { VK_PRIOR, 0x49 | 0x100, TRUE }, /* kVK_PageUp */
304 { VK_DELETE, 0x53 | 0x100, TRUE }, /* kVK_ForwardDelete */
305 { VK_F4, 0x3E, TRUE }, /* kVK_F4 */
306 { VK_END, 0x4F | 0x100, TRUE }, /* kVK_End */
307 { VK_F2, 0x3C, TRUE }, /* kVK_F2 */
308 { VK_NEXT, 0x51 | 0x100, TRUE }, /* kVK_PageDown */
309 { VK_F1, 0x3B, TRUE }, /* kVK_F1 */
310 { VK_LEFT, 0x4B | 0x100, TRUE }, /* kVK_LeftArrow */
311 { VK_RIGHT, 0x4D | 0x100, TRUE }, /* kVK_RightArrow */
312 { VK_DOWN, 0x50 | 0x100, TRUE }, /* kVK_DownArrow */
313 { VK_UP, 0x48 | 0x100, TRUE }, /* kVK_UpArrow */
314 };
315
316
317 static const struct {
318 DWORD vkey;
319 const char *name;
320 } vkey_names[] = {
321 { VK_ADD, "Num +" },
322 { VK_BACK, "Backspace" },
323 { VK_CAPITAL, "Caps Lock" },
324 { VK_CONTROL, "Ctrl" },
325 { VK_DECIMAL, "Num Del" },
326 { VK_DELETE | 0x100, "Delete" },
327 { VK_DIVIDE | 0x100, "Num /" },
328 { VK_DOWN | 0x100, "Down" },
329 { VK_END | 0x100, "End" },
330 { VK_ESCAPE, "Esc" },
331 { VK_F1, "F1" },
332 { VK_F2, "F2" },
333 { VK_F3, "F3" },
334 { VK_F4, "F4" },
335 { VK_F5, "F5" },
336 { VK_F6, "F6" },
337 { VK_F7, "F7" },
338 { VK_F8, "F8" },
339 { VK_F9, "F9" },
340 { VK_F10, "F10" },
341 { VK_F11, "F11" },
342 { VK_F12, "F12" },
343 { VK_F13, "F13" },
344 { VK_F14, "F14" },
345 { VK_F15, "F15" },
346 { VK_F16, "F16" },
347 { VK_F17, "F17" },
348 { VK_F18, "F18" },
349 { VK_F19, "F19" },
350 { VK_F20, "F20" },
351 { VK_F21, "F21" },
352 { VK_F22, "F22" },
353 { VK_F23, "F23" },
354 { VK_F24, "F24" },
355 { VK_HELP | 0x100, "Help" },
356 { VK_HOME | 0x100, "Home" },
357 { VK_INSERT | 0x100, "Insert" },
358 { VK_LCONTROL, "Ctrl" },
359 { VK_LEFT | 0x100, "Left" },
360 { VK_LMENU, "Alt" },
361 { VK_LSHIFT, "Shift" },
362 { VK_LWIN | 0x100, "Win" },
363 { VK_MENU, "Alt" },
364 { VK_MULTIPLY, "Num *" },
365 { VK_NEXT | 0x100, "Page Down" },
366 { VK_NUMLOCK | 0x100, "Num Lock" },
367 { VK_NUMPAD0, "Num 0" },
368 { VK_NUMPAD1, "Num 1" },
369 { VK_NUMPAD2, "Num 2" },
370 { VK_NUMPAD3, "Num 3" },
371 { VK_NUMPAD4, "Num 4" },
372 { VK_NUMPAD5, "Num 5" },
373 { VK_NUMPAD6, "Num 6" },
374 { VK_NUMPAD7, "Num 7" },
375 { VK_NUMPAD8, "Num 8" },
376 { VK_NUMPAD9, "Num 9" },
377 { VK_OEM_CLEAR, "Num Clear" },
378 { VK_OEM_NEC_EQUAL | 0x100, "Num =" },
379 { VK_PRIOR | 0x100, "Page Up" },
380 { VK_RCONTROL | 0x100, "Right Ctrl" },
381 { VK_RETURN, "Return" },
382 { VK_RETURN | 0x100, "Num Enter" },
383 { VK_RIGHT | 0x100, "Right" },
384 { VK_RMENU | 0x100, "Right Alt" },
385 { VK_RSHIFT, "Right Shift" },
386 { VK_RWIN | 0x100, "Right Win" },
387 { VK_SEPARATOR, "Num ," },
388 { VK_SHIFT, "Shift" },
389 { VK_SPACE, "Space" },
390 { VK_SUBTRACT, "Num -" },
391 { VK_TAB, "Tab" },
392 { VK_UP | 0x100, "Up" },
393 { VK_VOLUME_DOWN | 0x100, "Volume Down" },
394 { VK_VOLUME_MUTE | 0x100, "Mute" },
395 { VK_VOLUME_UP | 0x100, "Volume Up" },
396 };
397
398 HKL CDECL macdrv_GetKeyboardLayout(DWORD);
399
400 static BOOL char_matches_string(WCHAR wchar, UniChar *string, BOOL ignore_diacritics)
401 {
402 BOOL ret;
403 CFStringRef s1 = CFStringCreateWithCharactersNoCopy(NULL, (UniChar*)&wchar, 1, kCFAllocatorNull);
404 CFStringRef s2 = CFStringCreateWithCharactersNoCopy(NULL, string, strlenW(string), kCFAllocatorNull);
405 CFStringCompareFlags flags = kCFCompareCaseInsensitive | kCFCompareNonliteral | kCFCompareWidthInsensitive;
406 if (ignore_diacritics)
407 flags |= kCFCompareDiacriticInsensitive;
408 ret = (CFStringCompare(s1, s2, flags) == kCFCompareEqualTo);
409 CFRelease(s1);
410 CFRelease(s2);
411 return ret;
412 }
413
414
415 /* Filter Apple-specific private-use characters (see NSEvent.h) out of a
416 * string. Returns the length of the string after stripping. */
417 static int strip_apple_private_chars(LPWSTR bufW, int len)
418 {
419 int i;
420 for (i = 0; i < len; )
421 {
422 if (0xF700 <= bufW[i] && bufW[i] <= 0xF8FF)
423 {
424 memmove(&bufW[i], &bufW[i+1], (len - i - 1) * sizeof(bufW[0]));
425 len--;
426 }
427 else
428 i++;
429 }
430 return len;
431 }
432
433 static struct list layout_list = LIST_INIT( layout_list );
434 struct layout
435 {
436 struct list entry;
437 HKL hkl;
438 TISInputSourceRef input_source;
439 BOOL enabled; /* is the input source enabled - ie displayed in the input source selector UI */
440 };
441
442 static CRITICAL_SECTION layout_list_section;
443 static CRITICAL_SECTION_DEBUG critsect_debug =
444 {
445 0, 0, &layout_list_section,
446 { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
447 0, 0, { (DWORD_PTR)(__FILE__ ": layout_list_section") }
448 };
449 static CRITICAL_SECTION layout_list_section = { &critsect_debug, -1, 0, 0, 0, 0 };
450
451 int macdrv_layout_list_needs_update = TRUE;
452
453 static DWORD get_lcid(CFStringRef lang)
454 {
455 CFRange range;
456 WCHAR str[10];
457
458 range.location = 0;
459 range.length = min(CFStringGetLength(lang), ARRAY_SIZE(str) - 1);
460 CFStringGetCharacters(lang, range, str);
461 str[range.length] = 0;
462 return LocaleNameToLCID(str, 0);
463 }
464
465 static HKL get_hkl(CFStringRef lang, CFStringRef type)
466 {
467 ULONG_PTR lcid = get_lcid(lang);
468 struct layout *layout;
469
470 /* Look for the last occurrence of this lcid in the list and if
471 present use that value + 0x10000 */
472 LIST_FOR_EACH_ENTRY_REV(layout, &layout_list, struct layout, entry)
473 {
474 ULONG_PTR hkl = HandleToUlong(layout->hkl);
475
476 if (LOWORD(hkl) == lcid)
477 {
478 lcid = (hkl & ~0xe0000000) + 0x10000;
479 break;
480 }
481 }
482
483 if (!CFEqual(type, kTISTypeKeyboardLayout)) lcid |= 0xe0000000;
484
485 return (HKL)lcid;
486 }
487
488 /******************************************************************
489 * get_layout_from_source
490 *
491 * Must be called while holding the layout_list_section.
492 * Note, returned layout may not currently be enabled.
493 */
494 static struct layout *get_layout_from_source(TISInputSourceRef input)
495 {
496 struct layout *ret = NULL, *layout;
497
498 LIST_FOR_EACH_ENTRY(layout, &layout_list, struct layout, entry)
499 {
500 if (CFEqual(input, layout->input_source))
501 {
502 ret = layout;
503 break;
504 }
505 }
506 return ret;
507 }
508
509 /***********************************************************************
510 * update_layout_list
511 *
512 * Must be called while holding the layout_list_section
513 *
514 * If an input source has been disabled (ie. removed from the UI) its
515 * entry remains in the layout list but is marked as such and is not
516 * enumerated by GetKeyboardLayoutList. This is to ensure the
517 * HKL <-> input source mapping is unique.
518 */
519 static void update_layout_list(void)
520 {
521 CFArrayRef sources;
522 struct layout *layout;
523 int i;
524
525 if (!InterlockedExchange(&macdrv_layout_list_needs_update, FALSE)) return;
526
527 sources = macdrv_create_input_source_list();
528
529 LIST_FOR_EACH_ENTRY(layout, &layout_list, struct layout, entry)
530 layout->enabled = FALSE;
531
532 for (i = 0; i < CFArrayGetCount(sources); i++)
533 {
534 CFDictionaryRef dict = CFArrayGetValueAtIndex(sources, i);
535 TISInputSourceRef input = (TISInputSourceRef)CFDictionaryGetValue(dict, macdrv_input_source_input_key);
536 layout = get_layout_from_source(input);
537 if (!layout)
538 {
539 CFStringRef type = CFDictionaryGetValue(dict, macdrv_input_source_type_key);
540 CFStringRef lang = CFDictionaryGetValue(dict, macdrv_input_source_lang_key);
541
542 layout = HeapAlloc(GetProcessHeap(), 0, sizeof(*layout));
543 layout->input_source = (TISInputSourceRef)CFRetain(input);
544 layout->hkl = get_hkl(lang, type);
545
546 list_add_tail(&layout_list, &layout->entry);
547 TRACE("adding new layout %p\n", layout->hkl);
548 }
549 else
550 TRACE("enabling already existing layout %p\n", layout->hkl);
551
552 layout->enabled = TRUE;
553 }
554
555 CFRelease(sources);
556 }
557
558 /***********************************************************************
559 * macdrv_get_hkl_from_source
560 *
561 * Find the HKL associated with a given input source.
562 */
563 HKL macdrv_get_hkl_from_source(TISInputSourceRef input)
564 {
565 struct layout *layout;
566 HKL ret = 0;
567
568 EnterCriticalSection(&layout_list_section);
569
570 update_layout_list();
571 layout = get_layout_from_source(input);
572 if (layout) ret = layout->hkl;
573
574 LeaveCriticalSection(&layout_list_section);
575
576 return ret;
577 }
578
579
580 /***********************************************************************
581 * macdrv_compute_keyboard_layout
582 */
583 void macdrv_compute_keyboard_layout(struct macdrv_thread_data *thread_data)
584 {
585 int keyc;
586 WCHAR vkey;
587 const UCKeyboardLayout *uchr;
588 const UInt32 modifier_combos[] = {
589 0,
590 shiftKey >> 8,
591 cmdKey >> 8,
592 (shiftKey | cmdKey) >> 8,
593 optionKey >> 8,
594 (shiftKey | optionKey) >> 8,
595 };
596 UniChar map[128][ARRAY_SIZE(modifier_combos)][4 + 1];
597 int combo;
598 BYTE vkey_used[256];
599 int ignore_diacritics;
600 static const struct {
601 WCHAR wchar;
602 DWORD vkey;
603 } symbol_vkeys[] = {
604 { '-', VK_OEM_MINUS },
605 { '+', VK_OEM_PLUS },
606 { '_', VK_OEM_MINUS },
607 { ',', VK_OEM_COMMA },
608 { '.', VK_OEM_PERIOD },
609 { '=', VK_OEM_PLUS },
610 { '>', VK_OEM_PERIOD },
611 { '<', VK_OEM_COMMA },
612 { '|', VK_OEM_5 },
613 { '\\', VK_OEM_5 },
614 { '`', VK_OEM_3 },
615 { '[', VK_OEM_4 },
616 { '~', VK_OEM_3 },
617 { '?', VK_OEM_2 },
618 { ']', VK_OEM_6 },
619 { '/', VK_OEM_2 },
620 { ':', VK_OEM_1 },
621 { '}', VK_OEM_6 },
622 { '{', VK_OEM_4 },
623 { ';', VK_OEM_1 },
624 { '\'', VK_OEM_7 },
625 { ':', VK_OEM_PERIOD },
626 { ';', VK_OEM_COMMA },
627 { '"', VK_OEM_7 },
628 { 0x00B4, VK_OEM_4 }, /* 0x00B4 is ACUTE ACCENT */
629 { '\'', VK_OEM_2 },
630 { 0x00A7, VK_OEM_5 }, /* 0x00A7 is SECTION SIGN */
631 { '*', VK_OEM_PLUS },
632 { 0x00B4, VK_OEM_7 },
633 { '`', VK_OEM_4 },
634 { '[', VK_OEM_6 },
635 { '/', VK_OEM_5 },
636 { '^', VK_OEM_6 },
637 { '*', VK_OEM_2 },
638 { '{', VK_OEM_6 },
639 { '~', VK_OEM_1 },
640 { '?', VK_OEM_PLUS },
641 { '?', VK_OEM_4 },
642 { 0x00B4, VK_OEM_3 },
643 { '?', VK_OEM_COMMA },
644 { '~', VK_OEM_PLUS },
645 { ']', VK_OEM_4 },
646 { '\'', VK_OEM_3 },
647 { 0x00A7, VK_OEM_7 },
648 };
649 int i;
650
651 /* Vkeys that are suitable for assigning to arbitrary keys, organized in
652 contiguous ranges. */
653 static const struct {
654 WORD first, last;
655 } vkey_ranges[] = {
656 { 'A', 'Z' },
657 { '0', '9' },
658 { VK_OEM_1, VK_OEM_3 },
659 { VK_OEM_4, VK_ICO_CLEAR },
660 { 0xe9, 0xf5 },
661 { VK_OEM_NEC_EQUAL, VK_OEM_NEC_EQUAL },
662 { VK_F1, VK_F24 },
663 { 0, 0 }
664 };
665 int vkey_range;
666
667 if (!thread_data->keyboard_layout_uchr)
668 {
669 ERR("no keyboard layout UCHR data\n");
670 return;
671 }
672
673 memset(thread_data->keyc2vkey, 0, sizeof(thread_data->keyc2vkey));
674 memset(vkey_used, 0, sizeof(vkey_used));
675
676 for (keyc = 0; keyc < ARRAY_SIZE(default_map); keyc++)
677 {
678 thread_data->keyc2scan[keyc] = default_map[keyc].scan;
679 if (default_map[keyc].fixed)
680 {
681 vkey = default_map[keyc].vkey;
682 thread_data->keyc2vkey[keyc] = vkey;
683 vkey_used[vkey] = 1;
684 TRACE("keyc 0x%04x -> vkey 0x%04x (fixed)\n", keyc, vkey);
685 }
686 }
687
688 if (thread_data->iso_keyboard)
689 {
690 /* In almost all cases, the Mac key codes indicate a physical key position
691 and this corresponds nicely to Win32 scan codes. However, the Mac key
692 codes differ in one case between ANSI and ISO keyboards. For ANSI
693 keyboards, the key to the left of the digits and above the Tab key
694 produces key code kVK_ANSI_Grave. For ISO keyboards, the key in that
695 some position produces kVK_ISO_Section. The additional key on ISO
696 keyboards, the one to the right of the left Shift key, produces
697 kVK_ANSI_Grave, which is just weird.
698
699 Since we want the key in that upper left corner to always produce the
700 same scan code (0x29), we need to swap the scan codes of those two
701 Mac key codes for ISO keyboards. */
702 DWORD temp = thread_data->keyc2scan[kVK_ANSI_Grave];
703 thread_data->keyc2scan[kVK_ANSI_Grave] = thread_data->keyc2scan[kVK_ISO_Section];
704 thread_data->keyc2scan[kVK_ISO_Section] = temp;
705 }
706
707 uchr = (const UCKeyboardLayout*)CFDataGetBytePtr(thread_data->keyboard_layout_uchr);
708
709 /* Using the keyboard layout, build a map of key code + modifiers -> characters. */
710 memset(map, 0, sizeof(map));
711 for (keyc = 0; keyc < ARRAY_SIZE(map); keyc++)
712 {
713 if (!thread_data->keyc2scan[keyc]) continue; /* not a known Mac key code */
714 if (thread_data->keyc2vkey[keyc]) continue; /* assigned a fixed vkey */
715
716 TRACE("keyc 0x%04x: ", keyc);
717
718 for (combo = 0; combo < ARRAY_SIZE(modifier_combos); combo++)
719 {
720 UInt32 deadKeyState;
721 UniCharCount len;
722 OSStatus status;
723
724 deadKeyState = 0;
725 status = UCKeyTranslate(uchr, keyc, kUCKeyActionDown, modifier_combos[combo],
726 thread_data->keyboard_type, kUCKeyTranslateNoDeadKeysMask,
727 &deadKeyState, ARRAY_SIZE(map[keyc][combo]) - 1, &len, map[keyc][combo]);
728 if (status != noErr)
729 map[keyc][combo][0] = 0;
730
731 TRACE("%s%s", (combo ? ", " : ""), debugstr_w(map[keyc][combo]));
732 }
733
734 TRACE("\n");
735 }
736
737 /* First try to match key codes to the vkeys for the letters A through Z.
738 Try unmodified first, then with various modifier combinations in succession.
739 On the first pass, try to get a match lacking diacritical marks. On the
740 second pass, accept matches with diacritical marks. */
741 for (ignore_diacritics = 0; ignore_diacritics <= 1; ignore_diacritics++)
742 {
743 for (combo = 0; combo < ARRAY_SIZE(modifier_combos); combo++)
744 {
745 for (vkey = 'A'; vkey <= 'Z'; vkey++)
746 {
747 if (vkey_used[vkey])
748 continue;
749
750 for (keyc = 0; keyc < ARRAY_SIZE(map); keyc++)
751 {
752 if (thread_data->keyc2vkey[keyc] || !map[keyc][combo][0])
753 continue;
754
755 if (char_matches_string(vkey, map[keyc][combo], ignore_diacritics))
756 {
757 thread_data->keyc2vkey[keyc] = vkey;
758 vkey_used[vkey] = 1;
759 TRACE("keyc 0x%04x -> vkey 0x%04x (%s match %s)\n", keyc, vkey,
760 debugstr_wn(&vkey, 1), debugstr_w(map[keyc][combo]));
761 break;
762 }
763 }
764 }
765 }
766 }
767
768 /* Next try to match key codes to the vkeys for the digits 0 through 9. */
769 for (combo = 0; combo < ARRAY_SIZE(modifier_combos); combo++)
770 {
771 for (vkey = '0'; vkey <= '9'; vkey++)
772 {
773 if (vkey_used[vkey])
774 continue;
775
776 for (keyc = 0; keyc < ARRAY_SIZE(map); keyc++)
777 {
778 if (thread_data->keyc2vkey[keyc] || !map[keyc][combo][0])
779 continue;
780
781 if (char_matches_string(vkey, map[keyc][combo], FALSE))
782 {
783 thread_data->keyc2vkey[keyc] = vkey;
784 vkey_used[vkey] = 1;
785 TRACE("keyc 0x%04x -> vkey 0x%04x (%s match %s)\n", keyc, vkey,
786 debugstr_wn(&vkey, 1), debugstr_w(map[keyc][combo]));
787 break;
788 }
789 }
790 }
791 }
792
793 /* Now try to match key codes for certain common punctuation characters to
794 the most common OEM vkeys (e.g. '.' to VK_OEM_PERIOD). */
795 for (i = 0; i < ARRAY_SIZE(symbol_vkeys); i++)
796 {
797 vkey = symbol_vkeys[i].vkey;
798
799 if (vkey_used[vkey])
800 continue;
801
802 for (combo = 0; combo < ARRAY_SIZE(modifier_combos); combo++)
803 {
804 for (keyc = 0; keyc < ARRAY_SIZE(map); keyc++)
805 {
806 if (!thread_data->keyc2scan[keyc]) continue; /* not a known Mac key code */
807 if (thread_data->keyc2vkey[keyc] || !map[keyc][combo][0])
808 continue;
809
810 if (char_matches_string(symbol_vkeys[i].wchar, map[keyc][combo], FALSE))
811 {
812 thread_data->keyc2vkey[keyc] = vkey;
813 vkey_used[vkey] = 1;
814 TRACE("keyc 0x%04x -> vkey 0x%04x (%s match %s)\n", keyc, vkey,
815 debugstr_wn(&symbol_vkeys[i].wchar, 1), debugstr_w(map[keyc][combo]));
816 break;
817 }
818 }
819
820 if (vkey_used[vkey])
821 break;
822 }
823 }
824
825 /* For those key codes still without a vkey, try to use the default vkey
826 from the default map, if it's still available. */
827 for (keyc = 0; keyc < ARRAY_SIZE(default_map); keyc++)
828 {
829 DWORD vkey = default_map[keyc].vkey;
830
831 if (!thread_data->keyc2scan[keyc]) continue; /* not a known Mac key code */
832 if (thread_data->keyc2vkey[keyc]) continue; /* already assigned */
833
834 if (!vkey_used[vkey])
835 {
836 thread_data->keyc2vkey[keyc] = vkey;
837 vkey_used[vkey] = 1;
838 TRACE("keyc 0x%04x -> vkey 0x%04x (default map)\n", keyc, vkey);
839 }
840 }
841
842 /* For any unassigned key codes which would map to a letter in the default
843 map, but whose normal letter vkey wasn't available, try to find a
844 different letter. */
845 vkey = 'A';
846 for (keyc = 0; keyc < ARRAY_SIZE(default_map); keyc++)
847 {
848 if (default_map[keyc].vkey < 'A' || 'Z' < default_map[keyc].vkey)
849 continue; /* not a letter in ANSI layout */
850 if (!thread_data->keyc2scan[keyc]) continue; /* not a known Mac key code */
851 if (thread_data->keyc2vkey[keyc]) continue; /* already assigned */
852
853 while (vkey <= 'Z' && vkey_used[vkey]) vkey++;
854 if (vkey <= 'Z')
855 {
856 thread_data->keyc2vkey[keyc] = vkey;
857 vkey_used[vkey] = 1;
858 TRACE("keyc 0x%04x -> vkey 0x%04x (spare letter)\n", keyc, vkey);
859 }
860 else
861 break; /* no more unused letter vkeys, so stop trying */
862 }
863
864 /* Same thing but with the digits. */
865 vkey = '0';
866 for (keyc = 0; keyc < ARRAY_SIZE(default_map); keyc++)
867 {
868 if (default_map[keyc].vkey < '0' || '9' < default_map[keyc].vkey)
869 continue; /* not a digit in ANSI layout */
870 if (!thread_data->keyc2scan[keyc]) continue; /* not a known Mac key code */
871 if (thread_data->keyc2vkey[keyc]) continue; /* already assigned */
872
873 while (vkey <= '9' && vkey_used[vkey]) vkey++;
874 if (vkey <= '9')
875 {
876 thread_data->keyc2vkey[keyc] = vkey;
877 vkey_used[vkey] = 1;
878 TRACE("keyc 0x%04x -> vkey 0x%04x (spare digit)\n", keyc, vkey);
879 }
880 else
881 break; /* no more unused digit vkeys, so stop trying */
882 }
883
884 /* Last chance. Assign any available vkey. */
885 vkey_range = 0;
886 vkey = vkey_ranges[vkey_range].first;
887 for (keyc = 0; keyc < ARRAY_SIZE(default_map); keyc++)
888 {
889 if (!thread_data->keyc2scan[keyc]) continue; /* not a known Mac key code */
890 if (thread_data->keyc2vkey[keyc]) continue; /* already assigned */
891
892 while (vkey && vkey_used[vkey])
893 {
894 if (vkey == vkey_ranges[vkey_range].last)
895 {
896 vkey_range++;
897 vkey = vkey_ranges[vkey_range].first;
898 }
899 else
900 vkey++;
901 }
902
903 if (!vkey)
904 {
905 WARN("No more vkeys available!\n");
906 break;
907 }
908
909 thread_data->keyc2vkey[keyc] = vkey;
910 vkey_used[vkey] = 1;
911 TRACE("keyc 0x%04x -> vkey 0x%04x (spare vkey)\n", keyc, vkey);
912 }
913 }
914
915
916 /***********************************************************************
917 * macdrv_send_keyboard_input
918 */
919 static void macdrv_send_keyboard_input(HWND hwnd, WORD vkey, WORD scan, DWORD flags, DWORD time)
920 {
921 INPUT input;
922
923 TRACE_(key)("hwnd %p vkey=%04x scan=%04x flags=%04x\n", hwnd, vkey, scan, flags);
924
925 input.type = INPUT_KEYBOARD;
926 input.ki.wVk = vkey;
927 input.ki.wScan = scan;
928 input.ki.dwFlags = flags;
929 input.ki.time = time;
930 input.ki.dwExtraInfo = 0;
931
932 __wine_send_input(hwnd, &input);
933 }
934
935
936 /***********************************************************************
937 * get_async_key_state
938 */
939 static BOOL get_async_key_state(BYTE state[256])
940 {
941 BOOL ret;
942
943 SERVER_START_REQ(get_key_state)
944 {
945 req->tid = 0;
946 req->key = -1;
947 wine_server_set_reply(req, state, 256);
948 ret = !wine_server_call(req);
949 }
950 SERVER_END_REQ;
951 return ret;
952 }
953
954
955 /***********************************************************************
956 * update_modifier_state
957 */
958 static void update_modifier_state(unsigned int modifier, unsigned int modifiers, const BYTE *keystate,
959 WORD vkey, WORD alt_vkey, WORD scan, WORD alt_scan,
960 DWORD event_time, BOOL restore)
961 {
962 int key_pressed = (modifiers & modifier) != 0;
963 int vkey_pressed = (keystate[vkey] & 0x80) || (keystate[alt_vkey] & 0x80);
964 DWORD flags;
965
966 if (key_pressed != vkey_pressed)
967 {
968 if (key_pressed)
969 {
970 flags = (scan & 0x100) ? KEYEVENTF_EXTENDEDKEY : 0;
971 if (restore)
972 flags |= KEYEVENTF_KEYUP;
973
974 macdrv_send_keyboard_input(NULL, vkey, scan & 0xff, flags, event_time);
975 }
976 else
977 {
978 flags = restore ? 0 : KEYEVENTF_KEYUP;
979
980 if (keystate[vkey] & 0x80)
981 {
982 macdrv_send_keyboard_input(NULL, vkey, scan & 0xff,
983 flags | ((scan & 0x100) ? KEYEVENTF_EXTENDEDKEY : 0),
984 event_time);
985 }
986 if (keystate[alt_vkey] & 0x80)
987 {
988 macdrv_send_keyboard_input(NULL, alt_vkey, alt_scan & 0xff,
989 flags | ((alt_scan & 0x100) ? KEYEVENTF_EXTENDEDKEY : 0),
990 event_time);
991 }
992 }
993 }
994 }
995
996
997 /***********************************************************************
998 * macdrv_key_event
999 *
1000 * Handler for KEY_PRESS and KEY_RELEASE events.
1001 */
1002 void macdrv_key_event(HWND hwnd, const macdrv_event *event)
1003 {
1004 struct macdrv_thread_data *thread_data = macdrv_thread_data();
1005 WORD vkey, scan;
1006 DWORD flags;
1007
1008 TRACE_(key)("win %p/%p key %s keycode %hu modifiers 0x%08llx\n",
1009 hwnd, event->window, (event->type == KEY_PRESS ? "press" : "release"),
1010 event->key.keycode, event->key.modifiers);
1011
1012 thread_data->last_modifiers = event->key.modifiers;
1013
1014 if (event->key.keycode < ARRAY_SIZE(thread_data->keyc2vkey))
1015 {
1016 vkey = thread_data->keyc2vkey[event->key.keycode];
1017 scan = thread_data->keyc2scan[event->key.keycode];
1018 }
1019 else
1020 vkey = scan = 0;
1021
1022 TRACE_(key)("keycode %hu converted to vkey 0x%X scan 0x%02x\n",
1023 event->key.keycode, vkey, scan);
1024
1025 if (!vkey) return;
1026
1027 flags = 0;
1028 if (event->type == KEY_RELEASE) flags |= KEYEVENTF_KEYUP;
1029 if (scan & 0x100) flags |= KEYEVENTF_EXTENDEDKEY;
1030
1031 macdrv_send_keyboard_input(hwnd, vkey, scan & 0xff, flags, event->key.time_ms);
1032 }
1033
1034
1035 /***********************************************************************
1036 * macdrv_keyboard_changed
1037 *
1038 * Handler for KEYBOARD_CHANGED events.
1039 */
1040 void macdrv_keyboard_changed(const macdrv_event *event)
1041 {
1042 struct macdrv_thread_data *thread_data = macdrv_thread_data();
1043
1044 TRACE("new keyboard layout uchr data %p, type %u, iso %d\n", event->keyboard_changed.uchr,
1045 event->keyboard_changed.keyboard_type, event->keyboard_changed.iso_keyboard);
1046
1047 if (thread_data->keyboard_layout_uchr)
1048 CFRelease(thread_data->keyboard_layout_uchr);
1049 thread_data->keyboard_layout_uchr = CFDataCreateCopy(NULL, event->keyboard_changed.uchr);
1050 thread_data->keyboard_type = event->keyboard_changed.keyboard_type;
1051 thread_data->iso_keyboard = event->keyboard_changed.iso_keyboard;
1052 thread_data->active_keyboard_layout = macdrv_get_hkl_from_source(event->keyboard_changed.input_source);
1053 thread_data->dead_key_state = 0;
1054
1055 macdrv_compute_keyboard_layout(thread_data);
1056
1057 SendMessageW(GetActiveWindow(), WM_CANCELMODE, 0, 0);
1058 }
1059
1060
1061 /***********************************************************************
1062 * macdrv_hotkey_press
1063 *
1064 * Handler for HOTKEY_PRESS events.
1065 */
1066 void macdrv_hotkey_press(const macdrv_event *event)
1067 {
1068 struct macdrv_thread_data *thread_data = macdrv_thread_data();
1069
1070 TRACE_(key)("vkey 0x%04x mod_flags 0x%04x keycode 0x%04x time %lu\n",
1071 event->hotkey_press.vkey, event->hotkey_press.mod_flags, event->hotkey_press.keycode,
1072 event->hotkey_press.time_ms);
1073
1074 if (event->hotkey_press.keycode < ARRAY_SIZE(thread_data->keyc2vkey))
1075 {
1076 WORD scan = thread_data->keyc2scan[event->hotkey_press.keycode];
1077 BYTE keystate[256];
1078 BOOL got_keystate;
1079 DWORD flags;
1080
1081 if ((got_keystate = get_async_key_state(keystate)))
1082 {
1083 update_modifier_state(MOD_ALT, event->hotkey_press.mod_flags, keystate, VK_LMENU, VK_RMENU,
1084 0x38, 0x138, event->hotkey_press.time_ms, FALSE);
1085 update_modifier_state(MOD_CONTROL, event->hotkey_press.mod_flags, keystate, VK_LCONTROL, VK_RCONTROL,
1086 0x1D, 0x11D, event->hotkey_press.time_ms, FALSE);
1087 update_modifier_state(MOD_SHIFT, event->hotkey_press.mod_flags, keystate, VK_LSHIFT, VK_RSHIFT,
1088 0x2A, 0x36, event->hotkey_press.time_ms, FALSE);
1089 update_modifier_state(MOD_WIN, event->hotkey_press.mod_flags, keystate, VK_LWIN, VK_RWIN,
1090 0x15B, 0x15C, event->hotkey_press.time_ms, FALSE);
1091 }
1092
1093 activate_on_following_focus();
1094
1095 flags = (scan & 0x100) ? KEYEVENTF_EXTENDEDKEY : 0;
1096 macdrv_send_keyboard_input(NULL, event->hotkey_press.vkey, scan & 0xff,
1097 flags, event->key.time_ms);
1098 macdrv_send_keyboard_input(NULL, event->hotkey_press.vkey, scan & 0xff,
1099 flags | KEYEVENTF_KEYUP, event->key.time_ms);
1100
1101 if (got_keystate)
1102 {
1103 update_modifier_state(MOD_ALT, event->hotkey_press.mod_flags, keystate, VK_LMENU, VK_RMENU,
1104 0x38, 0x138, event->hotkey_press.time_ms, TRUE);
1105 update_modifier_state(MOD_CONTROL, event->hotkey_press.mod_flags, keystate, VK_LCONTROL, VK_RCONTROL,
1106 0x1D, 0x11D, event->hotkey_press.time_ms, TRUE);
1107 update_modifier_state(MOD_SHIFT, event->hotkey_press.mod_flags, keystate, VK_LSHIFT, VK_RSHIFT,
1108 0x2A, 0x36, event->hotkey_press.time_ms, TRUE);
1109 update_modifier_state(MOD_WIN, event->hotkey_press.mod_flags, keystate, VK_LWIN, VK_RWIN,
1110 0x15B, 0x15C, event->hotkey_press.time_ms, TRUE);
1111 }
1112 }
1113 }
1114
1115
1116 /***********************************************************************
1117 * macdrv_process_text_input
1118 */
1119 void macdrv_process_text_input(UINT vkey, UINT scan, UINT repeat, const BYTE *key_state, void *himc, int* done)
1120 {
1121 struct macdrv_thread_data *thread_data = macdrv_thread_data();
1122 unsigned int flags;
1123 int keyc;
1124
1125 TRACE("vkey 0x%04x scan 0x%04x repeat %u himc %p\n", vkey, scan, repeat, himc);
1126
1127 flags = thread_data->last_modifiers;
1128 if (key_state[VK_SHIFT] & 0x80)
1129 flags |= NX_SHIFTMASK;
1130 else
1131 flags &= ~(NX_SHIFTMASK | NX_DEVICELSHIFTKEYMASK | NX_DEVICERSHIFTKEYMASK);
1132 if (key_state[VK_CAPITAL] & 0x01)
1133 flags |= NX_ALPHASHIFTMASK;
1134 else
1135 flags &= ~NX_ALPHASHIFTMASK;
1136 if (key_state[VK_CONTROL] & 0x80)
1137 flags |= NX_CONTROLMASK;
1138 else
1139 flags &= ~(NX_CONTROLMASK | NX_DEVICELCTLKEYMASK | NX_DEVICERCTLKEYMASK);
1140 if (key_state[VK_MENU] & 0x80)
1141 flags |= NX_COMMANDMASK;
1142 else
1143 flags &= ~(NX_COMMANDMASK | NX_DEVICELCMDKEYMASK | NX_DEVICERCMDKEYMASK);
1144
1145 /* Find the Mac keycode corresponding to the scan code */
1146 for (keyc = 0; keyc < ARRAY_SIZE(thread_data->keyc2vkey); keyc++)
1147 if (thread_data->keyc2vkey[keyc] == vkey) break;
1148
1149 if (keyc >= ARRAY_SIZE(thread_data->keyc2vkey))
1150 {
1151 *done = -1;
1152 return;
1153 }
1154
1155 TRACE("flags 0x%08x keyc 0x%04x\n", flags, keyc);
1156
1157 macdrv_send_text_input_event(((scan & 0x8000) == 0), flags, repeat, keyc, himc, done);
1158 }
1159
1160
1161 /***********************************************************************
1162 * ActivateKeyboardLayout (MACDRV.@)
1163 */
1164 HKL CDECL macdrv_ActivateKeyboardLayout(HKL hkl, UINT flags)
1165 {
1166 HKL oldHkl = 0;
1167 struct macdrv_thread_data *thread_data = macdrv_init_thread_data();
1168 struct layout *layout;
1169
1170 TRACE("hkl %p flags %04x\n", hkl, flags);
1171
1172 if (flags) FIXME("flags %x not supported\n",flags);
1173
1174 if (hkl == (HKL)HKL_NEXT || hkl == (HKL)HKL_PREV)
1175 {
1176 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1177 FIXME("HKL_NEXT and HKL_PREV not supported\n");
1178 return 0;
1179 }
1180
1181 EnterCriticalSection(&layout_list_section);
1182 update_layout_list();
1183
1184 LIST_FOR_EACH_ENTRY(layout, &layout_list, struct layout, entry)
1185 {
1186 if (layout->hkl == hkl)
1187 {
1188 if (macdrv_select_input_source(layout->input_source))
1189 {
1190 oldHkl = thread_data->active_keyboard_layout;
1191 if (thread_data->keyboard_layout_uchr)
1192 CFRelease(thread_data->keyboard_layout_uchr);
1193
1194 macdrv_get_input_source_info(&thread_data->keyboard_layout_uchr, &thread_data->keyboard_type,
1195 &thread_data->iso_keyboard, NULL);
1196 thread_data->active_keyboard_layout = hkl;
1197 thread_data->dead_key_state = 0;
1198
1199 macdrv_compute_keyboard_layout(thread_data);
1200 }
1201 break;
1202 }
1203 }
1204 LeaveCriticalSection(&layout_list_section);
1205
1206 return oldHkl;
1207 }
1208
1209
1210 /***********************************************************************
1211 * Beep (MACDRV.@)
1212 */
1213 void CDECL macdrv_Beep(void)
1214 {
1215 macdrv_beep();
1216 }
1217
1218
1219 /***********************************************************************
1220 * GetKeyNameText (MACDRV.@)
1221 */
1222 INT CDECL macdrv_GetKeyNameText(LONG lparam, LPWSTR buffer, INT size)
1223 {
1224 struct macdrv_thread_data *thread_data = macdrv_init_thread_data();
1225 int scan, keyc;
1226
1227 scan = (lparam >> 16) & 0x1FF;
1228 for (keyc = 0; keyc < ARRAY_SIZE(thread_data->keyc2scan); keyc++)
1229 {
1230 if (thread_data->keyc2scan[keyc] == scan)
1231 {
1232 static const WCHAR dead[] = {' ','d','e','a','d',0};
1233 const UCKeyboardLayout *uchr;
1234 UInt32 deadKeyState = 0;
1235 UniCharCount len;
1236 OSStatus status;
1237 DWORD vkey;
1238 int i;
1239
1240 uchr = (const UCKeyboardLayout*)CFDataGetBytePtr(thread_data->keyboard_layout_uchr);
1241 status = UCKeyTranslate(uchr, keyc, kUCKeyActionDisplay, 0, thread_data->keyboard_type,
1242 0, &deadKeyState, size - 1, &len, (UniChar*)buffer);
1243 if (status != noErr)
1244 len = 0;
1245 if (len && isgraphW(buffer[0]))
1246 buffer[len] = 0;
1247
1248 vkey = thread_data->keyc2vkey[keyc];
1249 if (lparam & (1 << 25))
1250 {
1251 /* Caller doesn't care about distinctions between left and
1252 right keys. */
1253 switch (vkey)
1254 {
1255 case VK_LSHIFT:
1256 case VK_RSHIFT:
1257 vkey = VK_SHIFT; break;
1258 case VK_LCONTROL:
1259 case VK_RCONTROL:
1260 vkey = VK_CONTROL; break;
1261 case VK_LMENU:
1262 case VK_RMENU:
1263 vkey = VK_MENU; break;
1264 }
1265 }
1266
1267 if (scan & 0x100) vkey |= 0x100;
1268
1269 for (i = 0; i < ARRAY_SIZE(vkey_names); i++)
1270 {
1271 if (vkey_names[i].vkey == vkey)
1272 {
1273 len = MultiByteToWideChar(CP_UTF8, 0, vkey_names[i].name, -1, buffer, size);
1274 if (len) len--;
1275 break;
1276 }
1277 }
1278
1279 if (!len)
1280 {
1281 static const WCHAR format[] = {'K','e','y',' ','0','x','%','0','2','x',0};
1282 snprintfW(buffer, size, format, vkey);
1283 len = strlenW(buffer);
1284 }
1285
1286 if (!len)
1287 break;
1288
1289 if (status == noErr && deadKeyState)
1290 {
1291 lstrcpynW(buffer + len, dead, size - len);
1292 len = strlenW(buffer);
1293 }
1294
1295 TRACE("lparam 0x%08x -> %s\n", lparam, debugstr_w(buffer));
1296 return len;
1297 }
1298 }
1299
1300 WARN("found no name for lparam 0x%08x\n", lparam);
1301 return 0;
1302 }
1303
1304
1305 /***********************************************************************
1306 * GetKeyboardLayout (MACDRV.@)
1307 */
1308 HKL CDECL macdrv_GetKeyboardLayout(DWORD thread_id)
1309 {
1310 if (thread_id && thread_id != GetCurrentThreadId())
1311 FIXME("couldn't return keyboard layout for thread %04x\n", thread_id);
1312
1313 return macdrv_init_thread_data()->active_keyboard_layout;
1314 }
1315
1316
1317 /***********************************************************************
1318 * GetKeyboardLayoutList (MACDRV.@)
1319 */
1320 UINT CDECL macdrv_GetKeyboardLayoutList(INT size, HKL *list)
1321 {
1322 int count = 0;
1323 struct layout *layout;
1324
1325 TRACE("%d, %p\n", size, list);
1326
1327 EnterCriticalSection(&layout_list_section);
1328
1329 update_layout_list();
1330
1331 LIST_FOR_EACH_ENTRY(layout, &layout_list, struct layout, entry)
1332 {
1333 if (!layout->enabled) continue;
1334 if (list)
1335 {
1336 if (count >= size) break;
1337 list[count] = layout->hkl;
1338 TRACE("\t%d: %p\n", count, list[count]);
1339 }
1340 count++;
1341 }
1342 LeaveCriticalSection(&layout_list_section);
1343
1344 TRACE("returning %d\n", count);
1345 return count;
1346 }
1347
1348 /***********************************************************************
1349 * GetKeyboardLayoutName (MACDRV.@)
1350 */
1351 BOOL CDECL macdrv_GetKeyboardLayoutName(LPWSTR name)
1352 {
1353 static const WCHAR formatW[] = {'%','0','8','x',0};
1354 DWORD layout;
1355
1356 layout = HandleToUlong(macdrv_GetKeyboardLayout(0));
1357 if (HIWORD(layout) == LOWORD(layout)) layout = LOWORD(layout);
1358 sprintfW(name, formatW, layout);
1359 TRACE("returning %s\n", debugstr_w(name));
1360 return TRUE;
1361 }
1362
1363
1364 /***********************************************************************
1365 * MapVirtualKeyEx (MACDRV.@)
1366 */
1367 UINT CDECL macdrv_MapVirtualKeyEx(UINT wCode, UINT wMapType, HKL hkl)
1368 {
1369 struct macdrv_thread_data *thread_data = macdrv_init_thread_data();
1370 UINT ret = 0;
1371 int keyc;
1372
1373 TRACE("wCode=0x%x, wMapType=%d, hkl %p\n", wCode, wMapType, hkl);
1374
1375 switch (wMapType)
1376 {
1377 case MAPVK_VK_TO_VSC: /* vkey-code to scan-code */
1378 case MAPVK_VK_TO_VSC_EX:
1379 switch (wCode)
1380 {
1381 case VK_SHIFT: wCode = VK_LSHIFT; break;
1382 case VK_CONTROL: wCode = VK_LCONTROL; break;
1383 case VK_MENU: wCode = VK_LMENU; break;
1384 }
1385
1386 /* vkey -> keycode -> scan */
1387 for (keyc = 0; keyc < ARRAY_SIZE(thread_data->keyc2vkey); keyc++)
1388 {
1389 if (thread_data->keyc2vkey[keyc] == wCode)
1390 {
1391 ret = thread_data->keyc2scan[keyc] & 0xFF;
1392 break;
1393 }
1394 }
1395 break;
1396
1397 case MAPVK_VSC_TO_VK: /* scan-code to vkey-code */
1398 case MAPVK_VSC_TO_VK_EX:
1399 /* scan -> keycode -> vkey */
1400 for (keyc = 0; keyc < ARRAY_SIZE(thread_data->keyc2vkey); keyc++)
1401 if ((thread_data->keyc2scan[keyc] & 0xFF) == (wCode & 0xFF))
1402 {
1403 ret = thread_data->keyc2vkey[keyc];
1404 /* Only stop if it's not a numpad vkey; otherwise keep
1405 looking for a potential better vkey. */
1406 if (ret && (ret < VK_NUMPAD0 || VK_DIVIDE < ret))
1407 break;
1408 }
1409
1410 if (wMapType == MAPVK_VSC_TO_VK)
1411 switch (ret)
1412 {
1413 case VK_LSHIFT:
1414 case VK_RSHIFT:
1415 ret = VK_SHIFT; break;
1416 case VK_LCONTROL:
1417 case VK_RCONTROL:
1418 ret = VK_CONTROL; break;
1419 case VK_LMENU:
1420 case VK_RMENU:
1421 ret = VK_MENU; break;
1422 }
1423
1424 break;
1425
1426 case MAPVK_VK_TO_CHAR: /* vkey-code to character */
1427 {
1428 /* vkey -> keycode -> (UCKeyTranslate) wide char */
1429 struct macdrv_thread_data *thread_data = macdrv_thread_data();
1430 const UCKeyboardLayout *uchr;
1431 UniChar s[10];
1432 OSStatus status;
1433 UInt32 deadKeyState;
1434 UniCharCount len;
1435 BOOL deadKey = FALSE;
1436
1437 if ((VK_PRIOR <= wCode && wCode <= VK_HELP) ||
1438 (VK_F1 <= wCode && wCode <= VK_F24))
1439 break;
1440
1441 if (!thread_data || !thread_data->keyboard_layout_uchr)
1442 {
1443 WARN("No keyboard layout uchr data\n");
1444 break;
1445 }
1446
1447 uchr = (const UCKeyboardLayout*)CFDataGetBytePtr(thread_data->keyboard_layout_uchr);
1448
1449 /* Find the Mac keycode corresponding to the vkey */
1450 for (keyc = 0; keyc < ARRAY_SIZE(thread_data->keyc2vkey); keyc++)
1451 if (thread_data->keyc2vkey[keyc] == wCode) break;
1452
1453 if (keyc >= ARRAY_SIZE(thread_data->keyc2vkey))
1454 {
1455 WARN("Unknown virtual key %X\n", wCode);
1456 break;
1457 }
1458
1459 TRACE("Found keycode %u\n", keyc);
1460
1461 deadKeyState = 0;
1462 status = UCKeyTranslate(uchr, keyc, kUCKeyActionDown, 0,
1463 thread_data->keyboard_type, 0, &deadKeyState, ARRAY_SIZE(s), &len, s);
1464 if (status == noErr && !len && deadKeyState)
1465 {
1466 deadKey = TRUE;
1467 deadKeyState = 0;
1468 status = UCKeyTranslate(uchr, keyc, kUCKeyActionDown, 0,
1469 thread_data->keyboard_type, kUCKeyTranslateNoDeadKeysMask,
1470 &deadKeyState, ARRAY_SIZE(s), &len, s);
1471 }
1472
1473 if (status == noErr && len)
1474 ret = toupperW(s[0]) | (deadKey ? 0x80000000 : 0);
1475
1476 break;
1477 }
1478 default: /* reserved */
1479 FIXME("Unknown wMapType %d\n", wMapType);
1480 break;
1481 }
1482
1483 TRACE("returning 0x%04x\n", ret);
1484 return ret;
1485 }
1486
1487
1488 /***********************************************************************
1489 * RegisterHotKey (MACDRV.@)
1490 */
1491 BOOL CDECL macdrv_RegisterHotKey(HWND hwnd, UINT mod_flags, UINT vkey)
1492 {
1493 struct macdrv_thread_data *thread_data = macdrv_init_thread_data();
1494 unsigned int keyc, modifiers = 0;
1495 int ret;
1496
1497 TRACE_(key)("hwnd %p mod_flags 0x%04x vkey 0x%04x\n", hwnd, mod_flags, vkey);
1498
1499 /* Find the Mac keycode corresponding to the vkey */
1500 for (keyc = 0; keyc < ARRAY_SIZE(thread_data->keyc2vkey); keyc++)
1501 if (thread_data->keyc2vkey[keyc] == vkey) break;
1502
1503 if (keyc >= ARRAY_SIZE(thread_data->keyc2vkey))
1504 {
1505 WARN_(key)("ignoring unknown virtual key 0x%04x\n", vkey);
1506 return TRUE;
1507 }
1508
1509 if (mod_flags & MOD_ALT) modifiers |= cmdKey;
1510 if (mod_flags & MOD_CONTROL) modifiers |= controlKey;
1511 if (mod_flags & MOD_SHIFT) modifiers |= shiftKey;
1512 if (mod_flags & MOD_WIN)
1513 {
1514 WARN_(key)("MOD_WIN not supported; ignoring\n");
1515 return TRUE;
1516 }
1517
1518 ret = macdrv_register_hot_key(thread_data->queue, vkey, mod_flags, keyc, modifiers);
1519 TRACE_(key)("keyc 0x%04x modifiers 0x%08x -> %d\n", keyc, modifiers, ret);
1520
1521 if (ret == MACDRV_HOTKEY_ALREADY_REGISTERED)
1522 SetLastError(ERROR_HOTKEY_ALREADY_REGISTERED);
1523 else if (ret != MACDRV_HOTKEY_SUCCESS)
1524 SetLastError(ERROR_GEN_FAILURE);
1525
1526 return ret == MACDRV_HOTKEY_SUCCESS;
1527 }
1528
1529
1530 /***********************************************************************
1531 * ToUnicodeEx (MACDRV.@)
1532 *
1533 * The ToUnicode function translates the specified virtual-key code and keyboard
1534 * state to the corresponding Windows character or characters.
1535 *
1536 * If the specified key is a dead key, the return value is negative. Otherwise,
1537 * it is one of the following values:
1538 * Value Meaning
1539 * -1 The specified virtual key is a dead-key. If possible, the
1540 * non-combining form of the dead character is written to bufW.
1541 * 0 The specified virtual key has no translation for the current
1542 * state of the keyboard.
1543 * 1 One Windows character was copied to the buffer.
1544 * 2 or more Multiple characters were copied to the buffer. This usually
1545 * happens when a dead-key character (accent or diacritic) stored
1546 * in the keyboard layout cannot be composed with the specified
1547 * virtual key to form a single character.
1548 *
1549 */
1550 INT CDECL macdrv_ToUnicodeEx(UINT virtKey, UINT scanCode, const BYTE *lpKeyState,
1551 LPWSTR bufW, int bufW_size, UINT flags, HKL hkl)
1552 {
1553 struct macdrv_thread_data *thread_data = macdrv_init_thread_data();
1554 INT ret = 0;
1555 int keyc;
1556 BOOL is_menu = (flags & 0x1);
1557 int status;
1558 const UCKeyboardLayout *uchr;
1559 UInt16 keyAction;
1560 UInt32 modifierKeyState;
1561 OptionBits options;
1562 UInt32 deadKeyState, savedDeadKeyState;
1563 UniCharCount len;
1564 BOOL dead = FALSE;
1565
1566 TRACE_(key)("virtKey 0x%04x scanCode 0x%04x lpKeyState %p bufW %p bufW_size %d flags 0x%08x hkl %p\n",
1567 virtKey, scanCode, lpKeyState, bufW, bufW_size, flags, hkl);
1568
1569 if (!virtKey)
1570 goto done;
1571
1572 /* UCKeyTranslate, below, terminates a dead-key sequence if passed a
1573 modifier key press. We want it to effectively ignore modifier key
1574 presses. I think that one isn't supposed to call it at all for modifier
1575 events (e.g. NSFlagsChanged or kEventRawKeyModifiersChanged), since they
1576 are different event types than key up/down events. */
1577 switch (virtKey)
1578 {
1579 case VK_SHIFT:
1580 case VK_CONTROL:
1581 case VK_MENU:
1582 case VK_CAPITAL:
1583 case VK_LSHIFT:
1584 case VK_RSHIFT:
1585 case VK_LCONTROL:
1586 case VK_RCONTROL:
1587 case VK_LMENU:
1588 case VK_RMENU:
1589 goto done;
1590 }
1591
1592 /* There are a number of key combinations for which Windows does not
1593 produce characters, but Mac keyboard layouts may. Eat them. Do this
1594 here to avoid the expense of UCKeyTranslate() but also because these
1595 keys shouldn't terminate dead key sequences. */
1596 if ((VK_PRIOR <= virtKey && virtKey <= VK_HELP) || (VK_F1 <= virtKey && virtKey <= VK_F24))
1597 goto done;
1598
1599 /* Shift + <non-digit keypad keys>. */
1600 if ((lpKeyState[VK_SHIFT] & 0x80) && VK_MULTIPLY <= virtKey && virtKey <= VK_DIVIDE)
1601 goto done;
1602
1603 if (lpKeyState[VK_CONTROL] & 0x80)
1604 {
1605 /* Control-Tab, with or without other modifiers. */
1606 if (virtKey == VK_TAB)
1607 goto done;
1608
1609 /* Control-Shift-<key>, Control-Alt-<key>, and Control-Alt-Shift-<key>
1610 for these keys. */
1611 if ((lpKeyState[VK_SHIFT] & 0x80) || (lpKeyState[VK_MENU] & 0x80))
1612 {
1613 switch (virtKey)
1614 {
1615 case VK_CANCEL:
1616 case VK_BACK:
1617 case VK_ESCAPE:
1618 case VK_SPACE:
1619 case VK_RETURN:
1620 goto done;
1621 }
1622 }
1623 }
1624
1625 if (thread_data->keyboard_layout_uchr)
1626 uchr = (const UCKeyboardLayout*)CFDataGetBytePtr(thread_data->keyboard_layout_uchr);
1627 else
1628 uchr = NULL;
1629
1630 keyAction = (scanCode & 0x8000) ? kUCKeyActionUp : kUCKeyActionDown;
1631
1632 modifierKeyState = 0;
1633 if (lpKeyState[VK_SHIFT] & 0x80)
1634 modifierKeyState |= (shiftKey >> 8);
1635 if (lpKeyState[VK_CAPITAL] & 0x01)
1636 modifierKeyState |= (alphaLock >> 8);
1637 if (lpKeyState[VK_CONTROL] & 0x80)
1638 modifierKeyState |= (controlKey >> 8);
1639 if (lpKeyState[VK_MENU] & 0x80)
1640 modifierKeyState |= (cmdKey >> 8);
1641 if (thread_data->last_modifiers & (NX_ALTERNATEMASK | NX_DEVICELALTKEYMASK | NX_DEVICERALTKEYMASK))
1642 modifierKeyState |= (optionKey >> 8);
1643
1644 /* Find the Mac keycode corresponding to the vkey */
1645 for (keyc = 0; keyc < ARRAY_SIZE(thread_data->keyc2vkey); keyc++)
1646 if (thread_data->keyc2vkey[keyc] == virtKey) break;
1647
1648 if (keyc >= ARRAY_SIZE(thread_data->keyc2vkey))
1649 {
1650 WARN_(key)("Unknown virtual key 0x%04x\n", virtKey);
1651 goto done;
1652 }
1653
1654 TRACE_(key)("Key code 0x%04x %s, faked modifiers = 0x%04x\n", keyc,
1655 (keyAction == kUCKeyActionDown) ? "pressed" : "released", (unsigned)modifierKeyState);
1656
1657 if (is_menu)
1658 {
1659 if (keyAction == kUCKeyActionUp)
1660 goto done;
1661
1662 options = kUCKeyTranslateNoDeadKeysMask;
1663 deadKeyState = 0;
1664 }
1665 else
1666 {
1667 options = 0;
1668 deadKeyState = thread_data->dead_key_state;
1669 }
1670 savedDeadKeyState = deadKeyState;
1671 status = UCKeyTranslate(uchr, keyc, keyAction, modifierKeyState,
1672 thread_data->keyboard_type, options, &deadKeyState, bufW_size,
1673 &len, bufW);
1674 if (status != noErr)
1675 {
1676 ERR_(key)("Couldn't translate keycode 0x%04x, status %d\n", keyc, status);
1677 goto done;
1678 }
1679 if (!is_menu)
1680 {
1681 if (keyAction != kUCKeyActionUp && len > 0 && deadKeyState == thread_data->dead_key_state)
1682 thread_data->dead_key_state = 0;
1683 else
1684 thread_data->dead_key_state = deadKeyState;
1685
1686 if (keyAction == kUCKeyActionUp)
1687 goto done;
1688 }
1689
1690 if (len == 0 && deadKeyState)
1691 {
1692 /* Repeat the translation, but disabling dead-key generation to
1693 learn which dead key it was. */
1694 status = UCKeyTranslate(uchr, keyc, keyAction, modifierKeyState,
1695 thread_data->keyboard_type, kUCKeyTranslateNoDeadKeysMask,
1696 &savedDeadKeyState, bufW_size, &len, bufW);
1697 if (status != noErr)
1698 {
1699 ERR_(key)("Couldn't translate keycode 0x%04x, status %d\n", keyc, status);
1700 goto done;
1701 }
1702
1703 dead = TRUE;
1704 }
1705
1706 if (len > 0)
1707 len = strip_apple_private_chars(bufW, len);
1708
1709 if (dead && len > 0) ret = -1;
1710 else ret = len;
1711
1712 /* Control-Return produces line feed instead of carriage return. */
1713 if (ret > 0 && (lpKeyState[VK_CONTROL] & 0x80) && virtKey == VK_RETURN)
1714 {
1715 int i;
1716 for (i = 0; i < len; i++)
1717 if (bufW[i] == '\r')
1718 bufW[i] = '\n';
1719 }
1720
1721 done:
1722 /* Null-terminate the buffer, if there's room. MSDN clearly states that the
1723 caller must not assume this is done, but some programs (e.g. Audiosurf) do. */
1724 if (1 <= ret && ret < bufW_size)
1725 bufW[ret] = 0;
1726
1727 TRACE_(key)("returning %d / %s\n", ret, debugstr_wn(bufW, abs(ret)));
1728 return ret;
1729 }
1730
1731
1732 /***********************************************************************
1733 * UnregisterHotKey (MACDRV.@)
1734 */
1735 void CDECL macdrv_UnregisterHotKey(HWND hwnd, UINT modifiers, UINT vkey)
1736 {
1737 struct macdrv_thread_data *thread_data = macdrv_thread_data();
1738
1739 TRACE_(key)("hwnd %p modifiers 0x%04x vkey 0x%04x\n", hwnd, modifiers, vkey);
1740
1741 if (thread_data)
1742 macdrv_unregister_hot_key(thread_data->queue, vkey, modifiers);
1743 }
1744
1745
1746 /***********************************************************************
1747 * VkKeyScanEx (MACDRV.@)
1748 *
1749 * Note: Windows ignores HKL parameter and uses current active layout instead
1750 */
1751 SHORT CDECL macdrv_VkKeyScanEx(WCHAR wChar, HKL hkl)
1752 {
1753 struct macdrv_thread_data *thread_data = macdrv_init_thread_data();
1754 SHORT ret = -1;
1755 int state;
1756 const UCKeyboardLayout *uchr;
1757
1758 TRACE("%04x, %p\n", wChar, hkl);
1759
1760 uchr = (const UCKeyboardLayout*)CFDataGetBytePtr(thread_data->keyboard_layout_uchr);
1761 if (!uchr)
1762 {
1763 TRACE("no keyboard layout UCHR data; returning -1\n");
1764 return -1;
1765 }
1766
1767 for (state = 0; state < 8; state++)
1768 {
1769 UInt32 modifierKeyState = 0;
1770 int keyc;
1771
1772 if (state & 1)
1773 modifierKeyState |= (shiftKey >> 8);
1774 if ((state & 6) == 6)
1775 modifierKeyState |= (optionKey >> 8);
1776 else
1777 {
1778 if (state & 2)
1779 modifierKeyState |= (controlKey >> 8);
1780 if (state & 4)
1781 modifierKeyState |= (cmdKey >> 8);
1782 }
1783
1784 for (keyc = 0; keyc < ARRAY_SIZE(thread_data->keyc2vkey); keyc++)
1785 {
1786 UInt32 deadKeyState = 0;
1787 UniChar uchar;
1788 UniCharCount len;
1789 OSStatus status;
1790
1791 if (!thread_data->keyc2vkey[keyc]) continue;
1792
1793 status = UCKeyTranslate(uchr, keyc, kUCKeyActionDown, modifierKeyState,
1794 thread_data->keyboard_type, 0, &deadKeyState,
1795 1, &len, &uchar);
1796 if (status == noErr && len == 1 && uchar == wChar)
1797 {
1798 WORD vkey = thread_data->keyc2vkey[keyc];
1799
1800 ret = vkey | (state << 8);
1801 if ((VK_NUMPAD0 <= vkey && vkey <= VK_DIVIDE) ||
1802 keyc == kVK_ANSI_KeypadClear || keyc == kVK_ANSI_KeypadEnter ||
1803 keyc == kVK_ANSI_KeypadEquals)
1804 {
1805 /* Keep searching for a non-numpad match, which is preferred. */
1806 }
1807 else
1808 goto done;
1809 }
1810 }
1811 }
1812
1813 done:
1814 TRACE(" -> 0x%04x\n", ret);
1815 return ret;
1816 }
Windows API implementation