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 javaExtMask; 249 jint javaMask; 250 jint javaKey; 251 } 252 const nsKeyToJavaModifierTable[] = 253 { 254 { 255 NSAlphaShiftKeyMask, 256 0, 257 0, 258 0, // no Java equivalent 259 0, // no Java equivalent 260 java_awt_event_KeyEvent_VK_CAPS_LOCK 261 }, 262 { 263 NSShiftKeyMask, 264 //kCGSFlagsMaskAppleShiftKey, 265 //kCGSFlagsMaskAppleRightShiftKey, 266 56, 267 60, 268 java_awt_event_InputEvent_SHIFT_DOWN_MASK, 269 java_awt_event_InputEvent_SHIFT_MASK, 270 java_awt_event_KeyEvent_VK_SHIFT 271 }, 272 { 273 NSControlKeyMask, 274 //kCGSFlagsMaskAppleControlKey, 275 //kCGSFlagsMaskAppleRightControlKey, 276 59, 277 62, 278 java_awt_event_InputEvent_CTRL_DOWN_MASK, 279 java_awt_event_InputEvent_CTRL_MASK, 280 java_awt_event_KeyEvent_VK_CONTROL 281 }, 282 { 283 NSAlternateKeyMask, 284 //kCGSFlagsMaskAppleLeftAlternateKey, 285 //kCGSFlagsMaskAppleRightAlternateKey, 286 58, 287 61, 288 java_awt_event_InputEvent_ALT_DOWN_MASK, 289 java_awt_event_InputEvent_ALT_MASK, 290 java_awt_event_KeyEvent_VK_ALT 291 }, 292 { 293 NSCommandKeyMask, 294 //kCGSFlagsMaskAppleLeftCommandKey, 295 //kCGSFlagsMaskAppleRightCommandKey, 296 55, 297 54, 298 java_awt_event_InputEvent_META_DOWN_MASK, 299 java_awt_event_InputEvent_META_MASK, 300 java_awt_event_KeyEvent_VK_META 301 }, 302 // NSNumericPadKeyMask 303 { 304 NSHelpKeyMask, 305 0, 306 0, 307 0, // no Java equivalent 308 0, // no Java equivalent 309 java_awt_event_KeyEvent_VK_HELP 310 }, 311 // NSFunctionKeyMask 312 {0, 0, 0, 0, 0, 0} 313 }; 314 315 /* 316 * Almost all unicode characters just go from NS to Java with no translation. 317 * For the few exceptions, we handle it here with this small table. 318 */ 319 #define ALL_NS_KEY_MODIFIERS_MASK \ 320 (NSShiftKeyMask | NSControlKeyMask | NSAlternateKeyMask | NSCommandKeyMask) 321 322 static struct _char { 323 NSUInteger modifier; 324 unichar nsChar; 325 unichar javaChar; 326 } 327 const charTable[] = { 328 // map enter on keypad to same as return key 329 {0, NSEnterCharacter, NSNewlineCharacter}, 330 331 // [3134616] return newline instead of carriage return 332 {0, NSCarriageReturnCharacter, NSNewlineCharacter}, 333 334 // "delete" means backspace in Java 335 {ALL_NS_KEY_MODIFIERS_MASK, NSDeleteCharacter, NSBackspaceCharacter}, 336 {ALL_NS_KEY_MODIFIERS_MASK, NSDeleteFunctionKey, NSDeleteCharacter}, 337 338 // back-tab is only differentiated from tab by Shift flag 339 {NSShiftKeyMask, NSBackTabCharacter, NSTabCharacter}, 340 341 {0, 0, 0} 342 }; 343 344 static unichar 345 NsCharToJavaChar(unichar nsChar, NSUInteger modifiers) 346 { 347 const struct _char *cur; 348 // Mask off just the keyboard modifiers from the event modifier mask. 349 NSUInteger testableFlags = (modifiers & ALL_NS_KEY_MODIFIERS_MASK); 350 351 // walk through table & find the match 352 for (cur = charTable; cur->nsChar != 0 ; cur++) { 353 // <rdar://Problem/3476426> Need to determine if we are looking at 354 // a plain keypress or a modified keypress. Don't adjust the 355 // character of a keypress with a modifier. 356 if (cur->nsChar == nsChar) { 357 if (cur->modifier == 0 && testableFlags == 0) { 358 // If the modifier field is 0, that means to transform 359 // this character if no additional keyboard modifiers are set. 360 // This lets ctrl-C be reported as ctrl-C and not transformed 361 // into Newline. 362 return cur->javaChar; 363 } else if (cur->modifier != 0 && 364 (testableFlags & cur->modifier) == testableFlags) 365 { 366 // Likewise, if the modifier field is nonzero, that means 367 // transform this character if only these modifiers are 368 // set in the testable flags. 369 return cur->javaChar; 370 } 371 } 372 } 373 374 if (nsChar >= NSUpArrowFunctionKey && nsChar <= NSModeSwitchFunctionKey) { 375 return java_awt_event_KeyEvent_CHAR_UNDEFINED; 376 } 377 378 // otherwise return character unchanged 379 return nsChar; 380 } 381 382 static unichar NsGetDeadKeyChar(unsigned short keyCode) 383 { 384 TISInputSourceRef currentKeyboard = TISCopyCurrentKeyboardInputSource(); 385 CFDataRef uchr = (CFDataRef)TISGetInputSourceProperty(currentKeyboard, kTISPropertyUnicodeKeyLayoutData); 386 const UCKeyboardLayout *keyboardLayout = (const UCKeyboardLayout*)CFDataGetBytePtr(uchr); 387 // Carbon modifiers should be used instead of NSEvent modifiers 388 UInt32 modifierKeyState = (GetCurrentEventKeyModifiers() >> 8) & 0xFF; 389 390 if (keyboardLayout) { 391 UInt32 deadKeyState = 0; 392 UniCharCount maxStringLength = 255; 393 UniCharCount actualStringLength = 0; 394 UniChar unicodeString[maxStringLength]; 395 396 // get the deadKeyState 397 OSStatus status = UCKeyTranslate(keyboardLayout, 398 keyCode, kUCKeyActionDown, modifierKeyState, 399 LMGetKbdType(), kUCKeyTranslateNoDeadKeysBit, 400 &deadKeyState, 401 maxStringLength, 402 &actualStringLength, unicodeString); 403 404 if (status == noErr && deadKeyState != 0) { 405 // Press SPACE to get the dead key char 406 status = UCKeyTranslate(keyboardLayout, 407 kVK_Space, kUCKeyActionDown, 0, 408 LMGetKbdType(), 0, 409 &deadKeyState, 410 maxStringLength, 411 &actualStringLength, unicodeString); 412 413 if (status == noErr && actualStringLength > 0) { 414 return unicodeString[0]; 415 } 416 } 417 } 418 return 0; 419 } 420 421 /* 422 * This is the function that uses the table above to take incoming 423 * NSEvent keyCodes and translate to the Java virtual key code. 424 */ 425 static void 426 NsCharToJavaVirtualKeyCode(unichar ch, BOOL isDeadChar, 427 NSUInteger flags, unsigned short key, 428 jint *keyCode, jint *keyLocation, BOOL *postsTyped, unichar *deadChar) 429 { 430 static size_t size = sizeof(keyTable) / sizeof(struct _key); 431 NSInteger offset; 432 433 if (isDeadChar) { 434 unichar testDeadChar = NsGetDeadKeyChar(key); 435 const struct CharToVKEntry *map; 436 for (map = charToDeadVKTable; map->c != 0; ++map) { 437 if (testDeadChar == map->c) { 438 *keyCode = map->javaKey; 439 *postsTyped = NO; 440 // TODO: use UNKNOWN here? 441 *keyLocation = java_awt_event_KeyEvent_KEY_LOCATION_UNKNOWN; 442 *deadChar = testDeadChar; 443 return; 444 } 445 } 446 // If we got here, we keep looking for a normal key. 447 } 448 449 if ([[NSCharacterSet letterCharacterSet] characterIsMember:ch]) { 450 // key is an alphabetic character 451 unichar lower; 452 lower = tolower(ch); 453 offset = lower - 'a'; 454 if (offset >= 0 && offset <= 25) { 455 // some chars in letter set are NOT actually A-Z characters?! 456 // skip them... 457 *postsTyped = YES; 458 // do quick conversion 459 *keyCode = java_awt_event_KeyEvent_VK_A + offset; 460 *keyLocation = java_awt_event_KeyEvent_KEY_LOCATION_STANDARD; 461 return; 462 } 463 } 464 465 if ([[NSCharacterSet decimalDigitCharacterSet] characterIsMember:ch]) { 466 // key is a digit 467 offset = ch - '0'; 468 // make sure in range for decimal digits 469 if (offset >= 0 && offset <= 9) { 470 jboolean numpad = (flags & NSNumericPadKeyMask) != 0; 471 *postsTyped = YES; 472 if (numpad) { 473 *keyCode = offset + java_awt_event_KeyEvent_VK_NUMPAD0; 474 *keyLocation = java_awt_event_KeyEvent_KEY_LOCATION_NUMPAD; 475 } else { 476 *keyCode = offset + java_awt_event_KeyEvent_VK_0; 477 *keyLocation = java_awt_event_KeyEvent_KEY_LOCATION_STANDARD; 478 } 479 return; 480 } 481 } 482 483 if (key < size) { 484 *postsTyped = keyTable[key].postsTyped; 485 *keyCode = keyTable[key].javaKeyCode; 486 *keyLocation = keyTable[key].javaKeyLocation; 487 } else { 488 // Should we report this? This means we've got a keyboard 489 // we don't know about... 490 *postsTyped = NO; 491 *keyCode = java_awt_event_KeyEvent_VK_UNDEFINED; 492 *keyLocation = java_awt_event_KeyEvent_KEY_LOCATION_UNKNOWN; 493 } 494 } 495 496 /* 497 * This returns the java key data for the key NSEvent modifiers 498 * (after NSFlagChanged). 499 */ 500 static void 501 NsKeyModifiersToJavaKeyInfo(NSUInteger nsFlags, unsigned short eventKeyCode, 502 jint *javaKeyCode, 503 jint *javaKeyLocation, 504 jint *javaKeyType) 505 { 506 static NSUInteger sPreviousNSFlags = 0; 507 508 const struct _nsKeyToJavaModifier* cur; 509 NSUInteger oldNSFlags = sPreviousNSFlags; 510 NSUInteger changedNSFlags = oldNSFlags ^ nsFlags; 511 sPreviousNSFlags = nsFlags; 512 513 *javaKeyCode = java_awt_event_KeyEvent_VK_UNDEFINED; 514 *javaKeyLocation = java_awt_event_KeyEvent_KEY_LOCATION_UNKNOWN; 515 *javaKeyType = java_awt_event_KeyEvent_KEY_PRESSED; 516 517 for (cur = nsKeyToJavaModifierTable; cur->nsMask != 0; ++cur) { 518 if (changedNSFlags & cur->nsMask) { 519 *javaKeyCode = cur->javaKey; 520 *javaKeyLocation = java_awt_event_KeyEvent_KEY_LOCATION_STANDARD; 521 // TODO: uses SPI... 522 //if (changedNSFlags & cur->cgsLeftMask) { 523 // *javaKeyLocation = java_awt_event_KeyEvent_KEY_LOCATION_LEFT; 524 //} else if (changedNSFlags & cur->cgsRightMask) { 525 // *javaKeyLocation = java_awt_event_KeyEvent_KEY_LOCATION_RIGHT; 526 //} 527 if (eventKeyCode == cur->leftKeyCode) { 528 *javaKeyLocation = java_awt_event_KeyEvent_KEY_LOCATION_LEFT; 529 } else if (eventKeyCode == cur->rightKeyCode) { 530 *javaKeyLocation = java_awt_event_KeyEvent_KEY_LOCATION_RIGHT; 531 } 532 *javaKeyType = (cur->nsMask & nsFlags) ? 533 java_awt_event_KeyEvent_KEY_PRESSED : 534 java_awt_event_KeyEvent_KEY_RELEASED; 535 break; 536 } 537 } 538 } 539 540 /* 541 * This returns the java modifiers for a key NSEvent. 542 */ 543 jint NsKeyModifiersToJavaModifiers(NSUInteger nsFlags, BOOL isExtMods) 544 { 545 jint javaModifiers = 0; 546 const struct _nsKeyToJavaModifier* cur; 547 548 for (cur = nsKeyToJavaModifierTable; cur->nsMask != 0; ++cur) { 549 if ((cur->nsMask & nsFlags) != 0) { 550 javaModifiers |= isExtMods? cur->javaExtMask : cur->javaMask; 551 } 552 } 553 554 return javaModifiers; 555 } 556 557 /* 558 * This returns the NSEvent flags for java key modifiers. 559 */ 560 NSUInteger JavaModifiersToNsKeyModifiers(jint javaModifiers, BOOL isExtMods) 561 { 562 NSUInteger nsFlags = 0; 563 const struct _nsKeyToJavaModifier* cur; 564 565 for (cur = nsKeyToJavaModifierTable; cur->nsMask != 0; ++cur) { 566 jint mask = isExtMods? cur->javaExtMask : cur->javaMask; 567 if ((mask & javaModifiers) != 0) { 568 nsFlags |= cur->nsMask; 569 } 570 } 571 572 // special case 573 jint mask = isExtMods? java_awt_event_InputEvent_ALT_GRAPH_DOWN_MASK : 574 java_awt_event_InputEvent_ALT_GRAPH_MASK; 575 576 if ((mask & javaModifiers) != 0) { 577 nsFlags |= NSAlternateKeyMask; 578 } 579 580 return nsFlags; 581 } 582 583 584 jint GetJavaMouseModifiers(NSInteger button, NSUInteger modifierFlags) 585 { 586 // Mousing needs the key modifiers 587 jint modifiers = NsKeyModifiersToJavaModifiers(modifierFlags, YES); 588 589 590 /* 591 * Ask Quartz about mouse buttons state 592 */ 593 594 if (CGEventSourceButtonState(kCGEventSourceStateCombinedSessionState, 595 kCGMouseButtonLeft)) { 596 modifiers |= java_awt_event_InputEvent_BUTTON1_DOWN_MASK; 597 } 598 599 if (CGEventSourceButtonState(kCGEventSourceStateCombinedSessionState, 600 kCGMouseButtonRight)) { 601 modifiers |= java_awt_event_InputEvent_BUTTON3_DOWN_MASK; 602 } 603 604 if (CGEventSourceButtonState(kCGEventSourceStateCombinedSessionState, 605 kCGMouseButtonCenter)) { 606 modifiers |= java_awt_event_InputEvent_BUTTON2_DOWN_MASK; 607 } 608 609 NSInteger extraButton = 3; 610 for (; extraButton < gNumberOfButtons; extraButton++) { 611 if (CGEventSourceButtonState(kCGEventSourceStateCombinedSessionState, 612 extraButton)) { 613 modifiers |= gButtonDownMasks[extraButton]; 614 } 615 } 616 617 return modifiers; 618 } 619 620 jlong UTC(NSEvent *event) { 621 struct timeval tv; 622 if (gettimeofday(&tv, NULL) == 0) { 623 long long sec = (long long)tv.tv_sec; 624 return (sec*1000) + (tv.tv_usec/1000); 625 } 626 return 0; 627 } 628 629 JNIEXPORT void JNICALL 630 Java_java_awt_AWTEvent_nativeSetSource 631 (JNIEnv *env, jobject self, jobject newSource) 632 { 633 } 634 635 /* 636 * Class: sun_lwawt_macosx_event_NSEvent 637 * Method: nsToJavaMouseModifiers 638 * Signature: (II)I 639 */ 640 JNIEXPORT jint JNICALL 641 Java_sun_lwawt_macosx_event_NSEvent_nsToJavaMouseModifiers 642 (JNIEnv *env, jclass cls, jint buttonNumber, jint modifierFlags) 643 { 644 jint jmodifiers = 0; 645 646 JNF_COCOA_ENTER(env); 647 648 jmodifiers = GetJavaMouseModifiers(buttonNumber, modifierFlags); 649 650 JNF_COCOA_EXIT(env); 651 652 return jmodifiers; 653 } 654 655 /* 656 * Class: sun_lwawt_macosx_event_NSEvent 657 * Method: nsToJavaKeyModifiers 658 * Signature: (I)I 659 */ 660 JNIEXPORT jint JNICALL 661 Java_sun_lwawt_macosx_event_NSEvent_nsToJavaKeyModifiers 662 (JNIEnv *env, jclass cls, jint modifierFlags) 663 { 664 jint jmodifiers = 0; 665 666 JNF_COCOA_ENTER(env); 667 668 jmodifiers = NsKeyModifiersToJavaModifiers(modifierFlags, YES); 669 670 JNF_COCOA_EXIT(env); 671 672 return jmodifiers; 673 } 674 675 /* 676 * Class: sun_lwawt_macosx_event_NSEvent 677 * Method: nsToJavaKeyInfo 678 * Signature: ([I[I)Z 679 */ 680 JNIEXPORT jboolean JNICALL 681 Java_sun_lwawt_macosx_event_NSEvent_nsToJavaKeyInfo 682 (JNIEnv *env, jclass cls, jintArray inData, jintArray outData) 683 { 684 BOOL postsTyped = NO; 685 686 JNF_COCOA_ENTER(env); 687 688 jboolean copy = JNI_FALSE; 689 jint *data = (*env)->GetIntArrayElements(env, inData, ©); 690 691 // in = [testChar, testDeadChar, modifierFlags, keyCode] 692 jchar testChar = (jchar)data[0]; 693 BOOL isDeadChar = (data[1] != 0); 694 jint modifierFlags = data[2]; 695 jshort keyCode = (jshort)data[3]; 696 697 jint jkeyCode = java_awt_event_KeyEvent_VK_UNDEFINED; 698 jint jkeyLocation = java_awt_event_KeyEvent_KEY_LOCATION_UNKNOWN; 699 jchar testDeadChar = 0; 700 701 NsCharToJavaVirtualKeyCode((unichar)testChar, isDeadChar, 702 (NSUInteger)modifierFlags, (unsigned short)keyCode, 703 &jkeyCode, &jkeyLocation, &postsTyped, &testDeadChar); 704 705 // out = [jkeyCode, jkeyLocation]; 706 (*env)->SetIntArrayRegion(env, outData, 0, 1, &jkeyCode); 707 (*env)->SetIntArrayRegion(env, outData, 1, 1, &jkeyLocation); 708 (*env)->SetIntArrayRegion(env, outData, 2, 1, (jint *)&testDeadChar); 709 710 (*env)->ReleaseIntArrayElements(env, inData, data, 0); 711 712 JNF_COCOA_EXIT(env); 713 714 return postsTyped; 715 } 716 717 /* 718 * Class: sun_lwawt_macosx_event_NSEvent 719 * Method: nsKeyModifiersToJavaKeyInfo 720 * Signature: ([I[I)V 721 */ 722 JNIEXPORT void JNICALL 723 Java_sun_lwawt_macosx_event_NSEvent_nsKeyModifiersToJavaKeyInfo 724 (JNIEnv *env, jclass cls, jintArray inData, jintArray outData) 725 { 726 JNF_COCOA_ENTER(env); 727 728 jboolean copy = JNI_FALSE; 729 jint *data = (*env)->GetIntArrayElements(env, inData, ©); 730 731 // in = [modifierFlags, keyCode] 732 jint modifierFlags = data[0]; 733 jshort keyCode = (jshort)data[1]; 734 735 jint jkeyCode = java_awt_event_KeyEvent_VK_UNDEFINED; 736 jint jkeyLocation = java_awt_event_KeyEvent_KEY_LOCATION_UNKNOWN; 737 jint jkeyType = java_awt_event_KeyEvent_KEY_PRESSED; 738 739 NsKeyModifiersToJavaKeyInfo(modifierFlags, 740 keyCode, 741 &jkeyCode, 742 &jkeyLocation, 743 &jkeyType); 744 745 // out = [jkeyCode, jkeyLocation, jkeyType]; 746 (*env)->SetIntArrayRegion(env, outData, 0, 1, &jkeyCode); 747 (*env)->SetIntArrayRegion(env, outData, 1, 1, &jkeyLocation); 748 (*env)->SetIntArrayRegion(env, outData, 2, 1, &jkeyType); 749 750 (*env)->ReleaseIntArrayElements(env, inData, data, 0); 751 752 JNF_COCOA_EXIT(env); 753 } 754 755 /* 756 * Class: sun_lwawt_macosx_event_NSEvent 757 * Method: nsToJavaChar 758 * Signature: (CI)C 759 */ 760 JNIEXPORT jint JNICALL 761 Java_sun_lwawt_macosx_event_NSEvent_nsToJavaChar 762 (JNIEnv *env, jclass cls, char nsChar, jint modifierFlags) 763 { 764 jchar javaChar = 0; 765 766 JNF_COCOA_ENTER(env); 767 768 javaChar = NsCharToJavaChar(nsChar, modifierFlags); 769 770 JNF_COCOA_EXIT(env); 771 772 return javaChar; 773 }