1 /*
2 * Copyright (c) 2011, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26 #import <JavaNativeFoundation/JavaNativeFoundation.h>
27 #import <JavaRuntimeSupport/JavaRuntimeSupport.h>
28 #import <sys/time.h>
29 #include <Carbon/Carbon.h>
30
31 #import "LWCToolkit.h"
32 #import "ThreadUtilities.h"
33
34 #import "java_awt_event_InputEvent.h"
35 #import "java_awt_event_KeyEvent.h"
36 #import "java_awt_event_MouseEvent.h"
37
38 /*
39 * Table to map typed characters to their Java virtual key equivalent and back.
40 * We use the incoming unichar (ignoring all modifiers) and try to figure out
41 * which virtual key code is appropriate. A lot of them just have direct
42 * mappings (the function keys, arrow keys, etc.) so they aren't a problem.
43 * We had to do something a little funky to catch the keys on the numeric
44 * key pad (i.e. using event mask to distinguish between period on regular
45 * keyboard and decimal on keypad). We also have to do something incredibly
46 * hokey with regards to the shifted punctuation characters. For examples,
47 * consider '&' which is usually Shift-7. For the Java key typed events,
48 * that's no problem, we just say pass the unichar. But for the
49 * KeyPressed/Released events, we need to identify the virtual key code
50 * (which roughly correspond to hardware keys) which means we are supposed
51 * to say the virtual 7 key was pressed. But how are we supposed to know
52 * when we get a punctuation char what was the real hardware key was that
53 * was pressed? Although '&' often comes from Shift-7 the keyboard can be
54 * remapped! I don't think there really is a good answer, and hopefully
55 * all good applets are only interested in logical key typed events not
56 * press/release. Meanwhile, we are hard-coding the shifted punctuation
57 * to trigger the virtual keys that are the expected ones under a standard
58 * keymapping. Looking at Windows & Mac, they don't actually do this, the
59 * Mac seems to just put the ascii code in for the shifted punctuation
60 * (which means they actually end up with bogus key codes on the Java side),
61 * Windows I can't even figure out what it's doing.
62 */
63 #define KL_STANDARD java_awt_event_KeyEvent_KEY_LOCATION_STANDARD
64 #define KL_NUMPAD java_awt_event_KeyEvent_KEY_LOCATION_NUMPAD
65 #define KL_UNKNOWN java_awt_event_KeyEvent_KEY_LOCATION_UNKNOWN
66 static struct _key
67 {
68 unsigned short keyCode;
69 BOOL postsTyped;
70 jint javaKeyLocation;
71 jint javaKeyCode;
72 }
73 const keyTable[] =
74 {
75 {0x00, YES, KL_STANDARD, java_awt_event_KeyEvent_VK_A},
76 {0x01, YES, KL_STANDARD, java_awt_event_KeyEvent_VK_S},
77 {0x02, YES, KL_STANDARD, java_awt_event_KeyEvent_VK_D},
78 {0x03, YES, KL_STANDARD, java_awt_event_KeyEvent_VK_F},
79 {0x04, YES, KL_STANDARD, java_awt_event_KeyEvent_VK_H},
80 {0x05, YES, KL_STANDARD, java_awt_event_KeyEvent_VK_G},
81 {0x06, YES, KL_STANDARD, java_awt_event_KeyEvent_VK_Z},
82 {0x07, YES, KL_STANDARD, java_awt_event_KeyEvent_VK_X},
83 {0x08, YES, KL_STANDARD, java_awt_event_KeyEvent_VK_C},
84 {0x09, YES, KL_STANDARD, java_awt_event_KeyEvent_VK_V},
85 {0x0A, YES, KL_STANDARD, java_awt_event_KeyEvent_VK_BACK_QUOTE},
86 {0x0B, YES, KL_STANDARD, java_awt_event_KeyEvent_VK_B},
87 {0x0C, YES, KL_STANDARD, java_awt_event_KeyEvent_VK_Q},
88 {0x0D, YES, KL_STANDARD, java_awt_event_KeyEvent_VK_W},
89 {0x0E, YES, KL_STANDARD, java_awt_event_KeyEvent_VK_E},
90 {0x0F, YES, KL_STANDARD, java_awt_event_KeyEvent_VK_R},
91 {0x10, YES, KL_STANDARD, java_awt_event_KeyEvent_VK_Y},
92 {0x11, YES, KL_STANDARD, java_awt_event_KeyEvent_VK_T},
93 {0x12, YES, KL_STANDARD, java_awt_event_KeyEvent_VK_1},
94 {0x13, YES, KL_STANDARD, java_awt_event_KeyEvent_VK_2},
95 {0x14, YES, KL_STANDARD, java_awt_event_KeyEvent_VK_3},
96 {0x15, YES, KL_STANDARD, java_awt_event_KeyEvent_VK_4},
97 {0x16, YES, KL_STANDARD, java_awt_event_KeyEvent_VK_6},
98 {0x17, YES, KL_STANDARD, java_awt_event_KeyEvent_VK_5},
99 {0x18, YES, KL_STANDARD, java_awt_event_KeyEvent_VK_EQUALS},
100 {0x19, YES, KL_STANDARD, java_awt_event_KeyEvent_VK_9},
101 {0x1A, YES, KL_STANDARD, java_awt_event_KeyEvent_VK_7},
102 {0x1B, YES, KL_STANDARD, java_awt_event_KeyEvent_VK_MINUS},
103 {0x1C, YES, KL_STANDARD, java_awt_event_KeyEvent_VK_8},
104 {0x1D, YES, KL_STANDARD, java_awt_event_KeyEvent_VK_0},
105 {0x1E, YES, KL_STANDARD, java_awt_event_KeyEvent_VK_CLOSE_BRACKET},
106 {0x1F, YES, KL_STANDARD, java_awt_event_KeyEvent_VK_O},
107 {0x20, YES, KL_STANDARD, java_awt_event_KeyEvent_VK_U},
108 {0x21, YES, KL_STANDARD, java_awt_event_KeyEvent_VK_OPEN_BRACKET},
109 {0x22, YES, KL_STANDARD, java_awt_event_KeyEvent_VK_I},
110 {0x23, YES, KL_STANDARD, java_awt_event_KeyEvent_VK_P},
111 {0x24, YES, KL_STANDARD, java_awt_event_KeyEvent_VK_ENTER},
112 {0x25, YES, KL_STANDARD, java_awt_event_KeyEvent_VK_L},
113 {0x26, YES, KL_STANDARD, java_awt_event_KeyEvent_VK_J},
114 {0x27, YES, KL_STANDARD, java_awt_event_KeyEvent_VK_QUOTE},
115 {0x28, YES, KL_STANDARD, java_awt_event_KeyEvent_VK_K},
116 {0x29, YES, KL_STANDARD, java_awt_event_KeyEvent_VK_SEMICOLON},
117 {0x2A, YES, KL_STANDARD, java_awt_event_KeyEvent_VK_BACK_SLASH},
118 {0x2B, YES, KL_STANDARD, java_awt_event_KeyEvent_VK_COMMA},
119 {0x2C, YES, KL_STANDARD, java_awt_event_KeyEvent_VK_SLASH},
120 {0x2D, YES, KL_STANDARD, java_awt_event_KeyEvent_VK_N},
121 {0x2E, YES, KL_STANDARD, java_awt_event_KeyEvent_VK_M},
122 {0x2F, YES, KL_STANDARD, java_awt_event_KeyEvent_VK_PERIOD},
123 {0x30, YES, KL_STANDARD, java_awt_event_KeyEvent_VK_TAB},
124 {0x31, YES, KL_STANDARD, java_awt_event_KeyEvent_VK_SPACE},
125 {0x32, YES, KL_STANDARD, java_awt_event_KeyEvent_VK_BACK_QUOTE},
126 {0x33, YES, KL_STANDARD, java_awt_event_KeyEvent_VK_BACK_SPACE},
127 {0x34, YES, KL_NUMPAD, java_awt_event_KeyEvent_VK_ENTER},
128 {0x35, YES, KL_STANDARD, java_awt_event_KeyEvent_VK_ESCAPE},
129 {0x36, NO, KL_UNKNOWN, java_awt_event_KeyEvent_VK_UNDEFINED},
130 {0x37, NO, KL_UNKNOWN, java_awt_event_KeyEvent_VK_META}, // ****
131 {0x38, NO, KL_UNKNOWN, java_awt_event_KeyEvent_VK_SHIFT}, // ****
132 {0x39, NO, KL_STANDARD, java_awt_event_KeyEvent_VK_CAPS_LOCK},
133 {0x3A, NO, KL_UNKNOWN, java_awt_event_KeyEvent_VK_ALT}, // ****
134 {0x3B, NO, KL_UNKNOWN, java_awt_event_KeyEvent_VK_CONTROL}, // ****
135 {0x3C, NO, KL_UNKNOWN, java_awt_event_KeyEvent_VK_UNDEFINED},
136 {0x3D, NO, KL_UNKNOWN, java_awt_event_KeyEvent_VK_UNDEFINED},
137 {0x3E, NO, KL_UNKNOWN, java_awt_event_KeyEvent_VK_UNDEFINED},
138 {0x3F, NO, KL_UNKNOWN, java_awt_event_KeyEvent_VK_UNDEFINED}, // the 'fn' key on PowerBooks
139 {0x40, NO, KL_UNKNOWN, java_awt_event_KeyEvent_VK_UNDEFINED},
140 {0x41, YES, KL_NUMPAD, java_awt_event_KeyEvent_VK_DECIMAL},
141 {0x42, NO, KL_UNKNOWN, java_awt_event_KeyEvent_VK_UNDEFINED},
142 {0x43, YES, KL_NUMPAD, java_awt_event_KeyEvent_VK_MULTIPLY},
143 {0x44, NO, KL_UNKNOWN, java_awt_event_KeyEvent_VK_UNDEFINED},
144 {0x45, YES, KL_NUMPAD, java_awt_event_KeyEvent_VK_ADD},
145 {0x46, NO, KL_UNKNOWN, java_awt_event_KeyEvent_VK_UNDEFINED},
146 {0x47, NO, KL_NUMPAD, java_awt_event_KeyEvent_VK_CLEAR},
147 {0x48, NO, KL_UNKNOWN, java_awt_event_KeyEvent_VK_UNDEFINED},
148 {0x49, NO, KL_UNKNOWN, java_awt_event_KeyEvent_VK_UNDEFINED},
149 {0x4A, NO, KL_UNKNOWN, java_awt_event_KeyEvent_VK_UNDEFINED},
150 {0x4B, YES, KL_NUMPAD, java_awt_event_KeyEvent_VK_DIVIDE},
151 {0x4C, YES, KL_NUMPAD, java_awt_event_KeyEvent_VK_ENTER},
152 {0x4D, NO, KL_UNKNOWN, java_awt_event_KeyEvent_VK_UNDEFINED},
153 {0x4E, YES, KL_NUMPAD, java_awt_event_KeyEvent_VK_SUBTRACT},
154 {0x4F, NO, KL_UNKNOWN, java_awt_event_KeyEvent_VK_UNDEFINED},
155 {0x50, NO, KL_UNKNOWN, java_awt_event_KeyEvent_VK_UNDEFINED},
156 {0x51, YES, KL_NUMPAD, java_awt_event_KeyEvent_VK_EQUALS},
157 {0x52, YES, KL_NUMPAD, java_awt_event_KeyEvent_VK_NUMPAD0},
158 {0x53, YES, KL_NUMPAD, java_awt_event_KeyEvent_VK_NUMPAD1},
159 {0x54, YES, KL_NUMPAD, java_awt_event_KeyEvent_VK_NUMPAD2},
160 {0x55, YES, KL_NUMPAD, java_awt_event_KeyEvent_VK_NUMPAD3},
161 {0x56, YES, KL_NUMPAD, java_awt_event_KeyEvent_VK_NUMPAD4},
162 {0x57, YES, KL_NUMPAD, java_awt_event_KeyEvent_VK_NUMPAD5},
163 {0x58, YES, KL_NUMPAD, java_awt_event_KeyEvent_VK_NUMPAD6},
164 {0x59, YES, KL_NUMPAD, java_awt_event_KeyEvent_VK_NUMPAD7},
165 {0x5A, NO, KL_UNKNOWN, java_awt_event_KeyEvent_VK_UNDEFINED},
166 {0x5B, YES, KL_NUMPAD, java_awt_event_KeyEvent_VK_NUMPAD8},
167 {0x5C, YES, KL_NUMPAD, java_awt_event_KeyEvent_VK_NUMPAD9},
168 {0x5D, YES, KL_STANDARD, java_awt_event_KeyEvent_VK_BACK_SLASH}, // This is a combo yen/backslash on JIS keyboards.
169 {0x5E, YES, KL_NUMPAD, java_awt_event_KeyEvent_VK_UNDERSCORE},
170 {0x5F, YES, KL_NUMPAD, java_awt_event_KeyEvent_VK_COMMA},
171 {0x60, NO, KL_STANDARD, java_awt_event_KeyEvent_VK_F5},
172 {0x61, NO, KL_STANDARD, java_awt_event_KeyEvent_VK_F6},
173 {0x62, NO, KL_STANDARD, java_awt_event_KeyEvent_VK_F7},
174 {0x63, NO, KL_STANDARD, java_awt_event_KeyEvent_VK_F3},
175 {0x64, NO, KL_STANDARD, java_awt_event_KeyEvent_VK_F8},
176 {0x65, NO, KL_STANDARD, java_awt_event_KeyEvent_VK_F9},
177 {0x66, NO, KL_STANDARD, java_awt_event_KeyEvent_VK_ALPHANUMERIC},
178 {0x67, NO, KL_STANDARD, java_awt_event_KeyEvent_VK_F11},
179 {0x68, NO, KL_STANDARD, java_awt_event_KeyEvent_VK_KATAKANA},
180 {0x69, NO, KL_STANDARD, java_awt_event_KeyEvent_VK_F13},
181 {0x6A, NO, KL_STANDARD, java_awt_event_KeyEvent_VK_F16},
182 {0x6B, NO, KL_STANDARD, java_awt_event_KeyEvent_VK_F14},
183 {0x6C, NO, KL_UNKNOWN, java_awt_event_KeyEvent_VK_UNDEFINED},
184 {0x6D, NO, KL_STANDARD, java_awt_event_KeyEvent_VK_F10},
185 {0x6E, NO, KL_UNKNOWN, java_awt_event_KeyEvent_VK_UNDEFINED},
186 {0x6F, NO, KL_STANDARD, java_awt_event_KeyEvent_VK_F12},
187 {0x70, NO, KL_UNKNOWN, java_awt_event_KeyEvent_VK_UNDEFINED},
188 {0x71, NO, KL_STANDARD, java_awt_event_KeyEvent_VK_F15},
189 {0x72, NO, KL_STANDARD, java_awt_event_KeyEvent_VK_HELP},
190 {0x73, NO, KL_STANDARD, java_awt_event_KeyEvent_VK_HOME},
191 {0x74, NO, KL_STANDARD, java_awt_event_KeyEvent_VK_PAGE_UP},
192 {0x75, YES, KL_STANDARD, java_awt_event_KeyEvent_VK_DELETE},
193 {0x76, NO, KL_STANDARD, java_awt_event_KeyEvent_VK_F4},
194 {0x77, NO, KL_STANDARD, java_awt_event_KeyEvent_VK_END},
195 {0x78, NO, KL_STANDARD, java_awt_event_KeyEvent_VK_F2},
196 {0x79, NO, KL_STANDARD, java_awt_event_KeyEvent_VK_PAGE_DOWN},
197 {0x7A, NO, KL_STANDARD, java_awt_event_KeyEvent_VK_F1},
198 {0x7B, NO, KL_STANDARD, java_awt_event_KeyEvent_VK_LEFT},
199 {0x7C, NO, KL_STANDARD, java_awt_event_KeyEvent_VK_RIGHT},
200 {0x7D, NO, KL_STANDARD, java_awt_event_KeyEvent_VK_DOWN},
201 {0x7E, NO, KL_STANDARD, java_awt_event_KeyEvent_VK_UP},
202 {0x7F, NO, KL_UNKNOWN, java_awt_event_KeyEvent_VK_UNDEFINED},
203 };
204
205 /*
206 * This table was stolen from the Windows implementation for mapping
207 * Unicode values to VK codes for dead keys. On Windows, some layouts
208 * return ASCII punctuation for dead accents, while some return spacing
209 * accent chars, so both should be listed. However, in all of the
210 * keyboard layouts I tried only the Unicode values are used.
211 */
212 struct CharToVKEntry {
213 UniChar c;
214 jint javaKey;
215 };
216 static const struct CharToVKEntry charToDeadVKTable[] = {
217 {0x0060, java_awt_event_KeyEvent_VK_DEAD_GRAVE},
218 {0x00B4, java_awt_event_KeyEvent_VK_DEAD_ACUTE},
219 {0x0384, java_awt_event_KeyEvent_VK_DEAD_ACUTE}, // Unicode "GREEK TONOS" -- Greek keyboard, semicolon key
220 {0x005E, java_awt_event_KeyEvent_VK_DEAD_CIRCUMFLEX},
221 {0x007E, java_awt_event_KeyEvent_VK_DEAD_TILDE},
222 {0x02DC, java_awt_event_KeyEvent_VK_DEAD_TILDE}, // Unicode "SMALL TILDE"
223 {0x00AF, java_awt_event_KeyEvent_VK_DEAD_MACRON},
224 {0x02D8, java_awt_event_KeyEvent_VK_DEAD_BREVE},
225 {0x02D9, java_awt_event_KeyEvent_VK_DEAD_ABOVEDOT},
226 {0x00A8, java_awt_event_KeyEvent_VK_DEAD_DIAERESIS},
227 {0x02DA, java_awt_event_KeyEvent_VK_DEAD_ABOVERING},
228 {0x02DD, java_awt_event_KeyEvent_VK_DEAD_DOUBLEACUTE},
229 {0x02C7, java_awt_event_KeyEvent_VK_DEAD_CARON},
230 {0x00B8, java_awt_event_KeyEvent_VK_DEAD_CEDILLA},
231 {0x02DB, java_awt_event_KeyEvent_VK_DEAD_OGONEK},
232 {0x037A, java_awt_event_KeyEvent_VK_DEAD_IOTA},
233 {0x309B, java_awt_event_KeyEvent_VK_DEAD_VOICED_SOUND},
234 {0x309C, java_awt_event_KeyEvent_VK_DEAD_SEMIVOICED_SOUND},
235 {0,0}
236 };
237
238 // TODO: some constants below are part of CGS (private interfaces)...
239 // for now we will look at the raw key code to determine left/right status
240 // but not sure this is foolproof...
241 static struct _nsKeyToJavaModifier
242 {
243 NSUInteger nsMask;
244 //NSUInteger cgsLeftMask;
245 //NSUInteger cgsRightMask;
246 unsigned short leftKeyCode;
247 unsigned short rightKeyCode;
248 jint javaMask;
249 jint javaKey;
250 }
251 const nsKeyToJavaModifierTable[] =
252 {
253 {
254 NSAlphaShiftKeyMask,
255 0,
256 0,
257 0, // no Java equivalent
258 java_awt_event_KeyEvent_VK_CAPS_LOCK
259 },
260 {
261 NSShiftKeyMask,
262 //kCGSFlagsMaskAppleShiftKey,
263 //kCGSFlagsMaskAppleRightShiftKey,
264 56,
265 60,
266 java_awt_event_InputEvent_SHIFT_DOWN_MASK,
267 java_awt_event_KeyEvent_VK_SHIFT
268 },
269 {
270 NSControlKeyMask,
271 //kCGSFlagsMaskAppleControlKey,
272 //kCGSFlagsMaskAppleRightControlKey,
273 59,
274 62,
275 java_awt_event_InputEvent_CTRL_DOWN_MASK,
276 java_awt_event_KeyEvent_VK_CONTROL
277 },
278 {
279 NSAlternateKeyMask,
280 //kCGSFlagsMaskAppleLeftAlternateKey,
281 //kCGSFlagsMaskAppleRightAlternateKey,
282 58,
283 61,
284 java_awt_event_InputEvent_ALT_DOWN_MASK,
285 java_awt_event_KeyEvent_VK_ALT
286 },
287 {
288 NSCommandKeyMask,
289 //kCGSFlagsMaskAppleLeftCommandKey,
290 //kCGSFlagsMaskAppleRightCommandKey,
291 55,
292 54,
293 java_awt_event_InputEvent_META_DOWN_MASK,
294 java_awt_event_KeyEvent_VK_META
295 },
296 // NSNumericPadKeyMask
297 {
298 NSHelpKeyMask,
299 0,
300 0,
301 0, // no Java equivalent
302 java_awt_event_KeyEvent_VK_HELP
303 },
304 // NSFunctionKeyMask
305 {0, 0, 0, 0, 0}
306 };
307
308 /*
309 * Almost all unicode characters just go from NS to Java with no translation.
310 * For the few exceptions, we handle it here with this small table.
311 */
312 #define ALL_NS_KEY_MODIFIERS_MASK \
313 (NSShiftKeyMask | NSControlKeyMask | NSAlternateKeyMask | NSCommandKeyMask)
314
315 static struct _char {
316 NSUInteger modifier;
317 unichar nsChar;
318 unichar javaChar;
319 }
320 const charTable[] = {
321 // map enter on keypad to same as return key
322 {0, NSEnterCharacter, NSNewlineCharacter},
323
324 // [3134616] return newline instead of carriage return
325 {0, NSCarriageReturnCharacter, NSNewlineCharacter},
326
327 // "delete" means backspace in Java
328 {ALL_NS_KEY_MODIFIERS_MASK, NSDeleteCharacter, NSBackspaceCharacter},
329 {ALL_NS_KEY_MODIFIERS_MASK, NSDeleteFunctionKey, NSDeleteCharacter},
330
331 // back-tab is only differentiated from tab by Shift flag
332 {NSShiftKeyMask, NSBackTabCharacter, NSTabCharacter},
333
334 {0, 0, 0}
335 };
336
337 static unichar
338 NsCharToJavaChar(unichar nsChar, NSUInteger modifiers)
339 {
340 const struct _char *cur;
341 // Mask off just the keyboard modifiers from the event modifier mask.
342 NSUInteger testableFlags = (modifiers & ALL_NS_KEY_MODIFIERS_MASK);
343
344 // walk through table & find the match
345 for (cur = charTable; cur->nsChar != 0 ; cur++) {
346 // <rdar://Problem/3476426> Need to determine if we are looking at
347 // a plain keypress or a modified keypress. Don't adjust the
348 // character of a keypress with a modifier.
349 if (cur->nsChar == nsChar) {
350 if (cur->modifier == 0 && testableFlags == 0) {
351 // If the modifier field is 0, that means to transform
352 // this character if no additional keyboard modifiers are set.
353 // This lets ctrl-C be reported as ctrl-C and not transformed
354 // into Newline.
355 return cur->javaChar;
356 } else if (cur->modifier != 0 &&
357 (testableFlags & cur->modifier) == testableFlags)
358 {
359 // Likewise, if the modifier field is nonzero, that means
360 // transform this character if only these modifiers are
361 // set in the testable flags.
362 return cur->javaChar;
363 }
364 }
365 }
366
367 if (nsChar >= NSUpArrowFunctionKey && nsChar <= NSModeSwitchFunctionKey) {
368 return java_awt_event_KeyEvent_CHAR_UNDEFINED;
369 }
370
371 // otherwise return character unchanged
372 return nsChar;
373 }
374
375 static unichar NsGetDeadKeyChar(unsigned short keyCode)
376 {
377 TISInputSourceRef currentKeyboard = TISCopyCurrentKeyboardInputSource();
378 CFDataRef uchr = (CFDataRef)TISGetInputSourceProperty(currentKeyboard, kTISPropertyUnicodeKeyLayoutData);
379 const UCKeyboardLayout *keyboardLayout = (const UCKeyboardLayout*)CFDataGetBytePtr(uchr);
380 // Carbon modifiers should be used instead of NSEvent modifiers
381 UInt32 modifierKeyState = (GetCurrentEventKeyModifiers() >> 8) & 0xFF;
382
383 if (keyboardLayout) {
384 UInt32 deadKeyState = 0;
385 UniCharCount maxStringLength = 255;
386 UniCharCount actualStringLength = 0;
387 UniChar unicodeString[maxStringLength];
388
389 // get the deadKeyState
390 OSStatus status = UCKeyTranslate(keyboardLayout,
391 keyCode, kUCKeyActionDown, modifierKeyState,
392 LMGetKbdType(), kUCKeyTranslateNoDeadKeysBit,
393 &deadKeyState,
394 maxStringLength,
395 &actualStringLength, unicodeString);
396
397 if (status == noErr && deadKeyState != 0) {
398 // Press SPACE to get the dead key char
399 status = UCKeyTranslate(keyboardLayout,
400 kVK_Space, kUCKeyActionDown, 0,
401 LMGetKbdType(), 0,
402 &deadKeyState,
403 maxStringLength,
404 &actualStringLength, unicodeString);
405
406 if (status == noErr && actualStringLength > 0) {
407 return unicodeString[0];
408 }
409 }
410 }
411 return 0;
412 }
413
414 /*
415 * This is the function that uses the table above to take incoming
416 * NSEvent keyCodes and translate to the Java virtual key code.
417 */
418 static void
419 NsCharToJavaVirtualKeyCode(unichar ch, BOOL isDeadChar,
420 NSUInteger flags, unsigned short key,
421 jint *keyCode, jint *keyLocation, BOOL *postsTyped, unichar *deadChar)
422 {
423 static size_t size = sizeof(keyTable) / sizeof(struct _key);
424 NSInteger offset;
425
426 if (isDeadChar) {
427 unichar testDeadChar = NsGetDeadKeyChar(key);
428 const struct CharToVKEntry *map;
429 for (map = charToDeadVKTable; map->c != 0; ++map) {
430 if (testDeadChar == map->c) {
431 *keyCode = map->javaKey;
432 *postsTyped = NO;
433 // TODO: use UNKNOWN here?
434 *keyLocation = java_awt_event_KeyEvent_KEY_LOCATION_UNKNOWN;
435 *deadChar = testDeadChar;
436 return;
437 }
438 }
439 // If we got here, we keep looking for a normal key.
440 }
441
442 if ([[NSCharacterSet letterCharacterSet] characterIsMember:ch]) {
443 // key is an alphabetic character
444 unichar lower;
445 lower = tolower(ch);
446 offset = lower - 'a';
447 if (offset >= 0 && offset <= 25) {
448 // some chars in letter set are NOT actually A-Z characters?!
449 // skip them...
450 *postsTyped = YES;
451 // do quick conversion
452 *keyCode = java_awt_event_KeyEvent_VK_A + offset;
453 *keyLocation = java_awt_event_KeyEvent_KEY_LOCATION_STANDARD;
454 return;
455 }
456 }
457
458 if ([[NSCharacterSet decimalDigitCharacterSet] characterIsMember:ch]) {
459 // key is a digit
460 offset = ch - '0';
461 // make sure in range for decimal digits
462 if (offset >= 0 && offset <= 9) {
463 jboolean numpad = (flags & NSNumericPadKeyMask) != 0;
464 *postsTyped = YES;
465 if (numpad) {
466 *keyCode = offset + java_awt_event_KeyEvent_VK_NUMPAD0;
467 *keyLocation = java_awt_event_KeyEvent_KEY_LOCATION_NUMPAD;
468 } else {
469 *keyCode = offset + java_awt_event_KeyEvent_VK_0;
470 *keyLocation = java_awt_event_KeyEvent_KEY_LOCATION_STANDARD;
471 }
472 return;
473 }
474 }
475
476 if (key < size) {
477 *postsTyped = keyTable[key].postsTyped;
478 *keyCode = keyTable[key].javaKeyCode;
479 *keyLocation = keyTable[key].javaKeyLocation;
480 } else {
481 // Should we report this? This means we've got a keyboard
482 // we don't know about...
483 *postsTyped = NO;
484 *keyCode = java_awt_event_KeyEvent_VK_UNDEFINED;
485 *keyLocation = java_awt_event_KeyEvent_KEY_LOCATION_UNKNOWN;
486 }
487 }
488
489 /*
490 * This returns the java key data for the key NSEvent modifiers
491 * (after NSFlagChanged).
492 */
493 static void
494 NsKeyModifiersToJavaKeyInfo(NSUInteger nsFlags, unsigned short eventKeyCode,
495 jint *javaKeyCode,
496 jint *javaKeyLocation,
497 jint *javaKeyType)
498 {
499 static NSUInteger sPreviousNSFlags = 0;
500
501 const struct _nsKeyToJavaModifier* cur;
502 NSUInteger oldNSFlags = sPreviousNSFlags;
503 NSUInteger changedNSFlags = oldNSFlags ^ nsFlags;
504 sPreviousNSFlags = nsFlags;
505
506 *javaKeyCode = java_awt_event_KeyEvent_VK_UNDEFINED;
507 *javaKeyLocation = java_awt_event_KeyEvent_KEY_LOCATION_UNKNOWN;
508 *javaKeyType = java_awt_event_KeyEvent_KEY_PRESSED;
509
510 for (cur = nsKeyToJavaModifierTable; cur->nsMask != 0; ++cur) {
511 if (changedNSFlags & cur->nsMask) {
512 *javaKeyCode = cur->javaKey;
513 *javaKeyLocation = java_awt_event_KeyEvent_KEY_LOCATION_STANDARD;
514 // TODO: uses SPI...
515 //if (changedNSFlags & cur->cgsLeftMask) {
516 // *javaKeyLocation = java_awt_event_KeyEvent_KEY_LOCATION_LEFT;
517 //} else if (changedNSFlags & cur->cgsRightMask) {
518 // *javaKeyLocation = java_awt_event_KeyEvent_KEY_LOCATION_RIGHT;
519 //}
520 if (eventKeyCode == cur->leftKeyCode) {
521 *javaKeyLocation = java_awt_event_KeyEvent_KEY_LOCATION_LEFT;
522 } else if (eventKeyCode == cur->rightKeyCode) {
523 *javaKeyLocation = java_awt_event_KeyEvent_KEY_LOCATION_RIGHT;
524 }
525 *javaKeyType = (cur->nsMask & nsFlags) ?
526 java_awt_event_KeyEvent_KEY_PRESSED :
527 java_awt_event_KeyEvent_KEY_RELEASED;
528 break;
529 }
530 }
531 }
532
533 /*
534 * This returns the java modifiers for a key NSEvent.
535 */
536 static jint
537 NsKeyModifiersToJavaModifiers(NSUInteger nsFlags)
538 {
539 jint javaModifiers = 0;
540 const struct _nsKeyToJavaModifier* cur;
541
542 for (cur = nsKeyToJavaModifierTable; cur->nsMask != 0; ++cur) {
543 if ((cur->nsMask & nsFlags) != 0) {
544 javaModifiers |= cur->javaMask;
545 }
546 }
547
548 return javaModifiers;
549 }
550
551 jint GetJavaMouseModifiers(NSInteger button, NSUInteger modifierFlags)
552 {
553 // Mousing needs the key modifiers
554 jint modifiers = NsKeyModifiersToJavaModifiers(modifierFlags);
555
556
557 /*
558 * Ask Quartz about mouse buttons state
559 */
560
561 if (CGEventSourceButtonState(kCGEventSourceStateCombinedSessionState,
562 kCGMouseButtonLeft)) {
563 modifiers |= java_awt_event_InputEvent_BUTTON1_DOWN_MASK;
564 }
565
566 if (CGEventSourceButtonState(kCGEventSourceStateCombinedSessionState,
567 kCGMouseButtonRight)) {
568 modifiers |= java_awt_event_InputEvent_BUTTON3_DOWN_MASK;
569 }
570
571 if (CGEventSourceButtonState(kCGEventSourceStateCombinedSessionState,
572 kCGMouseButtonCenter)) {
573 modifiers |= java_awt_event_InputEvent_BUTTON2_DOWN_MASK;
574 }
575
576 NSInteger extraButton = 3;
577 for (; extraButton < gNumberOfButtons; extraButton++) {
578 if (CGEventSourceButtonState(kCGEventSourceStateCombinedSessionState,
579 extraButton)) {
580 modifiers |= gButtonDownMasks[extraButton];
581 }
582 }
583
584 return modifiers;
585 }
586
587 jlong UTC(NSEvent *event) {
588 struct timeval tv;
589 if (gettimeofday(&tv, NULL) == 0) {
590 long long sec = (long long)tv.tv_sec;
591 return (sec*1000) + (tv.tv_usec/1000);
592 }
593 return 0;
594 }
595
596 JNIEXPORT void JNICALL
597 Java_java_awt_AWTEvent_nativeSetSource
598 (JNIEnv *env, jobject self, jobject newSource)
599 {
600 }
601
602 /*
603 * Class: sun_lwawt_macosx_event_NSEvent
604 * Method: nsToJavaMouseModifiers
605 * Signature: (II)I
606 */
607 JNIEXPORT jint JNICALL
608 Java_sun_lwawt_macosx_event_NSEvent_nsToJavaMouseModifiers
609 (JNIEnv *env, jclass cls, jint buttonNumber, jint modifierFlags)
610 {
611 jint jmodifiers = 0;
612
613 JNF_COCOA_ENTER(env);
614
615 jmodifiers = GetJavaMouseModifiers(buttonNumber, modifierFlags);
616
617 JNF_COCOA_EXIT(env);
618
619 return jmodifiers;
620 }
621
622 /*
623 * Class: sun_lwawt_macosx_event_NSEvent
624 * Method: nsToJavaKeyModifiers
625 * Signature: (I)I
626 */
627 JNIEXPORT jint JNICALL
628 Java_sun_lwawt_macosx_event_NSEvent_nsToJavaKeyModifiers
629 (JNIEnv *env, jclass cls, jint modifierFlags)
630 {
631 jint jmodifiers = 0;
632
633 JNF_COCOA_ENTER(env);
634
635 jmodifiers = NsKeyModifiersToJavaModifiers(modifierFlags);
636
637 JNF_COCOA_EXIT(env);
638
639 return jmodifiers;
640 }
641
642 /*
643 * Class: sun_lwawt_macosx_event_NSEvent
644 * Method: nsToJavaKeyInfo
645 * Signature: ([I[I)Z
646 */
647 JNIEXPORT jboolean JNICALL
648 Java_sun_lwawt_macosx_event_NSEvent_nsToJavaKeyInfo
649 (JNIEnv *env, jclass cls, jintArray inData, jintArray outData)
650 {
651 BOOL postsTyped = NO;
652
653 JNF_COCOA_ENTER(env);
654
655 jboolean copy = JNI_FALSE;
656 jint *data = (*env)->GetIntArrayElements(env, inData, ©);
657
658 // in = [testChar, testDeadChar, modifierFlags, keyCode]
659 jchar testChar = (jchar)data[0];
660 BOOL isDeadChar = (data[1] != 0);
661 jint modifierFlags = data[2];
662 jshort keyCode = (jshort)data[3];
663
664 jint jkeyCode = java_awt_event_KeyEvent_VK_UNDEFINED;
665 jint jkeyLocation = java_awt_event_KeyEvent_KEY_LOCATION_UNKNOWN;
666 jchar testDeadChar = 0;
667
668 NsCharToJavaVirtualKeyCode((unichar)testChar, isDeadChar,
669 (NSUInteger)modifierFlags, (unsigned short)keyCode,
670 &jkeyCode, &jkeyLocation, &postsTyped, &testDeadChar);
671
672 // out = [jkeyCode, jkeyLocation];
673 (*env)->SetIntArrayRegion(env, outData, 0, 1, &jkeyCode);
674 (*env)->SetIntArrayRegion(env, outData, 1, 1, &jkeyLocation);
675 (*env)->SetIntArrayRegion(env, outData, 2, 1, (jint *)&testDeadChar);
676
677 (*env)->ReleaseIntArrayElements(env, inData, data, 0);
678
679 JNF_COCOA_EXIT(env);
680
681 return postsTyped;
682 }
683
684 /*
685 * Class: sun_lwawt_macosx_event_NSEvent
686 * Method: nsKeyModifiersToJavaKeyInfo
687 * Signature: ([I[I)V
688 */
689 JNIEXPORT void JNICALL
690 Java_sun_lwawt_macosx_event_NSEvent_nsKeyModifiersToJavaKeyInfo
691 (JNIEnv *env, jclass cls, jintArray inData, jintArray outData)
692 {
693 JNF_COCOA_ENTER(env);
694
695 jboolean copy = JNI_FALSE;
696 jint *data = (*env)->GetIntArrayElements(env, inData, ©);
697
698 // in = [modifierFlags, keyCode]
699 jint modifierFlags = data[0];
700 jshort keyCode = (jshort)data[1];
701
702 jint jkeyCode = java_awt_event_KeyEvent_VK_UNDEFINED;
703 jint jkeyLocation = java_awt_event_KeyEvent_KEY_LOCATION_UNKNOWN;
704 jint jkeyType = java_awt_event_KeyEvent_KEY_PRESSED;
705
706 NsKeyModifiersToJavaKeyInfo(modifierFlags,
707 keyCode,
708 &jkeyCode,
709 &jkeyLocation,
710 &jkeyType);
711
712 // out = [jkeyCode, jkeyLocation, jkeyType];
713 (*env)->SetIntArrayRegion(env, outData, 0, 1, &jkeyCode);
714 (*env)->SetIntArrayRegion(env, outData, 1, 1, &jkeyLocation);
715 (*env)->SetIntArrayRegion(env, outData, 2, 1, &jkeyType);
716
717 (*env)->ReleaseIntArrayElements(env, inData, data, 0);
718
719 JNF_COCOA_EXIT(env);
720 }
721
722 /*
723 * Class: sun_lwawt_macosx_event_NSEvent
724 * Method: nsToJavaChar
725 * Signature: (CI)C
726 */
727 JNIEXPORT jint JNICALL
728 Java_sun_lwawt_macosx_event_NSEvent_nsToJavaChar
729 (JNIEnv *env, jclass cls, char nsChar, jint modifierFlags)
730 {
731 jchar javaChar = 0;
732
733 JNF_COCOA_ENTER(env);
734
735 javaChar = NsCharToJavaChar(nsChar, modifierFlags);
736
737 JNF_COCOA_EXIT(env);
738
739 return javaChar;
740 }