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