1 /* 2 * Copyright (c) 2002, 2018, 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 #include "awt.h" 27 #include "awt_util.h" 28 #include "jni.h" 29 #include "jlong.h" 30 #include "Region.h" 31 #include "sizecalc.h" 32 #include "utility/rect.h" 33 34 #include "sun_awt_X11_XlibWrapper.h" 35 36 #include <stdlib.h> 37 #include <string.h> 38 #include <X11/extensions/Xdbe.h> 39 #include <X11/extensions/shape.h> 40 #include <X11/keysym.h> 41 #include <X11/Sunkeysym.h> 42 #include <X11/Xlib.h> 43 #include <X11/Xatom.h> 44 #include <X11/XKBlib.h> 45 #include <X11/Xos.h> 46 #include <X11/Xutil.h> 47 48 #if defined(AIX) 49 #undef X_HAVE_UTF8_STRING 50 extern Bool statusWindowEventHandler(XEvent event); 51 #endif 52 53 // From XWindow.c 54 extern KeySym keycodeToKeysym(Display *display, KeyCode keycode, int index); 55 56 #if defined(DEBUG) 57 static jmethodID lockIsHeldMID = NULL; 58 59 static void 60 CheckHaveAWTLock(JNIEnv *env) 61 { 62 if (lockIsHeldMID == NULL) { 63 if (tkClass == NULL) return; 64 lockIsHeldMID = 65 (*env)->GetStaticMethodID(env, tkClass, 66 "isAWTLockHeldByCurrentThread", "()Z"); 67 if (lockIsHeldMID == NULL) return; 68 } 69 if (!(*env)->CallStaticBooleanMethod(env, tkClass, lockIsHeldMID)) { 70 JNU_ThrowInternalError(env, "Current thread does not hold AWT_LOCK!"); 71 } 72 } 73 74 #define AWT_CHECK_HAVE_LOCK() \ 75 do { \ 76 CheckHaveAWTLock(env); \ 77 if ((*env)->ExceptionCheck(env)) { \ 78 return; \ 79 } \ 80 } while (0); \ 81 82 #define AWT_CHECK_HAVE_LOCK_RETURN(ret) \ 83 do { \ 84 CheckHaveAWTLock(env); \ 85 if ((*env)->ExceptionCheck(env)) { \ 86 return (ret); \ 87 } \ 88 } while (0); \ 89 90 #else 91 #define AWT_CHECK_HAVE_LOCK() 92 #define AWT_CHECK_HAVE_LOCK_RETURN(ret) 93 #endif 94 95 void freeNativeStringArray(char **array, jsize length) { 96 int i; 97 if (array == NULL) { 98 return; 99 } 100 for (i = 0; i < length; i++) { 101 free(array[i]); 102 } 103 free(array); 104 } 105 106 char** stringArrayToNative(JNIEnv *env, jobjectArray array, jsize * ret_length) { 107 Bool err = FALSE; 108 char ** strings; 109 int index, str_index = 0; 110 jsize length = (*env)->GetArrayLength(env, array); 111 112 if (length == 0) { 113 return NULL; 114 } 115 116 strings = (char**) calloc(length, sizeof (char*)); 117 118 if (strings == NULL) { 119 JNU_ThrowOutOfMemoryError(env, ""); 120 return NULL; 121 } 122 123 for (index = 0; index < length; index++) { 124 jstring str = (*env)->GetObjectArrayElement(env, array, index); 125 if (str != NULL) { 126 const char * str_char = JNU_GetStringPlatformChars(env, str, NULL); 127 if (str_char != NULL) { 128 char * dup_str = strdup(str_char); 129 if (dup_str != NULL) { 130 strings[str_index++] = dup_str; 131 } else { 132 JNU_ThrowOutOfMemoryError(env, ""); 133 err = TRUE; 134 } 135 JNU_ReleaseStringPlatformChars(env, str, str_char); 136 } else { 137 err = TRUE; 138 } 139 (*env)->DeleteLocalRef(env, str); 140 if (err) { 141 break; 142 } 143 } 144 } 145 146 if (err) { 147 freeNativeStringArray(strings, str_index); 148 strings = NULL; 149 str_index = -1; 150 } 151 *ret_length = str_index; 152 153 return strings; 154 } 155 156 /* 157 * Class: XlibWrapper 158 * Method: XOpenDisplay 159 * Signature: (J)J 160 */ 161 162 JNIEXPORT jlong JNICALL Java_sun_awt_X11_XlibWrapper_XOpenDisplay 163 (JNIEnv *env, jclass clazz, jlong display_name) 164 { 165 Display *dp; 166 AWT_CHECK_HAVE_LOCK_RETURN(0); 167 dp = XOpenDisplay((char *) jlong_to_ptr(display_name)); 168 169 return ptr_to_jlong(dp); 170 } 171 172 JNIEXPORT void JNICALL 173 Java_sun_awt_X11_XlibWrapper_XCloseDisplay(JNIEnv *env, jclass clazz, 174 jlong display) { 175 AWT_CHECK_HAVE_LOCK(); 176 XCloseDisplay((Display*) jlong_to_ptr(display)); 177 } 178 179 JNIEXPORT jlong JNICALL 180 Java_sun_awt_X11_XlibWrapper_XDisplayString(JNIEnv *env, jclass clazz, 181 jlong display) { 182 AWT_CHECK_HAVE_LOCK_RETURN(0); 183 return ptr_to_jlong(XDisplayString((Display*) jlong_to_ptr(display))); 184 } 185 186 JNIEXPORT void JNICALL 187 Java_sun_awt_X11_XlibWrapper_XSetCloseDownMode(JNIEnv *env, jclass clazz, 188 jlong display, jint mode) { 189 AWT_CHECK_HAVE_LOCK(); 190 XSetCloseDownMode((Display*) jlong_to_ptr(display), (int)mode); 191 } 192 193 /* 194 * Class: sun_awt_X11_XlibWrapper 195 * Method: DefaultScreen 196 * Signature: (J)J 197 */ 198 JNIEXPORT jlong JNICALL Java_sun_awt_X11_XlibWrapper_DefaultScreen (JNIEnv *env, jclass clazz, jlong display) { 199 200 AWT_CHECK_HAVE_LOCK_RETURN(0); 201 return (jlong) DefaultScreen((Display *) jlong_to_ptr(display)); 202 } 203 204 /* 205 * Class: sun_awt_X11_XlibWrapper 206 * Method: ScreenOfDisplay 207 * Signature: (JJ)J 208 */ 209 JNIEXPORT jlong JNICALL Java_sun_awt_X11_XlibWrapper_ScreenOfDisplay(JNIEnv *env, jclass clazz, jlong display, jlong screen_number) { 210 AWT_CHECK_HAVE_LOCK_RETURN(0); 211 return ptr_to_jlong(ScreenOfDisplay((Display *) jlong_to_ptr(display), 212 screen_number)); 213 } 214 215 /* 216 * Class: sun_awt_X11_XlibWrapper 217 * Method: DoesBackingStore 218 * Signature: (J)I 219 */ 220 JNIEXPORT jint JNICALL Java_sun_awt_X11_XlibWrapper_DoesBackingStore(JNIEnv *env, jclass clazz, jlong screen) { 221 AWT_CHECK_HAVE_LOCK_RETURN(0); 222 return (jint) DoesBackingStore((Screen*) jlong_to_ptr(screen)); 223 } 224 225 /* 226 * Class: sun_awt_X11_XlibWrapper 227 * Method: DisplayWidth 228 * Signature: (JJ)J 229 */ 230 JNIEXPORT jlong JNICALL Java_sun_awt_X11_XlibWrapper_DisplayWidth 231 (JNIEnv *env, jclass clazz, jlong display, jlong screen) { 232 233 AWT_CHECK_HAVE_LOCK_RETURN(0); 234 return (jlong) DisplayWidth((Display *) jlong_to_ptr(display),screen); 235 236 } 237 238 /* 239 * Class: sun_awt_X11_XlibWrapper 240 * Method: DisplayWidthMM 241 * Signature: (JJ)J 242 */ 243 JNIEXPORT jlong JNICALL Java_sun_awt_X11_XlibWrapper_DisplayWidthMM 244 (JNIEnv *env, jclass clazz, jlong display, jlong screen) { 245 AWT_CHECK_HAVE_LOCK_RETURN(0); 246 return (jlong) DisplayWidthMM((Display *) jlong_to_ptr(display),screen); 247 } 248 249 /* 250 * Class: sun_awt_X11_XlibWrapper 251 * Method: DisplayHeight 252 * Signature: (JJ)J 253 */ 254 JNIEXPORT jlong JNICALL Java_sun_awt_X11_XlibWrapper_DisplayHeight 255 (JNIEnv *env, jclass clazz, jlong display, jlong screen) { 256 257 AWT_CHECK_HAVE_LOCK_RETURN(0); 258 return (jlong) DisplayHeight((Display *) jlong_to_ptr(display),screen); 259 } 260 /* 261 * Class: sun_awt_X11_XlibWrapper 262 * Method: DisplayHeightMM 263 * Signature: (JJ)J 264 */ 265 JNIEXPORT jlong JNICALL Java_sun_awt_X11_XlibWrapper_DisplayHeightMM 266 (JNIEnv *env, jclass clazz, jlong display, jlong screen) { 267 AWT_CHECK_HAVE_LOCK_RETURN(0); 268 return (jlong) DisplayHeightMM((Display *) jlong_to_ptr(display),screen); 269 } 270 271 /* 272 * Class: sun_awt_X11_XlibWrapper 273 * Method: RootWindow 274 * Signature: (JJ)J 275 */ 276 JNIEXPORT jlong JNICALL Java_sun_awt_X11_XlibWrapper_RootWindow 277 (JNIEnv *env , jclass clazz, jlong display, jlong screen_number) { 278 AWT_CHECK_HAVE_LOCK_RETURN(0); 279 return (jlong) RootWindow((Display *) jlong_to_ptr(display), screen_number); 280 } 281 282 /* 283 * Class: sun_awt_X11_XlibWrapper 284 * Method: ScreenCount 285 */ 286 JNIEXPORT jint JNICALL Java_sun_awt_X11_XlibWrapper_ScreenCount 287 (JNIEnv *env , jclass clazz, jlong display) { 288 AWT_CHECK_HAVE_LOCK_RETURN(0); 289 return ScreenCount((Display *) jlong_to_ptr(display)); 290 } 291 292 /* 293 * Class: XlibWrapper 294 * Method: XCreateWindow 295 * Signature: (JJIIIIIIJJJJ)J 296 */ 297 JNIEXPORT jlong JNICALL Java_sun_awt_X11_XlibWrapper_XCreateWindow 298 (JNIEnv *env, jclass clazz, jlong display, jlong window, 299 jint x, jint y, jint w, jint h , jint border_width, jint depth, 300 jlong wclass, jlong visual, jlong valuemask, jlong attributes) 301 { 302 AWT_CHECK_HAVE_LOCK_RETURN(0); 303 return XCreateWindow((Display *) jlong_to_ptr(display),(Window) window, x, y, w, h, 304 border_width, depth, wclass, (Visual *) jlong_to_ptr(visual), 305 valuemask, (XSetWindowAttributes *) jlong_to_ptr(attributes)); 306 } 307 308 /* 309 * Class: XlibWrapper 310 * Method: XConvertCase 311 * Signature: (JJJ)V 312 */ 313 JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XConvertCase 314 (JNIEnv *env, jclass clazz, jlong keysym, 315 jlong keysym_lowercase, jlong keysym_uppercase) 316 { 317 AWT_CHECK_HAVE_LOCK(); 318 XConvertCase(keysym, (jlong_to_ptr(keysym_lowercase)), 319 (jlong_to_ptr(keysym_uppercase))); 320 } 321 322 /* 323 * Class: XlibWrapper 324 * Method: XMapWindow 325 * Signature: (JJ)V 326 */ 327 JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XMapWindow 328 (JNIEnv *env, jclass clazz, jlong display, jlong window) 329 { 330 AWT_CHECK_HAVE_LOCK(); 331 XMapWindow( (Display *)jlong_to_ptr(display),(Window) window); 332 } 333 334 /* 335 * Class: XlibWrapper 336 * Method: XMapRaised 337 * Signature: (JJ)V 338 */ 339 JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XMapRaised 340 (JNIEnv *env, jclass clazz, jlong display, jlong window) 341 { 342 AWT_CHECK_HAVE_LOCK(); 343 XMapRaised( (Display *)jlong_to_ptr(display),(Window) window); 344 } 345 346 /* 347 * Class: XlibWrapper 348 * Method: XRaiseWindow 349 * Signature: (JJ)V 350 */ 351 JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XRaiseWindow 352 (JNIEnv *env, jclass clazz, jlong display, jlong window) 353 { 354 AWT_CHECK_HAVE_LOCK(); 355 XRaiseWindow( (Display *)jlong_to_ptr(display),(Window) window); 356 } 357 358 /* 359 * Class: XlibWrapper 360 * Method: XLowerWindow 361 * Signature: (JJ)V 362 */ 363 JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XLowerWindow 364 (JNIEnv *env, jclass clazz, jlong display, jlong window) 365 { 366 AWT_CHECK_HAVE_LOCK(); 367 XLowerWindow( (Display *)jlong_to_ptr(display),(Window) window); 368 } 369 370 /* 371 * Class: XlibWrapper 372 * Method: XRestackWindows 373 * Signature: (JJI)V 374 */ 375 JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XRestackWindows 376 (JNIEnv *env, jclass clazz, jlong display, jlong windows, jint length) 377 { 378 AWT_CHECK_HAVE_LOCK(); 379 XRestackWindows( (Display *) jlong_to_ptr(display), (Window *) jlong_to_ptr(windows), length); 380 } 381 382 /* 383 * Class: XlibWrapper 384 * Method: XConfigureWindow 385 * Signature: (JJJJ)V 386 */ 387 JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XConfigureWindow 388 (JNIEnv *env, jclass clazz, jlong display, jlong window, jlong value_mask, 389 jlong values) 390 { 391 AWT_CHECK_HAVE_LOCK(); 392 XConfigureWindow((Display*)jlong_to_ptr(display), (Window)window, 393 (unsigned int)value_mask, (XWindowChanges*)jlong_to_ptr(values)); 394 } 395 396 /* 397 * Class: XlibWrapper 398 * Method: XSetInputFocus 399 * Signature: (JJ)V 400 */ 401 JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XSetInputFocus 402 (JNIEnv *env, jclass clazz, jlong display, jlong window) 403 { 404 AWT_CHECK_HAVE_LOCK(); 405 XSetInputFocus( (Display *)jlong_to_ptr(display),(Window) window, RevertToPointerRoot, CurrentTime); 406 } 407 408 /* 409 * Class: XlibWrapper 410 * Method: XSetInputFocus2 411 * Signature: (JJJ)V 412 */ 413 JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XSetInputFocus2 414 (JNIEnv *env, jclass clazz, jlong display, jlong window, jlong time) 415 { 416 AWT_CHECK_HAVE_LOCK(); 417 XSetInputFocus( (Display *)jlong_to_ptr(display),(Window) window, RevertToPointerRoot, time); 418 } 419 420 /* 421 * Class: XlibWrapper 422 * Method: XGetInputFocus 423 * Signature: (JJ)V 424 */ 425 JNIEXPORT jlong JNICALL Java_sun_awt_X11_XlibWrapper_XGetInputFocus 426 (JNIEnv *env, jclass clazz, jlong display) 427 { 428 Window focusOwner; 429 int revert_to; 430 AWT_CHECK_HAVE_LOCK_RETURN(0); 431 XGetInputFocus( (Display *)jlong_to_ptr(display), &focusOwner, &revert_to); 432 return focusOwner; 433 } 434 435 /* 436 * Class: XlibWrapper 437 * Method: XDestroyWindow 438 * Signature: (JJ)V 439 */ 440 JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XDestroyWindow 441 (JNIEnv *env, jclass clazz, jlong display, jlong window) 442 { 443 AWT_CHECK_HAVE_LOCK(); 444 XDestroyWindow( (Display *)jlong_to_ptr(display),(Window) window); 445 } 446 447 JNIEXPORT jint JNICALL Java_sun_awt_X11_XlibWrapper_XGrabPointer 448 (JNIEnv *env, jclass clazz, jlong display, jlong window, 449 jint owner_events, jint event_mask, jint pointer_mode, 450 jint keyboard_mode, jlong confine_to, jlong cursor, jlong time) 451 { 452 AWT_CHECK_HAVE_LOCK_RETURN(0); 453 return XGrabPointer( (Display *)jlong_to_ptr(display), (Window) window, 454 (Bool) owner_events, (unsigned int) event_mask, (int) pointer_mode, 455 (int) keyboard_mode, (Window) confine_to, (Cursor) cursor, (Time) time); 456 } 457 458 JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XUngrabPointer 459 (JNIEnv *env, jclass clazz, jlong display, jlong time) 460 { 461 AWT_CHECK_HAVE_LOCK(); 462 XUngrabPointer( (Display *)jlong_to_ptr(display), (Time) time); 463 } 464 465 JNIEXPORT jint JNICALL Java_sun_awt_X11_XlibWrapper_XGrabKeyboard 466 (JNIEnv *env, jclass clazz, jlong display, jlong window, 467 jint owner_events, jint pointer_mode, 468 jint keyboard_mode, jlong time) 469 { 470 AWT_CHECK_HAVE_LOCK_RETURN(0); 471 return XGrabKeyboard( (Display *)jlong_to_ptr(display), (Window) window, 472 (Bool) owner_events, (int) pointer_mode, 473 (int) keyboard_mode, (Time) time); 474 } 475 476 JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XUngrabKeyboard 477 (JNIEnv *env, jclass clazz, jlong display, jlong time) 478 { 479 AWT_CHECK_HAVE_LOCK(); 480 XUngrabKeyboard( (Display *)jlong_to_ptr(display), (Time) time); 481 } 482 483 JNIEXPORT void JNICALL 484 Java_sun_awt_X11_XlibWrapper_XGrabServer(JNIEnv *env, jclass clazz, 485 jlong display) { 486 AWT_CHECK_HAVE_LOCK(); 487 XGrabServer((Display*)jlong_to_ptr(display)); 488 } 489 490 JNIEXPORT void JNICALL 491 Java_sun_awt_X11_XlibWrapper_XUngrabServer(JNIEnv *env, jclass clazz, 492 jlong display) { 493 AWT_CHECK_HAVE_LOCK(); 494 XUngrabServer((Display*)jlong_to_ptr(display)); 495 /* Workaround for bug 5039226 */ 496 XSync((Display*)jlong_to_ptr(display), False); 497 } 498 499 /* 500 * Class: XlibWrapper 501 * Method: XUnmapWindow 502 * Signature: (JJ)V 503 */ 504 JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XUnmapWindow 505 (JNIEnv *env, jclass clazz, jlong display, jlong window) 506 { 507 508 AWT_CHECK_HAVE_LOCK(); 509 XUnmapWindow( (Display *)jlong_to_ptr(display),(Window) window); 510 511 } 512 513 JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XSelectInput 514 (JNIEnv *env, jclass clazz, jlong display, jlong window, jlong mask) 515 { 516 AWT_CHECK_HAVE_LOCK(); 517 XSelectInput((Display *) jlong_to_ptr(display), (Window) window, mask); 518 } 519 520 JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XkbSelectEvents 521 (JNIEnv *env, jclass clazz, jlong display, jlong device, jlong bits_to_change, 522 jlong values_for_bits) 523 { 524 AWT_CHECK_HAVE_LOCK(); 525 XkbSelectEvents((Display *) jlong_to_ptr(display), (unsigned int)device, 526 (unsigned long)bits_to_change, 527 (unsigned long)values_for_bits); 528 } 529 530 JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XkbSelectEventDetails 531 (JNIEnv *env, jclass clazz, jlong display, jlong device, jlong event_type, 532 jlong bits_to_change, jlong values_for_bits) 533 { 534 AWT_CHECK_HAVE_LOCK(); 535 XkbSelectEventDetails((Display *) jlong_to_ptr(display), (unsigned int)device, 536 (unsigned int) event_type, 537 (unsigned long)bits_to_change, 538 (unsigned long)values_for_bits); 539 } 540 541 JNIEXPORT jboolean JNICALL Java_sun_awt_X11_XlibWrapper_XkbQueryExtension 542 (JNIEnv *env, jclass clazz, jlong display, jlong opcode_rtrn, jlong event_rtrn, 543 jlong error_rtrn, jlong major_in_out, jlong minor_in_out) 544 { 545 Bool status; 546 AWT_CHECK_HAVE_LOCK_RETURN(JNI_FALSE); 547 status = XkbQueryExtension((Display *) jlong_to_ptr(display), 548 (int *) jlong_to_ptr(opcode_rtrn), 549 (int *) jlong_to_ptr(event_rtrn), 550 (int *) jlong_to_ptr(error_rtrn), 551 (int *) jlong_to_ptr(major_in_out), 552 (int *) jlong_to_ptr(minor_in_out)); 553 return status ? JNI_TRUE : JNI_FALSE; 554 } 555 556 JNIEXPORT jboolean JNICALL Java_sun_awt_X11_XlibWrapper_XkbLibraryVersion 557 (JNIEnv *env, jclass clazz, jlong lib_major_in_out, jlong lib_minor_in_out) 558 { 559 Bool status; 560 AWT_CHECK_HAVE_LOCK_RETURN(JNI_FALSE); 561 *((int *)jlong_to_ptr(lib_major_in_out)) = XkbMajorVersion; 562 *((int *)jlong_to_ptr(lib_minor_in_out)) = XkbMinorVersion; 563 status = XkbLibraryVersion((int *)jlong_to_ptr(lib_major_in_out), 564 (int *)jlong_to_ptr(lib_minor_in_out)); 565 return status ? JNI_TRUE : JNI_FALSE; 566 } 567 568 JNIEXPORT jlong JNICALL Java_sun_awt_X11_XlibWrapper_XkbGetMap 569 (JNIEnv *env, jclass clazz, jlong display, jlong which, jlong device_spec) 570 { 571 AWT_CHECK_HAVE_LOCK_RETURN(0); 572 return (jlong) XkbGetMap( (Display *) jlong_to_ptr(display), 573 (unsigned int) which, 574 (unsigned int) device_spec); 575 } 576 577 JNIEXPORT jlong JNICALL Java_sun_awt_X11_XlibWrapper_XkbGetUpdatedMap 578 (JNIEnv *env, jclass clazz, jlong display, jlong which, jlong xkb) 579 { 580 AWT_CHECK_HAVE_LOCK_RETURN(0); 581 return (jlong) XkbGetUpdatedMap( (Display *) jlong_to_ptr(display), 582 (unsigned int) which, 583 (XkbDescPtr) jlong_to_ptr(xkb)); 584 } 585 JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XkbFreeKeyboard 586 (JNIEnv *env, jclass clazz, jlong xkb, jlong which, jboolean free_all) 587 { 588 AWT_CHECK_HAVE_LOCK(); 589 XkbFreeKeyboard(jlong_to_ptr(xkb), (unsigned int)which, free_all); 590 } 591 JNIEXPORT jboolean JNICALL Java_sun_awt_X11_XlibWrapper_XkbTranslateKeyCode 592 (JNIEnv *env, jclass clazz, jlong xkb, jint keycode, jlong mods, jlong mods_rtrn, jlong keysym_rtrn) 593 { 594 AWT_CHECK_HAVE_LOCK_RETURN(JNI_FALSE); 595 Bool b; 596 b = XkbTranslateKeyCode((XkbDescPtr)xkb, (unsigned int)keycode, (unsigned int)mods, 597 (unsigned int *)jlong_to_ptr(mods_rtrn), 598 (KeySym *)jlong_to_ptr(keysym_rtrn)); 599 //printf("native, input: keycode:0x%0X; mods:0x%0X\n", keycode, mods); 600 //printf("native, output: keysym:0x%0X; mods:0x%0X\n", 601 // *(unsigned int *)jlong_to_ptr(keysym_rtrn), 602 // *(unsigned int *)jlong_to_ptr(mods_rtrn)); 603 return b ? JNI_TRUE : JNI_FALSE; 604 } 605 JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XkbSetDetectableAutoRepeat 606 (JNIEnv *env, jclass clazz, jlong display, jboolean detectable) 607 { 608 AWT_CHECK_HAVE_LOCK(); 609 XkbSetDetectableAutoRepeat((Display *) jlong_to_ptr(display), detectable, NULL); 610 } 611 /* 612 * Class: sun_awt_X11_XlibWrapper 613 * Method: XNextEvent 614 * Signature: (JJ)V 615 */ 616 JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XNextEvent 617 (JNIEnv *env, jclass clazz, jlong display, jlong ptr) 618 { 619 AWT_CHECK_HAVE_LOCK(); 620 XNextEvent( (Display *) jlong_to_ptr(display), jlong_to_ptr(ptr)); 621 } 622 623 /* 624 * Class: sun_awt_X11_XlibWrapper 625 * Method: XMaskEvent 626 * Signature: (JJJ)V 627 */ 628 JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XMaskEvent 629 (JNIEnv *env, jclass clazz, jlong display, jlong event_mask, jlong event_return) 630 { 631 AWT_CHECK_HAVE_LOCK(); 632 XMaskEvent( (Display *) jlong_to_ptr(display), event_mask, (XEvent *) jlong_to_ptr(event_return)); 633 } 634 635 /* 636 * Class: sun_awt_X11_XlibWrapper 637 * Method: XWindowEvent 638 * Signature: (JJJJ)V 639 */ 640 JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XWindowEvent 641 (JNIEnv *env, jclass clazz, jlong display, jlong window, jlong event_mask, jlong event_return) 642 { 643 AWT_CHECK_HAVE_LOCK(); 644 XWindowEvent( (Display *) jlong_to_ptr(display), (Window)window, event_mask, (XEvent *) jlong_to_ptr(event_return)); 645 } 646 647 /* 648 * Class: sun_awt_X11_XlibWrapper 649 * Method: XFilterEvent 650 * Signature: (JJ)Z 651 */ 652 JNIEXPORT jboolean JNICALL Java_sun_awt_X11_XlibWrapper_XFilterEvent 653 (JNIEnv *env, jclass clazz, jlong ptr, jlong window) 654 { 655 AWT_CHECK_HAVE_LOCK_RETURN(JNI_FALSE); 656 #if defined(AIX) 657 if (True == statusWindowEventHandler(*((XEvent *)(uintptr_t)ptr))) { 658 return (jboolean)True; 659 } 660 #endif 661 return (jboolean) XFilterEvent((XEvent *) jlong_to_ptr(ptr), (Window) window); 662 } 663 664 /* 665 * Class: sun_awt_X11_XlibWrapper 666 * Method: XSupportsLocale 667 * Signature: ()Z 668 */ 669 JNIEXPORT jboolean JNICALL Java_sun_awt_X11_XlibWrapper_XSupportsLocale 670 (JNIEnv *env, jclass clazz) 671 { 672 AWT_CHECK_HAVE_LOCK_RETURN(JNI_FALSE); 673 return (jboolean)XSupportsLocale(); 674 } 675 676 /* 677 * Class: sun_awt_X11_XlibWrapper 678 * Method: XSetLocaleModifiers 679 * Signature: (Ljava/lang/String;)Ljava/lang/String; 680 */ 681 JNIEXPORT jstring JNICALL Java_sun_awt_X11_XlibWrapper_XSetLocaleModifiers 682 (JNIEnv *env, jclass clazz, jstring jstr) 683 { 684 char * modifier_list = NULL; 685 char * ret = NULL; 686 687 if (!JNU_IsNull(env, jstr)) { 688 modifier_list = (char *)JNU_GetStringPlatformChars(env, jstr, NULL); 689 CHECK_NULL_RETURN(modifier_list, NULL); 690 } 691 692 AWT_CHECK_HAVE_LOCK_RETURN(NULL); 693 if (modifier_list) { 694 ret = XSetLocaleModifiers(modifier_list); 695 JNU_ReleaseStringPlatformChars(env, jstr, (const char *) modifier_list); 696 } else { 697 ret = XSetLocaleModifiers(""); 698 } 699 700 return (ret != NULL ? JNU_NewStringPlatform(env, ret): NULL); 701 } 702 703 704 /* 705 * Class: sun_awt_X11_wrappers_XlibWrapper 706 * Method: XPeekEvent 707 * Signature: (JJ)V 708 */ 709 710 711 JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XPeekEvent 712 (JNIEnv *env, jclass clazz, jlong display, jlong ptr) 713 { 714 AWT_CHECK_HAVE_LOCK(); 715 XPeekEvent((Display *) jlong_to_ptr(display),jlong_to_ptr(ptr)); 716 } 717 718 /* 719 * Class: sun_awt_X11_XlibWrapper 720 * Method: XMoveResizeWindow 721 * Signature: (JJIIII)V 722 */ 723 JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XMoveResizeWindow 724 (JNIEnv *env, jclass clazz, jlong display, jlong window, jint x , jint y , jint width, jint height) { 725 AWT_CHECK_HAVE_LOCK(); 726 XMoveResizeWindow( (Display *) jlong_to_ptr(display), (Window) window, x, y, width, height); 727 } 728 729 /* 730 * Class: sun_awt_X11_XlibWrapper 731 * Method: XResizeWindow 732 * Signature: (JJII)V 733 */ 734 JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XResizeWindow 735 (JNIEnv *env, jclass clazz, jlong display, jlong window, jint width, jint height) { 736 AWT_CHECK_HAVE_LOCK(); 737 XResizeWindow( (Display *) jlong_to_ptr(display),(Window) window,width,height); 738 } 739 740 /* 741 * Class: sun_awt_X11_XlibWrapper 742 * Method: XMoveWindow 743 * Signature: (JJII)V 744 */ 745 JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XMoveWindow 746 (JNIEnv *env, jclass clazz, jlong display, jlong window, jint width, jint height) { 747 AWT_CHECK_HAVE_LOCK(); 748 XMoveWindow( (Display *) jlong_to_ptr(display),(Window) window,width,height); 749 } 750 751 752 /* 753 * Class: sun_awt_X11_XlibWrapper 754 * Method: XSetWindowBackground 755 * Signature: (JJJ)V 756 */ 757 JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XSetWindowBackground 758 (JNIEnv *env, jclass clazz, jlong display, jlong window, jlong background_pixel) { 759 AWT_CHECK_HAVE_LOCK(); 760 XSetWindowBackground((Display *) jlong_to_ptr(display),window,background_pixel); 761 } 762 763 764 /* 765 * Class: sun_awt_X11_XlibWrapper 766 * Method: XFlush 767 * Signature: (J)V 768 */ 769 JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XFlush 770 (JNIEnv *env, jclass clazz, jlong display) { 771 772 AWT_CHECK_HAVE_LOCK(); 773 XFlush((Display *)jlong_to_ptr(display)); 774 } 775 776 /* 777 * Class: sun_awt_X11_XlibWrapper 778 * Method: XSync 779 * Signature: (JI)V 780 */ 781 JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XSync 782 (JNIEnv *env, jclass clazz, jlong display, jint discard) { 783 AWT_CHECK_HAVE_LOCK(); 784 XSync((Display *) jlong_to_ptr(display), discard); 785 } 786 787 JNIEXPORT jint JNICALL Java_sun_awt_X11_XlibWrapper_XTranslateCoordinates 788 (JNIEnv *env, jclass clazz, jlong display, jlong src_w, jlong dest_w, 789 jlong src_x, jlong src_y, jlong dest_x_return, jlong dest_y_return, 790 jlong child_return) 791 { 792 AWT_CHECK_HAVE_LOCK_RETURN(0); 793 return XTranslateCoordinates( (Display *) jlong_to_ptr(display), src_w, dest_w, 794 src_x, src_y, 795 (int *) jlong_to_ptr(dest_x_return), 796 (int *) jlong_to_ptr(dest_y_return), 797 (Window *) jlong_to_ptr(child_return)); 798 } 799 800 JNIEXPORT jint JNICALL Java_sun_awt_X11_XlibWrapper_XEventsQueued 801 (JNIEnv *env, jclass clazz, jlong display, jint mode) { 802 803 AWT_CHECK_HAVE_LOCK_RETURN(0); 804 return XEventsQueued((Display *) jlong_to_ptr(display), mode); 805 806 } 807 808 /* 809 * Class: sun_awt_X11_XlibWrapper 810 * Method: SetProperty 811 * Signature: (JJJLjava/lang/String;)V 812 */ 813 JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_SetProperty 814 (JNIEnv *env, jclass clazz, jlong display, jlong window, jlong atom, jstring jstr) { 815 char *cname; 816 XTextProperty tp; 817 int32_t status; 818 819 /* 820 In case there are direct support of UTF-8 declared, use UTF-8 strings. 821 */ 822 if (!JNU_IsNull(env, jstr)) { 823 #ifdef X_HAVE_UTF8_STRING 824 cname = (char *) (*env)->GetStringUTFChars(env, jstr, JNI_FALSE); 825 #else 826 cname = (char *) JNU_GetStringPlatformChars(env, jstr, NULL); 827 #endif 828 CHECK_NULL(cname); 829 } else { 830 cname = ""; 831 } 832 833 AWT_CHECK_HAVE_LOCK(); 834 835 #ifdef X_HAVE_UTF8_STRING 836 status = Xutf8TextListToTextProperty((Display *)jlong_to_ptr(display), &cname, 1, 837 XStdICCTextStyle, &tp); 838 #else 839 status = XmbTextListToTextProperty((Display *)jlong_to_ptr(display), &cname, 1, 840 XStdICCTextStyle, &tp); 841 #endif 842 843 if (status == Success || status > 0) { 844 XChangeProperty((Display *)jlong_to_ptr(display), window, atom, tp.encoding, tp.format, PropModeReplace, tp.value, tp.nitems); 845 if (tp.value != NULL) { 846 XFree(tp.value); 847 } 848 } 849 850 if (!JNU_IsNull(env, jstr)) { 851 #ifdef X_HAVE_UTF8_STRING 852 (*env)->ReleaseStringUTFChars(env, jstr, (const char *) cname); 853 #else 854 JNU_ReleaseStringPlatformChars(env, jstr, (const char *) cname); 855 #endif 856 } 857 } 858 859 /* 860 * Class: sun_awt_X11_XlibWrapper 861 * Method: XChangeProperty 862 * Signature: (JJJJJJJJJJJ)V 863 */ 864 JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XChangePropertyImpl( 865 JNIEnv *env, jclass clazz, jlong display, jlong window, jlong property, 866 jlong type, jint format, jint mode, jlong data, jint nelements) 867 { 868 AWT_CHECK_HAVE_LOCK(); 869 XChangeProperty((Display*) jlong_to_ptr(display), (Window) window, (Atom) property, 870 (Atom) type, format, mode, (unsigned char*) jlong_to_ptr(data), 871 nelements); 872 } 873 /* 874 * Class: sun_awt_X11_XlibWrapper 875 * Method: XChangePropertyS 876 * Signature: (JJJJJJJJJLjava/lang/String;)V 877 */ 878 JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XChangePropertyS( 879 JNIEnv *env, jclass clazz, jlong display, jlong window, jlong property, 880 jlong type, jint format, jint mode, jstring value) 881 { 882 jboolean iscopy; 883 AWT_CHECK_HAVE_LOCK(); 884 const char * chars = JNU_GetStringPlatformChars(env, value, &iscopy); 885 CHECK_NULL(chars); 886 XChangeProperty((Display*)jlong_to_ptr(display), window, (Atom)property, 887 (Atom)type, format, mode, (unsigned char*)chars, strlen(chars)); 888 if (iscopy) { 889 JNU_ReleaseStringPlatformChars(env, value, chars); 890 } 891 } 892 893 /* 894 * Class: sun_awt_X11_XlibWrapper 895 * Method: XGetWindowProperty 896 * Signature: (JJJJJJJJJJJ)J; 897 */ 898 JNIEXPORT jint JNICALL Java_sun_awt_X11_XlibWrapper_XGetWindowProperty 899 (JNIEnv *env, jclass clazz, jlong display, jlong window, jlong property, jlong long_offset, 900 jlong long_length, jlong delete, jlong req_type, jlong actual_type, 901 jlong actual_format, jlong nitems_ptr, jlong bytes_after, jlong data_ptr) 902 { 903 AWT_CHECK_HAVE_LOCK_RETURN(0); 904 return XGetWindowProperty((Display*) jlong_to_ptr(display), window, property, long_offset, long_length, 905 delete, (Atom) req_type, (Atom*) jlong_to_ptr(actual_type), 906 (int *) jlong_to_ptr(actual_format), (unsigned long *) jlong_to_ptr(nitems_ptr), 907 (unsigned long*) jlong_to_ptr(bytes_after), (unsigned char**) jlong_to_ptr(data_ptr)); 908 } 909 910 /* 911 * Class: sun_awt_X11_XlibWrapper 912 * Method: GetProperty 913 * Signature: (JJJ)Ljava/lang/String; 914 */ 915 JNIEXPORT jstring JNICALL Java_sun_awt_X11_XlibWrapper_GetProperty 916 (JNIEnv *env, jclass clazz, jlong display, jlong window, jlong atom) 917 { 918 /* Request status */ 919 int status; 920 921 /* Returns of XGetWindowProperty */ 922 Atom actual_type; 923 int actual_format; 924 unsigned long nitems; 925 unsigned long bytes_after; 926 unsigned char * string; 927 jstring res = NULL; 928 AWT_CHECK_HAVE_LOCK_RETURN(NULL); 929 status = XGetWindowProperty((Display*)jlong_to_ptr(display), window, 930 atom, 0, 0xFFFF, False, XA_STRING, 931 &actual_type, &actual_format, &nitems, &bytes_after, 932 &string); 933 934 if (status != Success || string == NULL) { 935 return NULL; 936 } 937 938 if (actual_type == XA_STRING && actual_format == 8) { 939 res = JNU_NewStringPlatform(env,(char*) string); 940 } 941 XFree(string); 942 return res; 943 } 944 945 /* 946 * Class: sun_awt_X11_XlibWrapper 947 * Method: InternAtom 948 * Signature: (JLjava/lang/String;I)J 949 */ 950 JNIEXPORT jlong JNICALL Java_sun_awt_X11_XlibWrapper_InternAtom 951 (JNIEnv *env, jclass clazz, jlong display, jstring jstr, jint ife) { 952 953 char *cname; 954 unsigned long atom; 955 956 AWT_CHECK_HAVE_LOCK_RETURN(0); 957 958 if (!JNU_IsNull(env, jstr)) { 959 cname = (char *)JNU_GetStringPlatformChars(env, jstr, NULL); 960 CHECK_NULL_RETURN(cname, 0); 961 } else { 962 cname = ""; 963 } 964 965 atom = XInternAtom((Display *) jlong_to_ptr(display), cname, ife); 966 967 if (!JNU_IsNull(env, jstr)) { 968 JNU_ReleaseStringPlatformChars(env, jstr, (const char *) cname); 969 } 970 971 return (jlong) atom; 972 973 } 974 975 JNIEXPORT jint JNICALL Java_sun_awt_X11_XlibWrapper_XCreateFontCursor 976 (JNIEnv *env, jclass clazz, jlong display, jint shape) { 977 AWT_CHECK_HAVE_LOCK_RETURN(0); 978 return XCreateFontCursor((Display *) jlong_to_ptr(display), (int) shape); 979 } 980 981 /* 982 * Class: sun_awt_X11_XlibWrapper 983 * Method: XCreatePixmapCursor 984 * Signature: (JJJJJII)J 985 */ 986 JNIEXPORT jlong JNICALL Java_sun_awt_X11_XlibWrapper_XCreatePixmapCursor 987 (JNIEnv *env , jclass clazz, jlong display, jlong source, jlong mask, jlong fore, jlong back, jint x , jint y) { 988 989 AWT_CHECK_HAVE_LOCK_RETURN(0); 990 return (jlong) XCreatePixmapCursor((Display *) jlong_to_ptr(display), (Pixmap) source, (Pixmap) mask, 991 (XColor *) jlong_to_ptr(fore), (XColor *) jlong_to_ptr(back), x, y); 992 } 993 994 /* 995 * Class: sun_awt_X11_XlibWrapper 996 * Method: XQueryBestCursor 997 * Signature: (JJIIJJ)Z 998 */ 999 JNIEXPORT jboolean JNICALL Java_sun_awt_X11_XlibWrapper_XQueryBestCursor 1000 (JNIEnv *env, jclass clazz, jlong display, jlong drawable, jint width, jint height, jlong width_return, jlong height_return) { 1001 1002 Status status; 1003 1004 AWT_CHECK_HAVE_LOCK_RETURN(JNI_FALSE); 1005 status = XQueryBestCursor((Display *) jlong_to_ptr(display), (Drawable) drawable, width,height, 1006 (unsigned int *) jlong_to_ptr(width_return), (unsigned int *) jlong_to_ptr(height_return)); 1007 1008 if (status == 0) return JNI_FALSE; 1009 else return JNI_TRUE; 1010 } 1011 1012 /* 1013 * Class: sun_awt_X11_XlibWrapper 1014 * Method: XFreeCursor 1015 * Signature: (JJ)V 1016 */ 1017 JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XFreeCursor 1018 (JNIEnv *env, jclass clazz, jlong display, jlong cursor) { 1019 1020 AWT_CHECK_HAVE_LOCK(); 1021 XFreeCursor( (Display *) jlong_to_ptr(display), (Cursor) cursor); 1022 } 1023 1024 /* 1025 * Class: sun_awt_X11_XlibWrapper 1026 * Method: XQueryPointer 1027 * Signature: (JJJJJJJJJ)Z 1028 */ 1029 JNIEXPORT jboolean JNICALL Java_sun_awt_X11_XlibWrapper_XQueryPointer 1030 (JNIEnv *env, jclass clazz, jlong display, jlong w, jlong root_return, jlong child_return, jlong root_x_return , jlong root_y_return, jlong win_x_return, jlong win_y_return, jlong mask_return) { 1031 1032 Bool b; 1033 1034 AWT_CHECK_HAVE_LOCK_RETURN(JNI_FALSE); 1035 b = XQueryPointer((Display *) jlong_to_ptr(display), 1036 (Window) w, (Window *) jlong_to_ptr(root_return), (Window *) jlong_to_ptr(child_return), 1037 (int *) jlong_to_ptr(root_x_return), (int *) jlong_to_ptr(root_y_return), 1038 (int *) jlong_to_ptr(win_x_return), (int *) jlong_to_ptr(win_y_return), 1039 (unsigned int *) jlong_to_ptr(mask_return)); 1040 1041 return b ? JNI_TRUE : JNI_FALSE; 1042 } 1043 1044 /* 1045 * Class: sun_awt_X11_XlibWrapper 1046 * Method: XChangeWindowAttributes 1047 * Signature: (JJJJ)V 1048 */ 1049 JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XChangeWindowAttributes 1050 (JNIEnv *env, jclass clazz, jlong display, jlong window, jlong valuemask, jlong attributes) { 1051 1052 AWT_CHECK_HAVE_LOCK(); 1053 XChangeWindowAttributes((Display *) jlong_to_ptr(display), (Window) window, (unsigned long) valuemask, 1054 (XSetWindowAttributes *) jlong_to_ptr(attributes)); 1055 } 1056 1057 /* 1058 * Class: sun_awt_X11_XlibWrapper 1059 * Method: XSetTransientFor 1060 * Signature: (JJJ)V 1061 */ 1062 JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XSetTransientFor 1063 (JNIEnv *env, jclass clazz, jlong display, jlong window, jlong transient_for_window) 1064 { 1065 AWT_CHECK_HAVE_LOCK(); 1066 XSetTransientForHint((Display *) jlong_to_ptr(display), window, transient_for_window); 1067 } 1068 1069 /* 1070 * Class: sun_awt_X11_XlibWrapper 1071 * Method: XSetWMHints 1072 * Signature: (JJJ)V 1073 */ 1074 JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XSetWMHints 1075 (JNIEnv *env, jclass clazz, jlong display, jlong window, jlong hints) 1076 { 1077 AWT_CHECK_HAVE_LOCK(); 1078 XSetWMHints((Display *) jlong_to_ptr(display), window, (XWMHints *) jlong_to_ptr(hints)); 1079 } 1080 1081 /* 1082 * Class: sun_awt_X11_XlibWrapper 1083 * Method: XGetWMHints 1084 * Signature: (JJJ)V 1085 */ 1086 JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XGetWMHints 1087 (JNIEnv *env, jclass clazz, jlong display, jlong window, jlong hints) 1088 { 1089 XWMHints * get_hints; 1090 AWT_CHECK_HAVE_LOCK(); 1091 get_hints = XGetWMHints((Display*)jlong_to_ptr(display), window); 1092 if (get_hints != NULL) { 1093 memcpy(jlong_to_ptr(hints), get_hints, sizeof(XWMHints)); 1094 XFree(get_hints); 1095 } else { 1096 memset(jlong_to_ptr(hints), 0, sizeof(XWMHints)); 1097 } 1098 } 1099 1100 /* 1101 * Class: sun_awt_X11_XlibWrapper 1102 * Method: XGetPointerMapping 1103 * Signature: (JJI)I 1104 */ 1105 JNIEXPORT jint JNICALL Java_sun_awt_X11_XlibWrapper_XGetPointerMapping 1106 (JNIEnv *env, jclass clazz, jlong display, jlong map, jint buttonNumber) 1107 { 1108 AWT_CHECK_HAVE_LOCK_RETURN(0); 1109 return XGetPointerMapping((Display*)jlong_to_ptr(display), (unsigned char*) jlong_to_ptr(map), buttonNumber); 1110 } 1111 1112 /* 1113 * Class: sun_awt_X11_XlibWrapper 1114 * Method: XGetDefault 1115 * Signature: (JJI)I 1116 */ 1117 JNIEXPORT jstring JNICALL Java_sun_awt_X11_XlibWrapper_XGetDefault 1118 (JNIEnv *env, jclass clazz, jlong display, jstring program, jstring option) 1119 { 1120 char * c_program = NULL; 1121 char * c_option = NULL; 1122 char * c_res = NULL; 1123 1124 if (!JNU_IsNull(env, program)) { 1125 c_program = (char *)JNU_GetStringPlatformChars(env, program, NULL); 1126 } 1127 CHECK_NULL_RETURN(c_program, NULL); 1128 1129 if (!JNU_IsNull(env, option)) { 1130 c_option = (char *)JNU_GetStringPlatformChars(env, option, NULL); 1131 } 1132 1133 if (c_option == NULL) { 1134 JNU_ReleaseStringPlatformChars(env, program, (const char *) c_program); 1135 return NULL; 1136 } 1137 1138 AWT_CHECK_HAVE_LOCK_RETURN(NULL); 1139 c_res = XGetDefault((Display*)jlong_to_ptr(display), c_program, c_option); 1140 // The strings returned by XGetDefault() are owned by Xlib and 1141 // should not be modified or freed by the client. 1142 1143 JNU_ReleaseStringPlatformChars(env, program, (const char *) c_program); 1144 JNU_ReleaseStringPlatformChars(env, option, (const char *) c_option); 1145 1146 if (c_res != NULL) { 1147 return JNU_NewStringPlatform(env, c_res); 1148 } else { 1149 return NULL; 1150 } 1151 } 1152 1153 /* 1154 * Class: sun_awt_X11_XlibWrapper 1155 * Method: getScreenOfWindow 1156 * Signature: (JJ)J 1157 */ 1158 JNIEXPORT jlong JNICALL Java_sun_awt_X11_XlibWrapper_getScreenOfWindow 1159 (JNIEnv *env, jclass clazz, jlong display, jlong window) 1160 { 1161 XWindowAttributes attrs; 1162 memset(&attrs, 0, sizeof(attrs)); 1163 AWT_CHECK_HAVE_LOCK_RETURN(0); 1164 XGetWindowAttributes((Display *) jlong_to_ptr(display), window, &attrs); 1165 return ptr_to_jlong(attrs.screen); 1166 } 1167 1168 /* 1169 * Class: sun_awt_X11_XlibWrapper 1170 * Method: XScreenNumberOfScreen 1171 * Signature: (J)J 1172 */ 1173 JNIEXPORT jlong JNICALL Java_sun_awt_X11_XlibWrapper_XScreenNumberOfScreen 1174 (JNIEnv *env, jclass clazz, jlong screen) 1175 { 1176 AWT_CHECK_HAVE_LOCK_RETURN(-1); 1177 if(jlong_to_ptr(screen) == NULL) { 1178 return -1; 1179 } 1180 return XScreenNumberOfScreen((Screen*) jlong_to_ptr(screen)); 1181 } 1182 1183 /* 1184 * Class: sun_awt_X11_XlibWrapper 1185 * Method: XIconifyWindow 1186 * Signature: (JJJ)V 1187 */ 1188 JNIEXPORT jint JNICALL Java_sun_awt_X11_XlibWrapper_XIconifyWindow 1189 (JNIEnv *env, jclass clazz, jlong display, jlong window, jlong screenNumber) 1190 { 1191 AWT_CHECK_HAVE_LOCK_RETURN(0); 1192 return XIconifyWindow((Display*) jlong_to_ptr(display), window, screenNumber); 1193 } 1194 1195 /* 1196 * Class: sun_awt_X11_XlibWrapper 1197 * Method: XFree 1198 * Signature: (J)V 1199 */ 1200 JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XFree 1201 (JNIEnv *env, jclass clazz, jlong ptr) 1202 { 1203 AWT_CHECK_HAVE_LOCK(); 1204 XFree(jlong_to_ptr(ptr)); 1205 } 1206 1207 /* 1208 * Class: sun_awt_X11_XlibWrapper 1209 * Method: XFree 1210 * Signature: (J)V 1211 */ 1212 JNIEXPORT jbyteArray JNICALL Java_sun_awt_X11_XlibWrapper_getStringBytes 1213 (JNIEnv *env, jclass clazz, jlong str_ptr) 1214 { 1215 unsigned char * str = (unsigned char*) jlong_to_ptr(str_ptr); 1216 long length = strlen((char*)str); 1217 jbyteArray res = (*env)->NewByteArray(env, length); 1218 CHECK_NULL_RETURN(res, NULL); 1219 (*env)->SetByteArrayRegion(env, res, 0, length, 1220 (const signed char*) str); 1221 return res; 1222 } 1223 1224 /* 1225 * Class: sun_awt_X11_XlibWrapper 1226 * Method: ServerVendor 1227 * Signature: (J)Ljava/lang/String; 1228 */ 1229 JNIEXPORT jstring JNICALL Java_sun_awt_X11_XlibWrapper_ServerVendor 1230 (JNIEnv *env, jclass clazz, jlong display) 1231 { 1232 AWT_CHECK_HAVE_LOCK_RETURN(NULL); 1233 return JNU_NewStringPlatform(env, ServerVendor((Display*)jlong_to_ptr(display))); 1234 } 1235 1236 /* 1237 * Class: sun_awt_X11_XlibWrapper 1238 * Method: VendorRelease 1239 * Signature: (J)I; 1240 */ 1241 JNIEXPORT jint JNICALL Java_sun_awt_X11_XlibWrapper_VendorRelease 1242 (JNIEnv *env, jclass clazz, jlong display) 1243 { 1244 AWT_CHECK_HAVE_LOCK_RETURN(0); 1245 return VendorRelease((Display*)jlong_to_ptr(display)); 1246 } 1247 1248 /* 1249 * Class: sun_awt_X11_XlibWrapper 1250 * Method: IsXsunKPBehavior 1251 * Signature: (J)Z; 1252 */ 1253 JNIEXPORT jboolean JNICALL Java_sun_awt_X11_XlibWrapper_IsXsunKPBehavior 1254 (JNIEnv *env, jclass clazz, jlong display) 1255 { 1256 // Xsun without XKB uses keysymarray[2] keysym to determine if it is KP event. 1257 // Otherwise, it is [1] or sometimes [0]. 1258 // This sniffer first tries to determine what is a keycode for XK_KP_7 1259 // using XKeysymToKeycode; 1260 // second, in which place in the keysymarray is XK_KP_7 1261 // using XKeycodeToKeysym. 1262 int kc7; 1263 AWT_CHECK_HAVE_LOCK_RETURN(JNI_FALSE); 1264 kc7 = XKeysymToKeycode((Display*)jlong_to_ptr(display), XK_KP_7); 1265 if( !kc7 ) { 1266 // keycode is not defined. Why, it's a reduced keyboard perhaps: 1267 // report arbitrarily false. 1268 return JNI_FALSE; 1269 } else { 1270 long ks2 = keycodeToKeysym((Display*)jlong_to_ptr(display), kc7, 2); 1271 if( ks2 == XK_KP_7 ) { 1272 //XXX If some Xorg server would put XK_KP_7 in keysymarray[2] as well, 1273 //XXX for yet unknown to me reason, the sniffer would lie. 1274 return JNI_TRUE; 1275 }else{ 1276 return JNI_FALSE; 1277 } 1278 } 1279 } 1280 1281 JNIEXPORT jboolean JNICALL Java_sun_awt_X11_XlibWrapper_IsSunKeyboard 1282 (JNIEnv *env, jclass clazz, jlong display) 1283 { 1284 int xx; 1285 AWT_CHECK_HAVE_LOCK_RETURN(JNI_FALSE); 1286 xx = XKeysymToKeycode((Display*)jlong_to_ptr(display), SunXK_F37); 1287 return (!xx) ? JNI_FALSE : JNI_TRUE; 1288 } 1289 1290 JNIEXPORT jboolean JNICALL Java_sun_awt_X11_XlibWrapper_IsKanaKeyboard 1291 (JNIEnv *env, jclass clazz, jlong display) 1292 { 1293 int xx; 1294 static jboolean result = JNI_FALSE; 1295 1296 int32_t minKeyCode, maxKeyCode, keySymsPerKeyCode; 1297 KeySym *keySyms, *keySymsStart, keySym; 1298 int32_t i; 1299 int32_t kanaCount = 0; 1300 1301 AWT_CHECK_HAVE_LOCK_RETURN(JNI_FALSE); 1302 1303 // There's no direct way to determine whether the keyboard has 1304 // a kana lock key. From available keyboard mapping tables, it looks 1305 // like only keyboards with the kana lock key can produce keysyms 1306 // for kana characters. So, as an indirect test, we check for those. 1307 XDisplayKeycodes((Display*)jlong_to_ptr(display), &minKeyCode, &maxKeyCode); 1308 keySyms = XGetKeyboardMapping((Display*)jlong_to_ptr(display), minKeyCode, maxKeyCode - minKeyCode + 1, &keySymsPerKeyCode); 1309 keySymsStart = keySyms; 1310 for (i = 0; i < (maxKeyCode - minKeyCode + 1) * keySymsPerKeyCode; i++) { 1311 keySym = *keySyms++; 1312 if ((keySym & 0xff00) == 0x0400) { 1313 kanaCount++; 1314 } 1315 } 1316 XFree(keySymsStart); 1317 1318 // use a (somewhat arbitrary) minimum so we don't get confused by a stray function key 1319 result = kanaCount > 10; 1320 return result ? JNI_TRUE : JNI_FALSE; 1321 } 1322 1323 JavaVM* jvm = NULL; 1324 static int ToolkitErrorHandler(Display * dpy, XErrorEvent * event) { 1325 JNIEnv * env; 1326 // First call the native synthetic error handler declared in "awt_util.h" file. 1327 if (current_native_xerror_handler != NULL) { 1328 current_native_xerror_handler(dpy, event); 1329 } 1330 if (jvm != NULL) { 1331 env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2); 1332 if (env) { 1333 return JNU_CallStaticMethodByName(env, NULL, "sun/awt/X11/XErrorHandlerUtil", 1334 "globalErrorHandler", "(JJ)I", ptr_to_jlong(dpy), ptr_to_jlong(event)).i; 1335 } 1336 } 1337 return 0; 1338 } 1339 1340 /* 1341 * Class: sun_awt_X11_XlibWrapper 1342 * Method: SetToolkitErrorHandler 1343 * Signature: ()J 1344 */ 1345 JNIEXPORT jlong JNICALL Java_sun_awt_X11_XlibWrapper_SetToolkitErrorHandler 1346 (JNIEnv *env, jclass clazz) 1347 { 1348 if ((*env)->GetJavaVM(env, &jvm) < 0) { 1349 return 0; 1350 } 1351 AWT_CHECK_HAVE_LOCK_RETURN(0); 1352 return ptr_to_jlong(XSetErrorHandler(ToolkitErrorHandler)); 1353 } 1354 1355 /* 1356 * Class: sun_awt_X11_XlibWrapper 1357 * Method: XSetErrorHandler 1358 * Signature: (J)V 1359 */ 1360 JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XSetErrorHandler 1361 (JNIEnv *env, jclass clazz, jlong handler) 1362 { 1363 AWT_CHECK_HAVE_LOCK(); 1364 XSetErrorHandler((XErrorHandler) jlong_to_ptr(handler)); 1365 } 1366 1367 /* 1368 * Class: sun_awt_X11_XlibWrapper 1369 * Method: CallErrorHandler 1370 * Signature: (JJJ)I 1371 */ 1372 JNIEXPORT jint JNICALL Java_sun_awt_X11_XlibWrapper_CallErrorHandler 1373 (JNIEnv *env, jclass clazz, jlong handler, jlong display, jlong event_ptr) 1374 { 1375 return (*(XErrorHandler)jlong_to_ptr(handler))((Display*) jlong_to_ptr(display), (XErrorEvent*) jlong_to_ptr(event_ptr)); 1376 } 1377 1378 /* 1379 * Class: sun_awt_X11_XlibWrapper 1380 * Method: PrintXErrorEvent 1381 * Signature: (JJ)V 1382 */ 1383 JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_PrintXErrorEvent 1384 (JNIEnv *env, jclass clazz, jlong display, jlong event_ptr) 1385 { 1386 char msg[128]; 1387 char buf[128]; 1388 1389 XErrorEvent* err = (XErrorEvent *)jlong_to_ptr(event_ptr); 1390 1391 XGetErrorText((Display *)jlong_to_ptr(display), err->error_code, msg, sizeof(msg)); 1392 jio_fprintf(stderr, "Xerror %s, XID %x, ser# %d\n", msg, err->resourceid, err->serial); 1393 jio_snprintf(buf, sizeof(buf), "%d", err->request_code); 1394 XGetErrorDatabaseText((Display *)jlong_to_ptr(display), "XRequest", buf, "Unknown", msg, sizeof(msg)); 1395 jio_fprintf(stderr, "Major opcode %d (%s)\n", err->request_code, msg); 1396 if (err->request_code > 128) { 1397 jio_fprintf(stderr, "Minor opcode %d\n", err->minor_code); 1398 } 1399 } 1400 1401 /* 1402 * Class: sun_awt_X11_XlibWrapper 1403 * Method: XInternAtoms 1404 * Signature: (J[Ljava/lang/String;ZJ)I 1405 */ 1406 JNIEXPORT jint JNICALL Java_sun_awt_X11_XlibWrapper_XInternAtoms 1407 (JNIEnv *env, jclass clazz, jlong display, jobjectArray names_arr, jboolean only_if_exists, jlong atoms) 1408 { 1409 int status = 0; 1410 AWT_CHECK_HAVE_LOCK_RETURN(0); 1411 jsize length; 1412 char** names = stringArrayToNative(env, names_arr, &length); 1413 if (names) { 1414 status = XInternAtoms((Display*)jlong_to_ptr(display), names, length, only_if_exists, (Atom*) jlong_to_ptr(atoms)); 1415 freeNativeStringArray(names, length); 1416 } 1417 return status; 1418 } 1419 1420 /* 1421 * Class: sun_awt_X11_XlibWrapper 1422 * Method: XGetWindowAttributes 1423 * Signature: (JJJ)I 1424 */ 1425 JNIEXPORT jint JNICALL Java_sun_awt_X11_XlibWrapper_XGetWindowAttributes 1426 (JNIEnv *env, jclass clazz, jlong display, jlong window, jlong attr_ptr) 1427 { 1428 jint status; 1429 AWT_CHECK_HAVE_LOCK_RETURN(0); 1430 memset((XWindowAttributes*) jlong_to_ptr(attr_ptr), 0, sizeof(XWindowAttributes)); 1431 status = XGetWindowAttributes((Display*)jlong_to_ptr(display), window, (XWindowAttributes*) jlong_to_ptr(attr_ptr)); 1432 return status; 1433 } 1434 1435 /* 1436 * Class: sun_awt_X11_XlibWrapper 1437 * Method: XGetGeometry 1438 * Signature: (JJJJJJJJJ)I 1439 */ 1440 JNIEXPORT jint JNICALL Java_sun_awt_X11_XlibWrapper_XGetGeometry 1441 (JNIEnv *env, jclass clazz, jlong display, jlong drawable, jlong root_return, 1442 jlong x_return, jlong y_return, jlong width_return, jlong height_return, 1443 jlong border_width_return, jlong depth_return) 1444 { 1445 jint status; 1446 AWT_CHECK_HAVE_LOCK_RETURN(0); 1447 status = XGetGeometry((Display *)jlong_to_ptr(display), 1448 (Drawable)drawable, (Window *)jlong_to_ptr(root_return), 1449 (int *)jlong_to_ptr(x_return), (int *)jlong_to_ptr(y_return), 1450 (unsigned int *)jlong_to_ptr(width_return), (unsigned int *)jlong_to_ptr(height_return), 1451 (unsigned int *)jlong_to_ptr(border_width_return), 1452 (unsigned int *)jlong_to_ptr(depth_return)); 1453 return status; 1454 } 1455 1456 /* 1457 * Class: sun_awt_X11_XlibWrapper 1458 * Method: XGetWMNormalHints 1459 * Signature: (JJJJ)I 1460 */ 1461 JNIEXPORT jint JNICALL Java_sun_awt_X11_XlibWrapper_XGetWMNormalHints 1462 (JNIEnv *env, jclass clazz, jlong display, jlong window, jlong hints, jlong supplied_return) 1463 { 1464 AWT_CHECK_HAVE_LOCK_RETURN(0); 1465 return XGetWMNormalHints((Display*) jlong_to_ptr(display), 1466 window, 1467 (XSizeHints*) jlong_to_ptr(hints), 1468 (long*) jlong_to_ptr(supplied_return)); 1469 } 1470 1471 /* 1472 * Class: sun_awt_X11_XlibWrapper 1473 * Method: XSetWMNormalHints 1474 * Signature: (JJJ)V 1475 */ 1476 JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XSetWMNormalHints 1477 (JNIEnv *env, jclass clazz, jlong display, jlong window, jlong hints) 1478 { 1479 AWT_CHECK_HAVE_LOCK(); 1480 XSetWMNormalHints((Display*) jlong_to_ptr(display), window, (XSizeHints*) jlong_to_ptr(hints)); 1481 } 1482 1483 /* 1484 * Class: sun_awt_X11_XlibWrapper 1485 * Method: XDeleteProperty 1486 * Signature: (JJJ)V 1487 */ 1488 JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XDeleteProperty 1489 (JNIEnv *env, jclass clazz, jlong display, jlong window, jlong atom) 1490 { 1491 AWT_CHECK_HAVE_LOCK(); 1492 XDeleteProperty((Display*) jlong_to_ptr(display), window, (Atom)atom); 1493 } 1494 1495 /* 1496 * Class: sun_awt_X11_XlibWrapper 1497 * Method: XSendEvent 1498 * Signature: (JJZJJ)V 1499 */ 1500 JNIEXPORT jint JNICALL Java_sun_awt_X11_XlibWrapper_XSendEvent 1501 (JNIEnv *env, jclass clazz, jlong display, jlong window, jboolean propagate, jlong event_mask, jlong event) 1502 { 1503 AWT_CHECK_HAVE_LOCK_RETURN(0); 1504 return XSendEvent((Display*) jlong_to_ptr(display), 1505 window, 1506 propagate==JNI_TRUE?True:False, 1507 (long) event_mask, 1508 (XEvent*) jlong_to_ptr(event)); 1509 } 1510 1511 /* 1512 * Class: sun_awt_X11_XlibWrapper 1513 * Method: XQueryTree 1514 * Signature: (JJJJJJ)I 1515 */ 1516 JNIEXPORT jint JNICALL Java_sun_awt_X11_XlibWrapper_XQueryTree 1517 (JNIEnv *env, jclass clazz, jlong display, jlong window, jlong root_return, jlong parent_return, jlong children_return, jlong nchildren_return) 1518 { 1519 AWT_CHECK_HAVE_LOCK_RETURN(0); 1520 return XQueryTree((Display*) jlong_to_ptr(display), 1521 window, 1522 (Window *) jlong_to_ptr(root_return), 1523 (Window*) jlong_to_ptr(parent_return), 1524 (Window**) jlong_to_ptr(children_return), 1525 (unsigned int*) jlong_to_ptr(nchildren_return)); 1526 } 1527 1528 /* 1529 * Class: sun_awt_X11_XlibWrapper 1530 * Method: memcpy 1531 * Signature: (JJJ)V 1532 */ 1533 JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_memcpy 1534 (JNIEnv *env, jclass clazz, jlong dest_ptr, jlong src_ptr, jlong length) 1535 { 1536 memcpy(jlong_to_ptr(dest_ptr), jlong_to_ptr(src_ptr), length); 1537 } 1538 1539 JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XSetMinMaxHints 1540 (JNIEnv *env, jclass clazz, jlong display, jlong window, jint x, jint y, jint width, jint height, jlong flags) { 1541 XSizeHints * hints; 1542 AWT_CHECK_HAVE_LOCK(); 1543 hints = XAllocSizeHints(); 1544 hints->flags = flags; 1545 hints->width = width; 1546 hints->min_width = width; 1547 hints->max_width = width; 1548 hints->height = height; 1549 hints->min_height = height; 1550 hints->max_height = height; 1551 hints->x = x; 1552 hints->y = y; 1553 XSetWMNormalHints((Display*) jlong_to_ptr(display), window, hints); 1554 XFree(hints); 1555 } 1556 1557 JNIEXPORT jlong JNICALL Java_sun_awt_X11_XlibWrapper_XGetVisualInfo 1558 (JNIEnv *env, jclass clazz, jlong display, jlong vinfo_mask, jlong vinfo_template, 1559 jlong nitems_return) 1560 { 1561 AWT_CHECK_HAVE_LOCK_RETURN(0); 1562 return ptr_to_jlong(XGetVisualInfo((Display*) jlong_to_ptr(display), 1563 (long) vinfo_mask, 1564 (XVisualInfo*) jlong_to_ptr(vinfo_template), 1565 (int*) jlong_to_ptr(nitems_return))); 1566 } 1567 1568 JNIEXPORT jlong JNICALL Java_sun_awt_X11_XlibWrapper_XAllocSizeHints 1569 (JNIEnv *env, jclass clazz) 1570 { 1571 AWT_CHECK_HAVE_LOCK_RETURN(0); 1572 return ptr_to_jlong(XAllocSizeHints()); 1573 } 1574 1575 /* 1576 * Class: sun_awt_X11_XlibWrapper 1577 * Method: XIconifyWindow 1578 * Signature: (JJJ)V 1579 */ 1580 JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XBell 1581 (JNIEnv *env, jclass clazz, jlong display, jint percent) 1582 { 1583 AWT_CHECK_HAVE_LOCK(); 1584 XBell((Display*)jlong_to_ptr(display), percent); 1585 } 1586 1587 /* 1588 * Class: sun_awt_X11_XlibWrapper 1589 * Method: XAllocColor 1590 * Signature: (JJJ)Z 1591 */ 1592 JNIEXPORT jboolean JNICALL Java_sun_awt_X11_XlibWrapper_XAllocColor 1593 (JNIEnv *env, jclass clazz, jlong display , jlong colormap, jlong xcolor) { 1594 1595 Status status; 1596 AWT_CHECK_HAVE_LOCK_RETURN(JNI_FALSE); 1597 status = XAllocColor((Display *) jlong_to_ptr(display), (Colormap) colormap, (XColor *) jlong_to_ptr(xcolor)); 1598 1599 if (status == 0) return JNI_FALSE; 1600 else return JNI_TRUE; 1601 } 1602 1603 /* 1604 * Class: sun_awt_X11_XlibWrapper 1605 * Method: XCreateBitmapFromData 1606 * Signature: (JJJII)J 1607 */ 1608 JNIEXPORT jlong JNICALL Java_sun_awt_X11_XlibWrapper_XCreateBitmapFromData 1609 (JNIEnv *env, jclass clazz, jlong display, jlong drawable, jlong data, jint width, jint height) { 1610 AWT_CHECK_HAVE_LOCK_RETURN(0); 1611 1612 return (jlong) XCreateBitmapFromData((Display *) jlong_to_ptr(display), (Drawable) drawable, 1613 (char *) jlong_to_ptr(data), width, height); 1614 } 1615 1616 /* 1617 * Class: sun_awt_X11_XlibWrapper 1618 * Method: XFreePixmap 1619 * Signature: (JJ)V 1620 */ 1621 JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XFreePixmap 1622 (JNIEnv *env, jclass clazz, jlong display, jlong pixmap) { 1623 AWT_CHECK_HAVE_LOCK(); 1624 XFreePixmap((Display *)jlong_to_ptr(display), (Pixmap) pixmap); 1625 } 1626 1627 /* 1628 * Class: sun_awt_X11_XlibWrapper 1629 * Method: XReparentWindow 1630 * Signature: (JJJII)V 1631 */ 1632 JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XReparentWindow 1633 (JNIEnv *env, jclass clazz, jlong display, jlong window, jlong parent, jint x, jint y) { 1634 AWT_CHECK_HAVE_LOCK(); 1635 XReparentWindow((Display*)jlong_to_ptr(display), window, parent, x, y); 1636 } 1637 1638 /* 1639 * Class: sun_awt_X11_XlibWrapper 1640 * Method: XConvertSelection 1641 * Signature: (JJJJJJ)V 1642 */ 1643 JNIEXPORT void JNICALL 1644 Java_sun_awt_X11_XlibWrapper_XConvertSelection(JNIEnv *env, jclass clazz, 1645 jlong display, jlong selection, 1646 jlong target, jlong property, 1647 jlong requestor, jlong time) { 1648 AWT_CHECK_HAVE_LOCK(); 1649 XConvertSelection((Display*)jlong_to_ptr(display), selection, target, property, requestor, 1650 time); 1651 } 1652 1653 /* 1654 * Class: sun_awt_X11_XlibWrapper 1655 * Method: XSetSelectionOwner 1656 * Signature: (JJJJ)V 1657 */ 1658 JNIEXPORT void JNICALL 1659 Java_sun_awt_X11_XlibWrapper_XSetSelectionOwner(JNIEnv *env, jclass clazz, 1660 jlong display, jlong selection, 1661 jlong owner, jlong time) { 1662 AWT_CHECK_HAVE_LOCK(); 1663 XSetSelectionOwner((Display*)jlong_to_ptr(display), selection, owner, time); 1664 } 1665 1666 /* 1667 * Class: sun_awt_X11_XlibWrapper 1668 * Method: XGetSelectionOwner 1669 * Signature: (JJ)J 1670 */ 1671 JNIEXPORT jlong JNICALL 1672 Java_sun_awt_X11_XlibWrapper_XGetSelectionOwner(JNIEnv *env, jclass clazz, 1673 jlong display, jlong selection) { 1674 AWT_CHECK_HAVE_LOCK_RETURN(0); 1675 return (jlong)XGetSelectionOwner((Display*)jlong_to_ptr(display), selection); 1676 } 1677 1678 /* 1679 * Class: sun_awt_X11_XlibWrapper 1680 * Method: XGetAtomName 1681 * Signature: (JJ)Ljava/lang/String; 1682 */ 1683 JNIEXPORT jstring JNICALL 1684 Java_sun_awt_X11_XlibWrapper_XGetAtomName(JNIEnv *env, jclass clazz, 1685 jlong display, jlong atom) 1686 { 1687 jstring string = NULL; 1688 char* name; 1689 AWT_CHECK_HAVE_LOCK_RETURN(NULL); 1690 name = (char*) XGetAtomName((Display*)jlong_to_ptr(display), atom); 1691 1692 if (name == NULL) { 1693 fprintf(stderr, "Atom was %d\n", (int)atom); 1694 JNU_ThrowNullPointerException(env, "Failed to retrieve atom name."); 1695 return NULL; 1696 } 1697 1698 string = (*env)->NewStringUTF(env, (const char *)name); 1699 1700 XFree(name); 1701 1702 return string; 1703 } 1704 1705 /* 1706 * Class: sun_awt_X11_XlibWrapper 1707 * Method: XMaxRequestSize 1708 * Signature: (J)J 1709 */ 1710 JNIEXPORT jlong JNICALL 1711 Java_sun_awt_X11_XlibWrapper_XMaxRequestSize(JNIEnv *env, jclass clazz, 1712 jlong display) { 1713 AWT_CHECK_HAVE_LOCK_RETURN(0); 1714 return XMaxRequestSize((Display*) jlong_to_ptr(display)); 1715 } 1716 1717 JNIEXPORT jlong JNICALL 1718 Java_sun_awt_X11_XlibWrapper_XAllocWMHints(JNIEnv *env, jclass clazz) 1719 { 1720 AWT_CHECK_HAVE_LOCK_RETURN(0); 1721 return ptr_to_jlong(XAllocWMHints()); 1722 } 1723 1724 JNIEXPORT jlong JNICALL 1725 Java_sun_awt_X11_XlibWrapper_XCreatePixmap(JNIEnv *env, jclass clazz, jlong display, jlong drawable, jint width, jint height, jint depth) 1726 { 1727 AWT_CHECK_HAVE_LOCK_RETURN(0); 1728 return XCreatePixmap((Display*)jlong_to_ptr(display), (Drawable)drawable, width, height, depth); 1729 } 1730 1731 JNIEXPORT jlong JNICALL 1732 Java_sun_awt_X11_XlibWrapper_XCreateImage 1733 (JNIEnv *env, jclass clazz, jlong display, jlong visual_ptr, 1734 jint depth, jint format, jint offset, jlong data, jint width, 1735 jint height, jint bitmap_pad, jint bytes_per_line) 1736 { 1737 AWT_CHECK_HAVE_LOCK_RETURN(0); 1738 return ptr_to_jlong(XCreateImage((Display*) jlong_to_ptr(display), (Visual*) jlong_to_ptr(visual_ptr), 1739 depth, format, offset, (char*) jlong_to_ptr(data), 1740 width, height, bitmap_pad, bytes_per_line)); 1741 } 1742 1743 JNIEXPORT jlong JNICALL 1744 Java_sun_awt_X11_XlibWrapper_XCreateGC 1745 (JNIEnv *env, jclass clazz, jlong display, jlong drawable, 1746 jlong valuemask, jlong values) 1747 { 1748 AWT_CHECK_HAVE_LOCK_RETURN(0); 1749 return ptr_to_jlong(XCreateGC((Display*) jlong_to_ptr(display), (Drawable)drawable, valuemask, (XGCValues*) jlong_to_ptr(values))); 1750 } 1751 1752 JNIEXPORT void JNICALL 1753 Java_sun_awt_X11_XlibWrapper_XDestroyImage(JNIEnv *env, jclass clazz, jlong image) 1754 { 1755 XImage *img = (XImage*) jlong_to_ptr(image); 1756 AWT_CHECK_HAVE_LOCK(); 1757 1758 // Fix for bug 4903671 : 1759 // We should be careful to not double free the memory pointed to data 1760 // Since we use unsafe to allocate it, we should use unsafe to free it. 1761 // So we should NULL the data pointer before calling XDestroyImage so 1762 // that X does not free the pointer for us. 1763 img->data = NULL; 1764 XDestroyImage(img); 1765 } 1766 1767 JNIEXPORT void JNICALL 1768 Java_sun_awt_X11_XlibWrapper_XPutImage(JNIEnv *env, jclass clazz, jlong display, jlong drawable, jlong gc, jlong image, jint src_x, jint src_y, jint dest_x, jint dest_y, jint width, jint height) 1769 { 1770 AWT_CHECK_HAVE_LOCK(); 1771 XPutImage((Display*)jlong_to_ptr(display), (Drawable)drawable, (GC) jlong_to_ptr(gc), (XImage*) jlong_to_ptr(image), src_x, src_y, 1772 dest_x, dest_y, width, height); 1773 } 1774 1775 JNIEXPORT void JNICALL 1776 Java_sun_awt_X11_XlibWrapper_XFreeGC(JNIEnv *env, jclass clazz, jlong display, jlong gc) 1777 { 1778 AWT_CHECK_HAVE_LOCK(); 1779 XFreeGC((Display*) jlong_to_ptr(display), (GC) jlong_to_ptr(gc)); 1780 } 1781 1782 JNIEXPORT void JNICALL 1783 Java_sun_awt_X11_XlibWrapper_XSetWindowBackgroundPixmap(JNIEnv *env, jclass clazz, jlong display, jlong window, jlong pixmap) 1784 { 1785 AWT_CHECK_HAVE_LOCK(); 1786 XSetWindowBackgroundPixmap((Display*) jlong_to_ptr(display), (Window)window, (Pixmap)pixmap); 1787 } 1788 1789 JNIEXPORT void JNICALL 1790 Java_sun_awt_X11_XlibWrapper_XClearWindow(JNIEnv *env, jclass clazz, jlong display, jlong window) 1791 { 1792 AWT_CHECK_HAVE_LOCK(); 1793 XClearWindow((Display*) jlong_to_ptr(display), (Window)window); 1794 } 1795 1796 JNIEXPORT jint JNICALL 1797 Java_sun_awt_X11_XlibWrapper_XGetIconSizes(JNIEnv *env, jclass clazz, jlong display, jlong window, jlong ret_sizes, jlong ret_count) 1798 { 1799 XIconSize** psize = (XIconSize**) jlong_to_ptr(ret_sizes); 1800 int * pcount = (int *) jlong_to_ptr(ret_count); 1801 Status res; 1802 AWT_CHECK_HAVE_LOCK_RETURN(0); 1803 res = XGetIconSizes((Display*) jlong_to_ptr(display), (Window)window, psize, pcount); 1804 return res; 1805 } 1806 1807 JNIEXPORT jint JNICALL Java_sun_awt_X11_XlibWrapper_XdbeQueryExtension 1808 (JNIEnv *env, jclass clazz, jlong display, jlong major_version_return, 1809 jlong minor_version_return) 1810 { 1811 AWT_CHECK_HAVE_LOCK_RETURN(0); 1812 return XdbeQueryExtension((Display*) jlong_to_ptr(display), (int *) jlong_to_ptr(major_version_return), 1813 (int *) jlong_to_ptr(minor_version_return)); 1814 } 1815 1816 JNIEXPORT jboolean JNICALL Java_sun_awt_X11_XlibWrapper_XQueryExtension 1817 (JNIEnv *env, jclass clazz, jlong display, jstring jstr, jlong mop_return, 1818 jlong feve_return, jlong err_return) 1819 { 1820 char *cname; 1821 Boolean bu; 1822 if (!JNU_IsNull(env, jstr)) { 1823 cname = (char *)JNU_GetStringPlatformChars(env, jstr, NULL); 1824 CHECK_NULL_RETURN(cname, JNI_FALSE); 1825 } else { 1826 cname = ""; 1827 } 1828 1829 AWT_CHECK_HAVE_LOCK_RETURN(JNI_FALSE); 1830 bu = XQueryExtension((Display*) jlong_to_ptr(display), cname, (int *) jlong_to_ptr(mop_return), 1831 (int *) jlong_to_ptr(feve_return), (int *) jlong_to_ptr(err_return)); 1832 if (!JNU_IsNull(env, jstr)) { 1833 JNU_ReleaseStringPlatformChars(env, jstr, (const char *) cname); 1834 } 1835 return bu ? JNI_TRUE : JNI_FALSE; 1836 } 1837 1838 JNIEXPORT jboolean JNICALL Java_sun_awt_X11_XlibWrapper_IsKeypadKey 1839 (JNIEnv *env, jclass clazz, jlong keysym) 1840 { 1841 AWT_CHECK_HAVE_LOCK_RETURN(JNI_FALSE); 1842 if(IsKeypadKey(keysym)) { 1843 return JNI_TRUE; 1844 } 1845 return JNI_FALSE; 1846 } 1847 1848 JNIEXPORT jlong JNICALL Java_sun_awt_X11_XlibWrapper_XdbeAllocateBackBufferName 1849 (JNIEnv *env, jclass clazz, jlong display, jlong window, jint swap_action) 1850 { 1851 AWT_CHECK_HAVE_LOCK_RETURN(0); 1852 return XdbeAllocateBackBufferName((Display*) jlong_to_ptr(display), (Window) window, 1853 (XdbeSwapAction) swap_action); 1854 } 1855 1856 JNIEXPORT jint JNICALL Java_sun_awt_X11_XlibWrapper_XdbeDeallocateBackBufferName 1857 (JNIEnv *env, jclass clazz, jlong display, jlong buffer) 1858 { 1859 AWT_CHECK_HAVE_LOCK_RETURN(0); 1860 return XdbeDeallocateBackBufferName((Display*) jlong_to_ptr(display), (XdbeBackBuffer) buffer); 1861 } 1862 1863 JNIEXPORT jint JNICALL Java_sun_awt_X11_XlibWrapper_XdbeBeginIdiom 1864 (JNIEnv *env, jclass clazz, jlong display) 1865 { 1866 AWT_CHECK_HAVE_LOCK_RETURN(0); 1867 return XdbeBeginIdiom((Display*) jlong_to_ptr(display)); 1868 } 1869 1870 JNIEXPORT jint JNICALL Java_sun_awt_X11_XlibWrapper_XdbeEndIdiom 1871 (JNIEnv *env, jclass clazz, jlong display) 1872 { 1873 AWT_CHECK_HAVE_LOCK_RETURN(0); 1874 return XdbeEndIdiom((Display*) jlong_to_ptr(display)); 1875 } 1876 1877 JNIEXPORT jint JNICALL Java_sun_awt_X11_XlibWrapper_XdbeSwapBuffers 1878 (JNIEnv *env, jclass clazz, jlong display, jlong swap_info, jint num_windows) 1879 { 1880 AWT_CHECK_HAVE_LOCK_RETURN(0); 1881 return XdbeSwapBuffers((Display*) jlong_to_ptr(display), (XdbeSwapInfo *) jlong_to_ptr(swap_info), num_windows); 1882 } 1883 JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XQueryKeymap 1884 (JNIEnv *env, jclass clazz, jlong display, jlong vector) 1885 { 1886 AWT_CHECK_HAVE_LOCK(); 1887 XQueryKeymap( (Display *) jlong_to_ptr(display), (char *) jlong_to_ptr(vector)); 1888 } 1889 1890 // XKeycodeToKeysym is deprecated but for compatibility we keep the API. 1891 JNIEXPORT jlong JNICALL 1892 Java_sun_awt_X11_XlibWrapper_XKeycodeToKeysym(JNIEnv *env, jclass clazz, 1893 jlong display, jint keycode, 1894 jint index) { 1895 AWT_CHECK_HAVE_LOCK_RETURN(0); 1896 return keycodeToKeysym((Display*)jlong_to_ptr(display), (unsigned int)keycode, (int)index); 1897 } 1898 1899 JNIEXPORT jint JNICALL 1900 Java_sun_awt_X11_XlibWrapper_XkbGetEffectiveGroup(JNIEnv *env, jclass clazz, 1901 jlong display) { 1902 XkbStateRec sr; 1903 AWT_CHECK_HAVE_LOCK_RETURN(0); 1904 memset(&sr, 0, sizeof(XkbStateRec)); 1905 XkbGetState((Display*) jlong_to_ptr(display), XkbUseCoreKbd, &sr); 1906 // printf("-------------------------------------VVVV\n"); 1907 // printf(" group:0x%0X\n",sr.group); 1908 // printf(" base_group:0x%0X\n",sr.base_group); 1909 // printf(" latched_group:0x%0X\n",sr.latched_group); 1910 // printf(" locked_group:0x%0X\n",sr.locked_group); 1911 // printf(" mods:0x%0X\n",sr.mods); 1912 // printf(" base_mods:0x%0X\n",sr.base_mods); 1913 // printf(" latched_mods:0x%0X\n",sr.latched_mods); 1914 // printf(" locked_mods:0x%0X\n",sr.locked_mods); 1915 // printf(" compat_state:0x%0X\n",sr.compat_state); 1916 // printf(" grab_mods:0x%0X\n",sr.grab_mods); 1917 // printf(" compat_grab_mods:0x%0X\n",sr.compat_grab_mods); 1918 // printf(" lookup_mods:0x%0X\n",sr.lookup_mods); 1919 // printf(" compat_lookup_mods:0x%0X\n",sr.compat_lookup_mods); 1920 // printf(" ptr_buttons:0x%0X\n",sr.ptr_buttons); 1921 // printf("-------------------------------------^^^^\n"); 1922 return (jint)(sr.group); 1923 } 1924 1925 JNIEXPORT jlong JNICALL 1926 Java_sun_awt_X11_XlibWrapper_XkbKeycodeToKeysym(JNIEnv *env, jclass clazz, 1927 jlong display, jint keycode, 1928 jint group, jint level) { 1929 AWT_CHECK_HAVE_LOCK_RETURN(0); 1930 return XkbKeycodeToKeysym((Display*) jlong_to_ptr(display), (unsigned int)keycode, (unsigned int)group, (unsigned int)level); 1931 } 1932 1933 JNIEXPORT jint JNICALL 1934 Java_sun_awt_X11_XlibWrapper_XKeysymToKeycode(JNIEnv *env, jclass clazz, 1935 jlong display, jlong keysym) { 1936 AWT_CHECK_HAVE_LOCK_RETURN(0); 1937 return XKeysymToKeycode((Display*) jlong_to_ptr(display), (KeySym)keysym); 1938 } 1939 1940 JNIEXPORT jlong JNICALL 1941 Java_sun_awt_X11_XlibWrapper_XGetModifierMapping(JNIEnv *env, jclass clazz, 1942 jlong display) { 1943 AWT_CHECK_HAVE_LOCK_RETURN(0); 1944 return ptr_to_jlong(XGetModifierMapping((Display*) jlong_to_ptr(display))); 1945 } 1946 1947 JNIEXPORT void JNICALL 1948 Java_sun_awt_X11_XlibWrapper_XFreeModifiermap(JNIEnv *env, jclass clazz, 1949 jlong keymap) { 1950 AWT_CHECK_HAVE_LOCK(); 1951 XFreeModifiermap((XModifierKeymap*) jlong_to_ptr(keymap)); 1952 } 1953 1954 /* 1955 * Class: sun_awt_X11_XlibWrapper 1956 * Method: XRefreshKeyboardMapping 1957 * Signature: (J)V 1958 */ 1959 JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XRefreshKeyboardMapping 1960 (JNIEnv *env, jclass clazz, jlong event_ptr) 1961 { 1962 AWT_CHECK_HAVE_LOCK(); 1963 XRefreshKeyboardMapping((XMappingEvent*) jlong_to_ptr(event_ptr)); 1964 } 1965 1966 JNIEXPORT void JNICALL 1967 Java_sun_awt_X11_XlibWrapper_XChangeActivePointerGrab(JNIEnv *env, jclass clazz, 1968 jlong display, jint mask, 1969 jlong cursor, jlong time) { 1970 AWT_CHECK_HAVE_LOCK(); 1971 XChangeActivePointerGrab((Display*)jlong_to_ptr(display), (unsigned int)mask, 1972 (Cursor)cursor, (Time)time); 1973 } 1974 1975 /******************* Secondary loop support ************************************/ 1976 #define AWT_SECONDARY_LOOP_TIMEOUT 250 1977 1978 static Bool exitSecondaryLoop = True; 1979 1980 /* 1981 * This predicate procedure allows the Toolkit thread to process specific events 1982 * while it is blocked waiting for the event dispatch thread to process 1983 * a SunDropTargetEvent. We need this to prevent deadlock when the client code 1984 * processing SunDropTargetEvent sets or gets the contents of the system 1985 * clipboard/selection. In this case the event dispatch thread waits for the 1986 * Toolkit thread to process PropertyNotify or SelectionNotify events. 1987 */ 1988 static Bool 1989 secondary_loop_event(Display* dpy, XEvent* event, XPointer xawt_root_window) { 1990 return ( 1991 event->type == SelectionNotify || 1992 event->type == SelectionClear || 1993 event->type == PropertyNotify || 1994 (event->type == ConfigureNotify 1995 && event->xany.window == *(Window*) xawt_root_window) 1996 ) ? True : False; 1997 } 1998 1999 JNIEXPORT jboolean JNICALL 2000 Java_sun_awt_X11_XlibWrapper_XNextSecondaryLoopEvent(JNIEnv *env, jclass clazz, 2001 jlong display, jlong ptr) { 2002 uint32_t timeout = 1; 2003 2004 AWT_CHECK_HAVE_LOCK_RETURN(JNI_FALSE); 2005 exitSecondaryLoop = False; 2006 Window xawt_root_window = get_xawt_root_shell(env); 2007 2008 while (!exitSecondaryLoop) { 2009 if (XCheckIfEvent((Display*) jlong_to_ptr(display), 2010 (XEvent*) jlong_to_ptr(ptr), secondary_loop_event, (XPointer) &xawt_root_window)) { 2011 return JNI_TRUE; 2012 } 2013 timeout = (timeout < AWT_SECONDARY_LOOP_TIMEOUT) ? (timeout << 1) : AWT_SECONDARY_LOOP_TIMEOUT; 2014 AWT_WAIT(timeout); 2015 } 2016 return JNI_FALSE; 2017 } 2018 2019 JNIEXPORT void JNICALL 2020 Java_sun_awt_X11_XlibWrapper_ExitSecondaryLoop(JNIEnv *env, jclass clazz) { 2021 DASSERT(!exitSecondaryLoop); 2022 AWT_CHECK_HAVE_LOCK(); 2023 exitSecondaryLoop = True; 2024 AWT_NOTIFY_ALL(); 2025 } 2026 2027 JNIEXPORT jobjectArray JNICALL 2028 Java_sun_awt_X11_XlibWrapper_XTextPropertyToStringList(JNIEnv *env, 2029 jclass clazz, 2030 jbyteArray bytes, 2031 jlong encodingAtom) { 2032 XTextProperty tp; 2033 jbyte *value; 2034 2035 char** strings = (char **)NULL; 2036 int32_t nstrings = 0; 2037 jobjectArray ret = NULL; 2038 int32_t i; 2039 jsize len; 2040 jboolean isCopy = JNI_FALSE; 2041 static jclass stringClass = NULL; 2042 jclass stringClassLocal = NULL; 2043 2044 AWT_CHECK_HAVE_LOCK_RETURN(NULL); 2045 2046 if (JNU_IsNull(env, stringClass)) { 2047 stringClassLocal = (*env)->FindClass(env, "java/lang/String"); 2048 2049 if ((*env)->ExceptionCheck(env)) { 2050 (*env)->ExceptionDescribe(env); 2051 (*env)->ExceptionClear(env); 2052 DASSERT(False); 2053 } 2054 2055 if (JNU_IsNull(env, stringClassLocal)) { 2056 return NULL; 2057 } 2058 2059 stringClass = (*env)->NewGlobalRef(env, stringClassLocal); /* never freed! */ 2060 (*env)->DeleteLocalRef(env, stringClassLocal); 2061 2062 if (JNU_IsNull(env, stringClass)) { 2063 JNU_ThrowOutOfMemoryError(env, ""); 2064 return NULL; 2065 } 2066 } 2067 2068 /* 2069 * If the length of the byte array is 0 just return a null 2070 */ 2071 len = (*env)->GetArrayLength(env, bytes); 2072 if (len == 0) { 2073 return (*env)->NewObjectArray(env, 0, stringClass, NULL); 2074 } 2075 2076 value = (*env)->GetByteArrayElements(env, bytes, &isCopy); 2077 if (JNU_IsNull(env, value)) { 2078 return NULL; 2079 } 2080 2081 tp.encoding = encodingAtom; 2082 tp.value = (unsigned char *)value; 2083 tp.nitems = len; 2084 tp.format = 8; 2085 2086 /* 2087 * Convert the byte stream into a list of X11 strings 2088 */ 2089 if (XTextPropertyToStringList(&tp, &strings, &nstrings) == 0) { 2090 (*env)->ReleaseByteArrayElements(env, bytes, value, JNI_ABORT); 2091 return NULL; 2092 } 2093 2094 (*env)->ReleaseByteArrayElements(env, bytes, value, JNI_ABORT); 2095 2096 if (nstrings == 0) { 2097 return (*env)->NewObjectArray(env, 0, stringClass, NULL); 2098 } 2099 2100 ret = (*env)->NewObjectArray(env, nstrings, stringClass, NULL); 2101 2102 if ((*env)->ExceptionCheck(env)) { 2103 (*env)->ExceptionDescribe(env); 2104 (*env)->ExceptionClear(env); 2105 goto wayout; 2106 } 2107 2108 if (JNU_IsNull(env, ret)) { 2109 goto wayout; 2110 } 2111 2112 for (i = 0; i < nstrings; i++) { 2113 jstring string = (*env)->NewStringUTF(env, 2114 (const char *)strings[i]); 2115 if ((*env)->ExceptionCheck(env)) { 2116 (*env)->ExceptionDescribe(env); 2117 (*env)->ExceptionClear(env); 2118 goto wayout; 2119 } 2120 2121 if (JNU_IsNull(env, string)) { 2122 goto wayout; 2123 } 2124 2125 (*env)->SetObjectArrayElement(env, ret, i, string); 2126 2127 if ((*env)->ExceptionCheck(env)) { 2128 (*env)->ExceptionDescribe(env); 2129 (*env)->ExceptionClear(env); 2130 goto wayout; 2131 } 2132 2133 (*env)->DeleteLocalRef(env, string); 2134 } 2135 2136 wayout: 2137 /* 2138 * Clean up and return 2139 */ 2140 XFreeStringList(strings); 2141 return ret; 2142 } 2143 2144 JNIEXPORT void JNICALL 2145 Java_sun_awt_X11_XlibWrapper_XPutBackEvent(JNIEnv *env, 2146 jclass clazz, 2147 jlong display, 2148 jlong event) { 2149 XPutBackEvent((Display*)jlong_to_ptr(display), (XEvent*) jlong_to_ptr(event)); 2150 } 2151 2152 JNIEXPORT jlong JNICALL 2153 Java_sun_awt_X11_XlibWrapper_getAddress(JNIEnv *env, 2154 jclass clazz, 2155 jobject o) { 2156 return ptr_to_jlong(o); 2157 } 2158 2159 JNIEXPORT void JNICALL 2160 Java_sun_awt_X11_XlibWrapper_copyIntArray(JNIEnv *env, 2161 jclass clazz, 2162 jlong dest, jobject array, jint size) { 2163 jboolean isCopy = JNI_FALSE; 2164 jint * ints = (*env)->GetIntArrayElements(env, array, &isCopy); 2165 memcpy(jlong_to_ptr(dest), ints, size); 2166 if (isCopy) { 2167 (*env)->ReleaseIntArrayElements(env, array, ints, JNI_ABORT); 2168 } 2169 } 2170 2171 JNIEXPORT void JNICALL 2172 Java_sun_awt_X11_XlibWrapper_copyLongArray(JNIEnv *env, 2173 jclass clazz, 2174 jlong dest, jobject array, jint size) { 2175 jboolean isCopy = JNI_FALSE; 2176 jlong * longs = (*env)->GetLongArrayElements(env, array, &isCopy); 2177 memcpy(jlong_to_ptr(dest), longs, size); 2178 if (isCopy) { 2179 (*env)->ReleaseLongArrayElements(env, array, longs, JNI_ABORT); 2180 } 2181 } 2182 2183 JNIEXPORT jint JNICALL 2184 Java_sun_awt_X11_XlibWrapper_XSynchronize(JNIEnv *env, jclass clazz, jlong display, jboolean onoff) 2185 { 2186 return (jint) ((intptr_t)XSynchronize((Display*)jlong_to_ptr(display), (onoff == JNI_TRUE ? True : False))); 2187 } 2188 2189 JNIEXPORT jboolean JNICALL 2190 Java_sun_awt_X11_XlibWrapper_XShapeQueryExtension 2191 (JNIEnv *env, jclass clazz, jlong display, jlong event_base_return, jlong error_base_return) 2192 { 2193 Bool status; 2194 2195 AWT_CHECK_HAVE_LOCK_RETURN(JNI_FALSE); 2196 2197 status = XShapeQueryExtension((Display *)jlong_to_ptr(display), 2198 (int *)jlong_to_ptr(event_base_return), (int *)jlong_to_ptr(error_base_return)); 2199 return status ? JNI_TRUE : JNI_FALSE; 2200 } 2201 2202 /* 2203 * Class: XlibWrapper 2204 * Method: SetRectangularShape 2205 */ 2206 2207 JNIEXPORT void JNICALL 2208 Java_sun_awt_X11_XlibWrapper_SetRectangularShape 2209 (JNIEnv *env, jclass clazz, jlong display, jlong window, 2210 jint x1, jint y1, jint x2, jint y2, 2211 jobject region) 2212 { 2213 AWT_CHECK_HAVE_LOCK(); 2214 2215 // If all the params are zeros, the shape must be simply reset. 2216 // Otherwise, the shape may be not rectangular. 2217 if (region || x1 || x2 || y1 || y2) { 2218 XRectangle rects[256]; 2219 XRectangle *pRect = rects; 2220 2221 int numrects = RegionToYXBandedRectangles(env, x1, y1, x2, y2, region, 2222 &pRect, 256); 2223 2224 XShapeCombineRectangles((Display *)jlong_to_ptr(display), (Window)jlong_to_ptr(window), 2225 ShapeClip, 0, 0, pRect, numrects, ShapeSet, YXBanded); 2226 XShapeCombineRectangles((Display *)jlong_to_ptr(display), (Window)jlong_to_ptr(window), 2227 ShapeBounding, 0, 0, pRect, numrects, ShapeSet, YXBanded); 2228 2229 if (pRect != rects) { 2230 free(pRect); 2231 } 2232 } else { 2233 // Reset the shape to a rectangular form. 2234 XShapeCombineMask((Display *)jlong_to_ptr(display), (Window)jlong_to_ptr(window), 2235 ShapeClip, 0, 0, None, ShapeSet); 2236 XShapeCombineMask((Display *)jlong_to_ptr(display), (Window)jlong_to_ptr(window), 2237 ShapeBounding, 0, 0, None, ShapeSet); 2238 } 2239 } 2240 2241 /* 2242 * Class: XlibWrapper 2243 * Method: SetZOrder 2244 */ 2245 2246 JNIEXPORT void JNICALL 2247 Java_sun_awt_X11_XlibWrapper_SetZOrder 2248 (JNIEnv *env, jclass clazz, jlong display, jlong window, jlong above) 2249 { 2250 unsigned int value_mask = CWStackMode; 2251 2252 XWindowChanges wc; 2253 wc.sibling = (Window)jlong_to_ptr(above); 2254 2255 AWT_CHECK_HAVE_LOCK(); 2256 2257 if (above == 0) { 2258 wc.stack_mode = Above; 2259 } else { 2260 wc.stack_mode = Below; 2261 value_mask |= CWSibling; 2262 } 2263 2264 XConfigureWindow((Display *)jlong_to_ptr(display), 2265 (Window)jlong_to_ptr(window), 2266 value_mask, &wc ); 2267 } 2268 2269 /* 2270 * Class: XlibWrapper 2271 * Method: SetBitmapShape 2272 */ 2273 JNIEXPORT void JNICALL 2274 Java_sun_awt_X11_XlibWrapper_SetBitmapShape 2275 (JNIEnv *env, jclass clazz, jlong display, jlong window, 2276 jint width, jint height, jintArray bitmap) 2277 { 2278 jsize len; 2279 jint *values; 2280 jboolean isCopy = JNI_FALSE; 2281 size_t worstBufferSize = (size_t)((width / 2 + 1) * height); 2282 RECT_T * pRect; 2283 int numrects; 2284 2285 if (!IS_SAFE_SIZE_MUL(width / 2 + 1, height)) { 2286 return; 2287 } 2288 2289 AWT_CHECK_HAVE_LOCK(); 2290 2291 len = (*env)->GetArrayLength(env, bitmap); 2292 if (len == 0 || len < width * height) { 2293 return; 2294 } 2295 2296 values = (*env)->GetIntArrayElements(env, bitmap, &isCopy); 2297 if (JNU_IsNull(env, values)) { 2298 return; 2299 } 2300 2301 pRect = (RECT_T *)SAFE_SIZE_ARRAY_ALLOC(malloc, (int)worstBufferSize, sizeof(RECT_T)); 2302 if (!pRect) { 2303 return; 2304 } 2305 2306 /* Note: the values[0] and values[1] are supposed to contain the width 2307 * and height (see XIconInfo.getIntData() for details). So, we do +2. 2308 */ 2309 numrects = BitmapToYXBandedRectangles(32, (int)width, (int)height, 2310 (unsigned char *)(values + 2), pRect); 2311 2312 XShapeCombineRectangles((Display *)jlong_to_ptr(display), (Window)jlong_to_ptr(window), 2313 ShapeClip, 0, 0, pRect, numrects, ShapeSet, YXBanded); 2314 XShapeCombineRectangles((Display *)jlong_to_ptr(display), (Window)jlong_to_ptr(window), 2315 ShapeBounding, 0, 0, pRect, numrects, ShapeSet, YXBanded); 2316 2317 free(pRect); 2318 2319 (*env)->ReleaseIntArrayElements(env, bitmap, values, JNI_ABORT); 2320 }