1 /*
2 * Copyright (c) 2002, 2013, 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 jint 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 jint 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 *)jlong_to_ptr(lib_major_in_out)) = XkbMajorVersion;
489 *((int *)jlong_to_ptr(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 jint 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 jint 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 static jboolean result = JNI_FALSE;
1234
1235 int32_t minKeyCode, maxKeyCode, keySymsPerKeyCode;
1236 KeySym *keySyms, *keySymsStart, keySym;
1237 int32_t i;
1238 int32_t kanaCount = 0;
1239
1240 AWT_CHECK_HAVE_LOCK();
1241
1242 // There's no direct way to determine whether the keyboard has
1243 // a kana lock key. From available keyboard mapping tables, it looks
1244 // like only keyboards with the kana lock key can produce keysyms
1245 // for kana characters. So, as an indirect test, we check for those.
1246 XDisplayKeycodes((Display*)jlong_to_ptr(display), &minKeyCode, &maxKeyCode);
1247 keySyms = XGetKeyboardMapping((Display*)jlong_to_ptr(display), minKeyCode, maxKeyCode - minKeyCode + 1, &keySymsPerKeyCode);
1248 keySymsStart = keySyms;
1249 for (i = 0; i < (maxKeyCode - minKeyCode + 1) * keySymsPerKeyCode; i++) {
1250 keySym = *keySyms++;
1251 if ((keySym & 0xff00) == 0x0400) {
1252 kanaCount++;
1253 }
1254 }
1255 XFree(keySymsStart);
1256
1257 // use a (somewhat arbitrary) minimum so we don't get confused by a stray function key
1258 result = kanaCount > 10;
1259 return result ? JNI_TRUE : JNI_FALSE;
1260 }
1261
1262 JavaVM* jvm = NULL;
1263 static int ToolkitErrorHandler(Display * dpy, XErrorEvent * event) {
1264 JNIEnv * env;
1265 if (jvm != NULL) {
1266 env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
1267 if (env) {
1268 return JNU_CallStaticMethodByName(env, NULL, "sun/awt/X11/XToolkit", "globalErrorHandler", "(JJ)I",
1269 ptr_to_jlong(dpy), ptr_to_jlong(event)).i;
1270 }
1271 }
1272 return 0;
1273 }
1274
1275 /*
1276 * Class: sun_awt_X11_XlibWrapper
1277 * Method: SetToolkitErrorHandler
1278 * Signature: ()J
1279 */
1280 JNIEXPORT jlong JNICALL Java_sun_awt_X11_XlibWrapper_SetToolkitErrorHandler
1281 (JNIEnv *env, jclass clazz)
1282 {
1283 (*env)->GetJavaVM(env, &jvm);
1284 AWT_CHECK_HAVE_LOCK();
1285 return ptr_to_jlong(XSetErrorHandler(ToolkitErrorHandler));
1286 }
1287
1288 /*
1289 * Class: sun_awt_X11_XlibWrapper
1290 * Method: XSetErrorHandler
1291 * Signature: (J)V
1292 */
1293 JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XSetErrorHandler
1294 (JNIEnv *env, jclass clazz, jlong handler)
1295 {
1296 AWT_CHECK_HAVE_LOCK();
1297 XSetErrorHandler((XErrorHandler) jlong_to_ptr(handler));
1298 }
1299
1300 /*
1301 * Class: sun_awt_X11_XlibWrapper
1302 * Method: CallErrorHandler
1303 * Signature: (JJJ)I
1304 */
1305 JNIEXPORT jint JNICALL Java_sun_awt_X11_XlibWrapper_CallErrorHandler
1306 (JNIEnv *env, jclass clazz, jlong handler, jlong display, jlong event_ptr)
1307 {
1308 return (*(XErrorHandler)jlong_to_ptr(handler))((Display*) jlong_to_ptr(display), (XErrorEvent*) jlong_to_ptr(event_ptr));
1309 }
1310
1311
1312 /*
1313 * Class: sun_awt_X11_XlibWrapper
1314 * Method: PrintXErrorEvent
1315 * Signature: (JJ)V
1316 */
1317 JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_PrintXErrorEvent
1318 (JNIEnv *env, jclass clazz, jlong display, jlong event_ptr)
1319 {
1320 char msg[128];
1321 char buf[128];
1322
1323 XErrorEvent* err = (XErrorEvent *)jlong_to_ptr(event_ptr);
1324
1325 XGetErrorText((Display *)jlong_to_ptr(display), err->error_code, msg, sizeof(msg));
1326 jio_fprintf(stderr, "Xerror %s, XID %x, ser# %d\n", msg, err->resourceid, err->serial);
1327 jio_snprintf(buf, sizeof(buf), "%d", err->request_code);
1328 XGetErrorDatabaseText((Display *)jlong_to_ptr(display), "XRequest", buf, "Unknown", msg, sizeof(msg));
1329 jio_fprintf(stderr, "Major opcode %d (%s)\n", err->request_code, msg);
1330 if (err->request_code > 128) {
1331 jio_fprintf(stderr, "Minor opcode %d\n", err->minor_code);
1332 }
1333 }
1334
1335
1336 /*
1337 * Class: sun_awt_X11_XlibWrapper
1338 * Method: XInternAtoms
1339 * Signature: (J[Ljava/lang/String;ZJ)I
1340 */
1341 JNIEXPORT jint JNICALL Java_sun_awt_X11_XlibWrapper_XInternAtoms
1342 (JNIEnv *env, jclass clazz, jlong display, jobjectArray names_arr, jboolean only_if_exists, jlong atoms)
1343 {
1344 int length = (*env)->GetArrayLength(env, names_arr);
1345 char ** names = (char**)malloc(length*sizeof(char*));
1346 jboolean copy;
1347 int index, name_index = 0;
1348 int status;
1349
1350 AWT_CHECK_HAVE_LOCK();
1351
1352 for (index = 0; index < length; index++) {
1353 jstring str = (*env)->GetObjectArrayElement(env, names_arr, index);
1354 if (!JNU_IsNull(env, str)) {
1355 const char * str_char = JNU_GetStringPlatformChars(env, str, NULL);
1356 names[name_index++] = strdup(str_char);
1357 JNU_ReleaseStringPlatformChars(env, str, str_char);
1358 (*env)->DeleteLocalRef(env, str);
1359 }
1360 }
1361 status = XInternAtoms((Display*)jlong_to_ptr(display), names, name_index, only_if_exists, (Atom*) jlong_to_ptr(atoms));
1362 for (index = 0; index < length; index++) {
1363 free(names[index]);
1364 }
1365 free(names);
1366 return status;
1367 }
1368
1369
1370
1371 /*
1372 * Class: sun_awt_X11_XlibWrapper
1373 * Method: XGetWindowAttributes
1374 * Signature: (JJJ)I
1375 */
1376 JNIEXPORT jint JNICALL Java_sun_awt_X11_XlibWrapper_XGetWindowAttributes
1377 (JNIEnv *env, jclass clazz, jlong display, jlong window, jlong attr_ptr)
1378 {
1379 jint status;
1380 AWT_CHECK_HAVE_LOCK();
1381 memset((XWindowAttributes*) jlong_to_ptr(attr_ptr), 0, sizeof(XWindowAttributes));
1382 status = XGetWindowAttributes((Display*)jlong_to_ptr(display), window, (XWindowAttributes*) jlong_to_ptr(attr_ptr));
1383 return status;
1384 }
1385
1386
1387 /*
1388 * Class: sun_awt_X11_XlibWrapper
1389 * Method: XGetGeometry
1390 * Signature: (JJJJJJJJJ)I
1391 */
1392 JNIEXPORT jint JNICALL Java_sun_awt_X11_XlibWrapper_XGetGeometry
1393 (JNIEnv *env, jclass clazz, jlong display, jlong drawable, jlong root_return,
1394 jlong x_return, jlong y_return, jlong width_return, jlong height_return,
1395 jlong border_width_return, jlong depth_return)
1396 {
1397 jint status;
1398 AWT_CHECK_HAVE_LOCK();
1399 status = XGetGeometry((Display *)jlong_to_ptr(display),
1400 (Drawable)drawable, (Window *)jlong_to_ptr(root_return),
1401 (int *)jlong_to_ptr(x_return), (int *)jlong_to_ptr(y_return),
1402 (unsigned int *)jlong_to_ptr(width_return), (unsigned int *)jlong_to_ptr(height_return),
1403 (unsigned int *)jlong_to_ptr(border_width_return),
1404 (unsigned int *)jlong_to_ptr(depth_return));
1405 return status;
1406 }
1407
1408
1409 /*
1410 * Class: sun_awt_X11_XlibWrapper
1411 * Method: XGetWMNormalHints
1412 * Signature: (JJJJ)I
1413 */
1414 JNIEXPORT jint JNICALL Java_sun_awt_X11_XlibWrapper_XGetWMNormalHints
1415 (JNIEnv *env, jclass clazz, jlong display, jlong window, jlong hints, jlong supplied_return)
1416 {
1417 AWT_CHECK_HAVE_LOCK();
1418 return XGetWMNormalHints((Display*) jlong_to_ptr(display),
1419 window,
1420 (XSizeHints*) jlong_to_ptr(hints),
1421 (long*) jlong_to_ptr(supplied_return));
1422 }
1423
1424 /*
1425 * Class: sun_awt_X11_XlibWrapper
1426 * Method: XSetWMNormalHints
1427 * Signature: (JJJ)V
1428 */
1429 JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XSetWMNormalHints
1430 (JNIEnv *env, jclass clazz, jlong display, jlong window, jlong hints)
1431 {
1432 AWT_CHECK_HAVE_LOCK();
1433 XSetWMNormalHints((Display*) jlong_to_ptr(display), window, (XSizeHints*) jlong_to_ptr(hints));
1434 }
1435
1436 /*
1437 * Class: sun_awt_X11_XlibWrapper
1438 * Method: XDeleteProperty
1439 * Signature: (JJJ)V
1440 */
1441 JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XDeleteProperty
1442 (JNIEnv *env, jclass clazz, jlong display, jlong window, jlong atom)
1443 {
1444 AWT_CHECK_HAVE_LOCK();
1445 XDeleteProperty((Display*) jlong_to_ptr(display), window, (Atom)atom);
1446 }
1447
1448 /*
1449 * Class: sun_awt_X11_XlibWrapper
1450 * Method: XSendEvent
1451 * Signature: (JJZJJ)V
1452 */
1453 JNIEXPORT jint JNICALL Java_sun_awt_X11_XlibWrapper_XSendEvent
1454 (JNIEnv *env, jclass clazz, jlong display, jlong window, jboolean propagate, jlong event_mask, jlong event)
1455 {
1456 AWT_CHECK_HAVE_LOCK();
1457 return XSendEvent((Display*) jlong_to_ptr(display),
1458 window,
1459 propagate==JNI_TRUE?True:False,
1460 (long) event_mask,
1461 (XEvent*) jlong_to_ptr(event));
1462 }
1463
1464
1465 /*
1466 * Class: sun_awt_X11_XlibWrapper
1467 * Method: XQueryTree
1468 * Signature: (JJJJJJ)I
1469 */
1470 JNIEXPORT jint JNICALL Java_sun_awt_X11_XlibWrapper_XQueryTree
1471 (JNIEnv *env, jclass clazz, jlong display, jlong window, jlong root_return, jlong parent_return, jlong children_return, jlong nchildren_return)
1472 {
1473 AWT_CHECK_HAVE_LOCK();
1474 return XQueryTree((Display*) jlong_to_ptr(display),
1475 window,
1476 (Window *) jlong_to_ptr(root_return),
1477 (Window*) jlong_to_ptr(parent_return),
1478 (Window**) jlong_to_ptr(children_return),
1479 (unsigned int*) jlong_to_ptr(nchildren_return));
1480 }
1481
1482
1483 /*
1484 * Class: sun_awt_X11_XlibWrapper
1485 * Method: memcpy
1486 * Signature: (JJJ)V
1487 */
1488 JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_memcpy
1489 (JNIEnv *env, jclass clazz, jlong dest_ptr, jlong src_ptr, jlong length)
1490 {
1491 memcpy(jlong_to_ptr(dest_ptr), jlong_to_ptr(src_ptr), length);
1492 }
1493
1494
1495 JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XSetMinMaxHints
1496 (JNIEnv *env, jclass clazz, jlong display, jlong window, jint x, jint y, jint width, jint height, jlong flags) {
1497 XSizeHints * hints;
1498 AWT_CHECK_HAVE_LOCK();
1499 hints = XAllocSizeHints();
1500 hints->flags = flags;
1501 hints->width = width;
1502 hints->min_width = width;
1503 hints->max_width = width;
1504 hints->height = height;
1505 hints->min_height = height;
1506 hints->max_height = height;
1507 hints->x = x;
1508 hints->y = y;
1509 XSetWMNormalHints((Display*) jlong_to_ptr(display), window, hints);
1510 XFree(hints);
1511 }
1512
1513
1514 JNIEXPORT jlong JNICALL Java_sun_awt_X11_XlibWrapper_XGetVisualInfo
1515 (JNIEnv *env, jclass clazz, jlong display, jlong vinfo_mask, jlong vinfo_template,
1516 jlong nitems_return)
1517 {
1518 AWT_CHECK_HAVE_LOCK();
1519 return ptr_to_jlong(XGetVisualInfo((Display*) jlong_to_ptr(display),
1520 (long) vinfo_mask,
1521 (XVisualInfo*) jlong_to_ptr(vinfo_template),
1522 (int*) jlong_to_ptr(nitems_return)));
1523 }
1524
1525 JNIEXPORT jlong JNICALL Java_sun_awt_X11_XlibWrapper_XAllocSizeHints
1526 (JNIEnv *env, jclass clazz)
1527 {
1528 AWT_CHECK_HAVE_LOCK();
1529 return ptr_to_jlong(XAllocSizeHints());
1530 }
1531
1532 /*
1533 * Class: sun_awt_X11_XlibWrapper
1534 * Method: XIconifyWindow
1535 * Signature: (JJJ)V
1536 */
1537 JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XBell
1538 (JNIEnv *env, jclass clazz, jlong display, jint percent)
1539 {
1540 AWT_CHECK_HAVE_LOCK();
1541 XBell((Display*)jlong_to_ptr(display), percent);
1542 }
1543
1544
1545 /*
1546 * Class: sun_awt_X11_XlibWrapper
1547 * Method: XAllocColor
1548 * Signature: (JJJ)Z
1549 */
1550 JNIEXPORT jboolean JNICALL Java_sun_awt_X11_XlibWrapper_XAllocColor
1551 (JNIEnv *env, jclass clazz, jlong display , jlong colormap, jlong xcolor) {
1552
1553 Status status;
1554 AWT_CHECK_HAVE_LOCK();
1555 status = XAllocColor((Display *) jlong_to_ptr(display), (Colormap) colormap, (XColor *) jlong_to_ptr(xcolor));
1556
1557 if (status == 0) return JNI_FALSE;
1558 else return JNI_TRUE;
1559 }
1560
1561
1562 /*
1563 * Class: sun_awt_X11_XlibWrapper
1564 * Method: XCreateBitmapFromData
1565 * Signature: (JJJII)J
1566 */
1567 JNIEXPORT jlong JNICALL Java_sun_awt_X11_XlibWrapper_XCreateBitmapFromData
1568 (JNIEnv *env, jclass clazz, jlong display, jlong drawable, jlong data, jint width, jint height) {
1569 AWT_CHECK_HAVE_LOCK();
1570
1571 return (jlong) XCreateBitmapFromData((Display *) jlong_to_ptr(display), (Drawable) drawable,
1572 (char *) jlong_to_ptr(data), width, height);
1573 }
1574
1575
1576 /*
1577 * Class: sun_awt_X11_XlibWrapper
1578 * Method: XFreePixmap
1579 * Signature: (JJ)V
1580 */
1581 JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XFreePixmap
1582 (JNIEnv *env, jclass clazz, jlong display, jlong pixmap) {
1583 AWT_CHECK_HAVE_LOCK();
1584 XFreePixmap((Display *)jlong_to_ptr(display), (Pixmap) pixmap);
1585 }
1586
1587 /*
1588 * Class: sun_awt_X11_XlibWrapper
1589 * Method: XReparentWindow
1590 * Signature: (JJJII)V
1591 */
1592 JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XReparentWindow
1593 (JNIEnv *env, jclass clazz, jlong display, jlong window, jlong parent, jint x, jint y) {
1594 AWT_CHECK_HAVE_LOCK();
1595 XReparentWindow((Display*)jlong_to_ptr(display), window, parent, x, y);
1596 }
1597
1598 /*
1599 * Class: sun_awt_X11_XlibWrapper
1600 * Method: XConvertSelection
1601 * Signature: (JJJJJJ)V
1602 */
1603 JNIEXPORT void JNICALL
1604 Java_sun_awt_X11_XlibWrapper_XConvertSelection(JNIEnv *env, jclass clazz,
1605 jlong display, jlong selection,
1606 jlong target, jlong property,
1607 jlong requestor, jlong time) {
1608 AWT_CHECK_HAVE_LOCK();
1609 XConvertSelection((Display*)jlong_to_ptr(display), selection, target, property, requestor,
1610 time);
1611 }
1612
1613 /*
1614 * Class: sun_awt_X11_XlibWrapper
1615 * Method: XSetSelectionOwner
1616 * Signature: (JJJJ)V
1617 */
1618 JNIEXPORT void JNICALL
1619 Java_sun_awt_X11_XlibWrapper_XSetSelectionOwner(JNIEnv *env, jclass clazz,
1620 jlong display, jlong selection,
1621 jlong owner, jlong time) {
1622 AWT_CHECK_HAVE_LOCK();
1623 XSetSelectionOwner((Display*)jlong_to_ptr(display), selection, owner, time);
1624 }
1625
1626 /*
1627 * Class: sun_awt_X11_XlibWrapper
1628 * Method: XGetSelectionOwner
1629 * Signature: (JJ)J
1630 */
1631 JNIEXPORT jlong JNICALL
1632 Java_sun_awt_X11_XlibWrapper_XGetSelectionOwner(JNIEnv *env, jclass clazz,
1633 jlong display, jlong selection) {
1634 AWT_CHECK_HAVE_LOCK();
1635 return (jlong)XGetSelectionOwner((Display*)jlong_to_ptr(display), selection);
1636 }
1637
1638 /*
1639 * Class: sun_awt_X11_XlibWrapper
1640 * Method: XGetAtomName
1641 * Signature: (JJ)Ljava/lang/String;
1642 */
1643 JNIEXPORT jstring JNICALL
1644 Java_sun_awt_X11_XlibWrapper_XGetAtomName(JNIEnv *env, jclass clazz,
1645 jlong display, jlong atom)
1646 {
1647 jstring string = NULL;
1648 char* name;
1649 AWT_CHECK_HAVE_LOCK();
1650 name = (char*) XGetAtomName((Display*)jlong_to_ptr(display), atom);
1651
1652 if (name == NULL) {
1653 fprintf(stderr, "Atom was %d\n", (int)atom);
1654 JNU_ThrowNullPointerException(env, "Failed to retrieve atom name.");
1655 return NULL;
1656 }
1657
1658 string = (*env)->NewStringUTF(env, (const char *)name);
1659
1660 XFree(name);
1661
1662 return string;
1663 }
1664
1665 /*
1666 * Class: sun_awt_X11_XlibWrapper
1667 * Method: XMaxRequestSize
1668 * Signature: (J)J
1669 */
1670 JNIEXPORT jlong JNICALL
1671 Java_sun_awt_X11_XlibWrapper_XMaxRequestSize(JNIEnv *env, jclass clazz,
1672 jlong display) {
1673 AWT_CHECK_HAVE_LOCK();
1674 return XMaxRequestSize((Display*) jlong_to_ptr(display));
1675 }
1676
1677 JNIEXPORT jlong JNICALL
1678 Java_sun_awt_X11_XlibWrapper_XAllocWMHints(JNIEnv *env, jclass clazz)
1679 {
1680 AWT_CHECK_HAVE_LOCK();
1681 return ptr_to_jlong(XAllocWMHints());
1682 }
1683
1684 JNIEXPORT jlong JNICALL
1685 Java_sun_awt_X11_XlibWrapper_XCreatePixmap(JNIEnv *env, jclass clazz, jlong display, jlong drawable, jint width, jint height, jint depth)
1686 {
1687 AWT_CHECK_HAVE_LOCK();
1688 return XCreatePixmap((Display*)jlong_to_ptr(display), (Drawable)drawable, width, height, depth);
1689 }
1690 JNIEXPORT jlong JNICALL
1691 Java_sun_awt_X11_XlibWrapper_XCreateImage
1692 (JNIEnv *env, jclass clazz, jlong display, jlong visual_ptr,
1693 jint depth, jint format, jint offset, jlong data, jint width,
1694 jint height, jint bitmap_pad, jint bytes_per_line)
1695 {
1696 AWT_CHECK_HAVE_LOCK();
1697 return ptr_to_jlong(XCreateImage((Display*) jlong_to_ptr(display), (Visual*) jlong_to_ptr(visual_ptr),
1698 depth, format, offset, (char*) jlong_to_ptr(data),
1699 width, height, bitmap_pad, bytes_per_line));
1700 }
1701 JNIEXPORT jlong JNICALL
1702 Java_sun_awt_X11_XlibWrapper_XCreateGC
1703 (JNIEnv *env, jclass clazz, jlong display, jlong drawable,
1704 jlong valuemask, jlong values)
1705 {
1706 AWT_CHECK_HAVE_LOCK();
1707 return ptr_to_jlong(XCreateGC((Display*) jlong_to_ptr(display), (Drawable)drawable, valuemask, (XGCValues*) jlong_to_ptr(values)));
1708 }
1709
1710 JNIEXPORT void JNICALL
1711 Java_sun_awt_X11_XlibWrapper_XDestroyImage(JNIEnv *env, jclass clazz, jlong image)
1712 {
1713 XImage *img = (XImage*) jlong_to_ptr(image);
1714 AWT_CHECK_HAVE_LOCK();
1715
1716 // Fix for bug 4903671 :
1717 // We should be careful to not double free the memory pointed to data
1718 // Since we use unsafe to allocate it, we should use unsafe to free it.
1719 // So we should NULL the data pointer before calling XDestroyImage so
1720 // that X does not free the pointer for us.
1721 img->data = NULL;
1722 XDestroyImage(img);
1723 }
1724 JNIEXPORT void JNICALL
1725 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)
1726 {
1727 AWT_CHECK_HAVE_LOCK();
1728 XPutImage((Display*)jlong_to_ptr(display), (Drawable)drawable, (GC) jlong_to_ptr(gc), (XImage*) jlong_to_ptr(image), src_x, src_y,
1729 dest_x, dest_y, width, height);
1730 }
1731 JNIEXPORT void JNICALL
1732 Java_sun_awt_X11_XlibWrapper_XFreeGC(JNIEnv *env, jclass clazz, jlong display, jlong gc)
1733 {
1734 AWT_CHECK_HAVE_LOCK();
1735 XFreeGC((Display*) jlong_to_ptr(display), (GC) jlong_to_ptr(gc));
1736 }
1737 JNIEXPORT void JNICALL
1738 Java_sun_awt_X11_XlibWrapper_XSetWindowBackgroundPixmap(JNIEnv *env, jclass clazz, jlong display, jlong window, jlong pixmap)
1739 {
1740 AWT_CHECK_HAVE_LOCK();
1741 XSetWindowBackgroundPixmap((Display*) jlong_to_ptr(display), (Window)window, (Pixmap)pixmap);
1742 }
1743 JNIEXPORT void JNICALL
1744 Java_sun_awt_X11_XlibWrapper_XClearWindow(JNIEnv *env, jclass clazz, jlong display, jlong window)
1745 {
1746 AWT_CHECK_HAVE_LOCK();
1747 XClearWindow((Display*) jlong_to_ptr(display), (Window)window);
1748 }
1749
1750 JNIEXPORT jint JNICALL
1751 Java_sun_awt_X11_XlibWrapper_XGetIconSizes(JNIEnv *env, jclass clazz, jlong display, jlong window, jlong ret_sizes, jlong ret_count)
1752 {
1753 XIconSize** psize = (XIconSize**) jlong_to_ptr(ret_sizes);
1754 int * pcount = (int *) jlong_to_ptr(ret_count);
1755 Status res;
1756 AWT_CHECK_HAVE_LOCK();
1757 res = XGetIconSizes((Display*) jlong_to_ptr(display), (Window)window, psize, pcount);
1758 return res;
1759 }
1760
1761 JNIEXPORT jint JNICALL Java_sun_awt_X11_XlibWrapper_XdbeQueryExtension
1762 (JNIEnv *env, jclass clazz, jlong display, jlong major_version_return,
1763 jlong minor_version_return)
1764 {
1765 AWT_CHECK_HAVE_LOCK();
1766 return XdbeQueryExtension((Display*) jlong_to_ptr(display), (int *) jlong_to_ptr(major_version_return),
1767 (int *) jlong_to_ptr(minor_version_return));
1768 }
1769
1770 JNIEXPORT jboolean JNICALL Java_sun_awt_X11_XlibWrapper_XQueryExtension
1771 (JNIEnv *env, jclass clazz, jlong display, jstring jstr, jlong mop_return,
1772 jlong feve_return, jlong err_return)
1773 {
1774 char *cname;
1775 Boolean bu;
1776 if (!JNU_IsNull(env, jstr)) {
1777 cname = (char *)JNU_GetStringPlatformChars(env, jstr, NULL);
1778 } else {
1779 cname = "";
1780 }
1781
1782 AWT_CHECK_HAVE_LOCK();
1783 bu = XQueryExtension((Display*) jlong_to_ptr(display), cname, (int *) jlong_to_ptr(mop_return),
1784 (int *) jlong_to_ptr(feve_return), (int *) jlong_to_ptr(err_return));
1785 if (!JNU_IsNull(env, jstr)) {
1786 JNU_ReleaseStringPlatformChars(env, jstr, (const char *) cname);
1787 }
1788 return bu ? JNI_TRUE : JNI_FALSE;
1789 }
1790
1791 JNIEXPORT jboolean JNICALL Java_sun_awt_X11_XlibWrapper_IsKeypadKey
1792 (JNIEnv *env, jclass clazz, jlong keysym)
1793 {
1794 AWT_CHECK_HAVE_LOCK();
1795 if(IsKeypadKey(keysym)) {
1796 return JNI_TRUE;
1797 }
1798 return JNI_FALSE;
1799 }
1800
1801 JNIEXPORT jlong JNICALL Java_sun_awt_X11_XlibWrapper_XdbeAllocateBackBufferName
1802 (JNIEnv *env, jclass clazz, jlong display, jlong window, jint swap_action)
1803 {
1804 AWT_CHECK_HAVE_LOCK();
1805 return XdbeAllocateBackBufferName((Display*) jlong_to_ptr(display), (Window) window,
1806 (XdbeSwapAction) swap_action);
1807 }
1808
1809 JNIEXPORT jint JNICALL Java_sun_awt_X11_XlibWrapper_XdbeDeallocateBackBufferName
1810 (JNIEnv *env, jclass clazz, jlong display, jlong buffer)
1811 {
1812 AWT_CHECK_HAVE_LOCK();
1813 return XdbeDeallocateBackBufferName((Display*) jlong_to_ptr(display), (XdbeBackBuffer) buffer);
1814 }
1815
1816 JNIEXPORT jint JNICALL Java_sun_awt_X11_XlibWrapper_XdbeBeginIdiom
1817 (JNIEnv *env, jclass clazz, jlong display)
1818 {
1819 AWT_CHECK_HAVE_LOCK();
1820 return XdbeBeginIdiom((Display*) jlong_to_ptr(display));
1821 }
1822
1823 JNIEXPORT jint JNICALL Java_sun_awt_X11_XlibWrapper_XdbeEndIdiom
1824 (JNIEnv *env, jclass clazz, jlong display)
1825 {
1826 AWT_CHECK_HAVE_LOCK();
1827 return XdbeEndIdiom((Display*) jlong_to_ptr(display));
1828 }
1829
1830 JNIEXPORT jint JNICALL Java_sun_awt_X11_XlibWrapper_XdbeSwapBuffers
1831 (JNIEnv *env, jclass clazz, jlong display, jlong swap_info, jint num_windows)
1832 {
1833 AWT_CHECK_HAVE_LOCK();
1834 return XdbeSwapBuffers((Display*) jlong_to_ptr(display), (XdbeSwapInfo *) jlong_to_ptr(swap_info), num_windows);
1835 }
1836 JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XQueryKeymap
1837 (JNIEnv *env, jclass clazz, jlong display, jlong vector)
1838 {
1839
1840 AWT_CHECK_HAVE_LOCK();
1841 XQueryKeymap( (Display *) jlong_to_ptr(display), (char *) jlong_to_ptr(vector));
1842 }
1843
1844 JNIEXPORT jlong JNICALL
1845 Java_sun_awt_X11_XlibWrapper_XKeycodeToKeysym(JNIEnv *env, jclass clazz,
1846 jlong display, jint keycode,
1847 jint index) {
1848 AWT_CHECK_HAVE_LOCK();
1849 return XKeycodeToKeysym((Display*) jlong_to_ptr(display), (unsigned int)keycode, (int)index);
1850 }
1851
1852 JNIEXPORT jint JNICALL
1853 Java_sun_awt_X11_XlibWrapper_XkbGetEffectiveGroup(JNIEnv *env, jclass clazz,
1854 jlong display) {
1855 XkbStateRec sr;
1856 AWT_CHECK_HAVE_LOCK();
1857 memset(&sr, 0, sizeof(XkbStateRec));
1858 XkbGetState((Display*) jlong_to_ptr(display), XkbUseCoreKbd, &sr);
1859 // printf("-------------------------------------VVVV\n");
1860 // printf(" group:0x%0X\n",sr.group);
1861 // printf(" base_group:0x%0X\n",sr.base_group);
1862 // printf(" latched_group:0x%0X\n",sr.latched_group);
1863 // printf(" locked_group:0x%0X\n",sr.locked_group);
1864 // printf(" mods:0x%0X\n",sr.mods);
1865 // printf(" base_mods:0x%0X\n",sr.base_mods);
1866 // printf(" latched_mods:0x%0X\n",sr.latched_mods);
1867 // printf(" locked_mods:0x%0X\n",sr.locked_mods);
1868 // printf(" compat_state:0x%0X\n",sr.compat_state);
1869 // printf(" grab_mods:0x%0X\n",sr.grab_mods);
1870 // printf(" compat_grab_mods:0x%0X\n",sr.compat_grab_mods);
1871 // printf(" lookup_mods:0x%0X\n",sr.lookup_mods);
1872 // printf(" compat_lookup_mods:0x%0X\n",sr.compat_lookup_mods);
1873 // printf(" ptr_buttons:0x%0X\n",sr.ptr_buttons);
1874 // printf("-------------------------------------^^^^\n");
1875 return (jint)(sr.group);
1876 }
1877 JNIEXPORT jlong JNICALL
1878 Java_sun_awt_X11_XlibWrapper_XkbKeycodeToKeysym(JNIEnv *env, jclass clazz,
1879 jlong display, jint keycode,
1880 jint group, jint level) {
1881 AWT_CHECK_HAVE_LOCK();
1882 return XkbKeycodeToKeysym((Display*) jlong_to_ptr(display), (unsigned int)keycode, (unsigned int)group, (unsigned int)level);
1883 }
1884
1885 JNIEXPORT jint JNICALL
1886 Java_sun_awt_X11_XlibWrapper_XKeysymToKeycode(JNIEnv *env, jclass clazz,
1887 jlong display, jlong keysym) {
1888 AWT_CHECK_HAVE_LOCK();
1889 return XKeysymToKeycode((Display*) jlong_to_ptr(display), (KeySym)keysym);
1890 }
1891
1892 JNIEXPORT jlong JNICALL
1893 Java_sun_awt_X11_XlibWrapper_XGetModifierMapping(JNIEnv *env, jclass clazz,
1894 jlong display) {
1895 AWT_CHECK_HAVE_LOCK();
1896 return ptr_to_jlong(XGetModifierMapping((Display*) jlong_to_ptr(display)));
1897 }
1898
1899 JNIEXPORT void JNICALL
1900 Java_sun_awt_X11_XlibWrapper_XFreeModifiermap(JNIEnv *env, jclass clazz,
1901 jlong keymap) {
1902 AWT_CHECK_HAVE_LOCK();
1903 XFreeModifiermap((XModifierKeymap*) jlong_to_ptr(keymap));
1904 }
1905 /*
1906 * Class: sun_awt_X11_XlibWrapper
1907 * Method: XRefreshKeyboardMapping
1908 * Signature: (J)V
1909 */
1910 JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XRefreshKeyboardMapping
1911 (JNIEnv *env, jclass clazz, jlong event_ptr)
1912 {
1913 AWT_CHECK_HAVE_LOCK();
1914 XRefreshKeyboardMapping((XMappingEvent*) jlong_to_ptr(event_ptr));
1915 }
1916
1917 JNIEXPORT void JNICALL
1918 Java_sun_awt_X11_XlibWrapper_XChangeActivePointerGrab(JNIEnv *env, jclass clazz,
1919 jlong display, jint mask,
1920 jlong cursor, jlong time) {
1921 AWT_CHECK_HAVE_LOCK();
1922 XChangeActivePointerGrab((Display*)jlong_to_ptr(display), (unsigned int)mask,
1923 (Cursor)cursor, (Time)time);
1924 }
1925
1926 /******************* Secondary loop support ************************************/
1927 #define AWT_SECONDARY_LOOP_TIMEOUT 250
1928
1929 static Bool exitSecondaryLoop = True;
1930
1931 /*
1932 * This predicate procedure allows the Toolkit thread to process specific events
1933 * while it is blocked waiting for the event dispatch thread to process
1934 * a SunDropTargetEvent. We need this to prevent deadlock when the client code
1935 * processing SunDropTargetEvent sets or gets the contents of the system
1936 * clipboard/selection. In this case the event dispatch thread waits for the
1937 * Toolkit thread to process PropertyNotify or SelectionNotify events.
1938 */
1939 static Bool
1940 secondary_loop_event(Display* dpy, XEvent* event, char* arg) {
1941 return (event->type == SelectionNotify ||
1942 event->type == SelectionClear ||
1943 event->type == PropertyNotify) ? True : False;
1944 }
1945
1946
1947 JNIEXPORT jboolean JNICALL
1948 Java_sun_awt_X11_XlibWrapper_XNextSecondaryLoopEvent(JNIEnv *env, jclass clazz,
1949 jlong display, jlong ptr) {
1950 uint32_t timeout = 1;
1951
1952 AWT_CHECK_HAVE_LOCK();
1953 exitSecondaryLoop = False;
1954 while (!exitSecondaryLoop) {
1955 if (XCheckIfEvent((Display*) jlong_to_ptr(display), (XEvent*) jlong_to_ptr(ptr), secondary_loop_event, NULL)) {
1956 return JNI_TRUE;
1957 }
1958 timeout = (timeout < AWT_SECONDARY_LOOP_TIMEOUT) ? (timeout << 1) : AWT_SECONDARY_LOOP_TIMEOUT;
1959 AWT_WAIT(timeout);
1960 }
1961 return JNI_FALSE;
1962 }
1963
1964 JNIEXPORT void JNICALL
1965 Java_sun_awt_X11_XlibWrapper_ExitSecondaryLoop(JNIEnv *env, jclass clazz) {
1966 DASSERT(!exitSecondaryLoop);
1967 AWT_CHECK_HAVE_LOCK();
1968 exitSecondaryLoop = True;
1969 AWT_NOTIFY_ALL();
1970 }
1971 /*******************************************************************************/
1972
1973 JNIEXPORT jobjectArray JNICALL
1974 Java_sun_awt_X11_XlibWrapper_XTextPropertyToStringList(JNIEnv *env,
1975 jclass clazz,
1976 jbyteArray bytes,
1977 jlong encodingAtom) {
1978 XTextProperty tp;
1979 jbyte *value;
1980
1981 char** strings = (char **)NULL;
1982 int32_t nstrings = 0;
1983 jobjectArray ret = NULL;
1984 int32_t i;
1985 jsize len;
1986 jboolean isCopy = JNI_FALSE;
1987 static jclass stringClass = NULL;
1988 jclass stringClassLocal = NULL;
1989
1990 AWT_CHECK_HAVE_LOCK();
1991
1992 if (JNU_IsNull(env, stringClass)) {
1993 stringClassLocal = (*env)->FindClass(env, "java/lang/String");
1994
1995 if ((*env)->ExceptionCheck(env)) {
1996 (*env)->ExceptionDescribe(env);
1997 (*env)->ExceptionClear(env);
1998 DASSERT(False);
1999 }
2000
2001 if (JNU_IsNull(env, stringClassLocal)) {
2002 return NULL;
2003 }
2004
2005 stringClass = (*env)->NewGlobalRef(env, stringClassLocal); /* never freed! */
2006 (*env)->DeleteLocalRef(env, stringClassLocal);
2007
2008 if (JNU_IsNull(env, stringClass)) {
2009 JNU_ThrowOutOfMemoryError(env, "");
2010 return NULL;
2011 }
2012 }
2013
2014 /*
2015 * If the length of the byte array is 0 just return a null
2016 */
2017 len = (*env)->GetArrayLength(env, bytes);
2018 if (len == 0) {
2019 return (*env)->NewObjectArray(env, 0, stringClass, NULL);
2020 }
2021
2022 value = (*env)->GetByteArrayElements(env, bytes, &isCopy);
2023 if (JNU_IsNull(env, value)) {
2024 return NULL;
2025 }
2026
2027 tp.encoding = encodingAtom;
2028 tp.value = (unsigned char *)value;
2029 tp.nitems = len;
2030 tp.format = 8;
2031
2032 /*
2033 * Convert the byte stream into a list of X11 strings
2034 */
2035 if (XTextPropertyToStringList(&tp, &strings, &nstrings) == 0) {
2036 (*env)->ReleaseByteArrayElements(env, bytes, value, JNI_ABORT);
2037 return NULL;
2038 }
2039
2040 (*env)->ReleaseByteArrayElements(env, bytes, value, JNI_ABORT);
2041
2042 if (nstrings == 0) {
2043 return (*env)->NewObjectArray(env, 0, stringClass, NULL);
2044 }
2045
2046 ret = (*env)->NewObjectArray(env, nstrings, stringClass, NULL);
2047
2048 if ((*env)->ExceptionCheck(env)) {
2049 (*env)->ExceptionDescribe(env);
2050 (*env)->ExceptionClear(env);
2051 goto wayout;
2052 }
2053
2054 if (JNU_IsNull(env, ret)) {
2055 goto wayout;
2056 }
2057
2058 for (i = 0; i < nstrings; i++) {
2059 jstring string = (*env)->NewStringUTF(env,
2060 (const char *)strings[i]);
2061 if ((*env)->ExceptionCheck(env)) {
2062 (*env)->ExceptionDescribe(env);
2063 (*env)->ExceptionClear(env);
2064 goto wayout;
2065 }
2066
2067 if (JNU_IsNull(env, string)) {
2068 goto wayout;
2069 }
2070
2071 (*env)->SetObjectArrayElement(env, ret, i, string);
2072
2073 if ((*env)->ExceptionCheck(env)) {
2074 (*env)->ExceptionDescribe(env);
2075 (*env)->ExceptionClear(env);
2076 goto wayout;
2077 }
2078
2079 (*env)->DeleteLocalRef(env, string);
2080 }
2081
2082 wayout:
2083 /*
2084 * Clean up and return
2085 */
2086 XFreeStringList(strings);
2087 return ret;
2088 }
2089
2090
2091 JNIEXPORT void JNICALL
2092 Java_sun_awt_X11_XlibWrapper_XPutBackEvent(JNIEnv *env,
2093 jclass clazz,
2094 jlong display,
2095 jlong event) {
2096 XPutBackEvent((Display*)jlong_to_ptr(display), (XEvent*) jlong_to_ptr(event));
2097 }
2098
2099 JNIEXPORT jlong JNICALL
2100 Java_sun_awt_X11_XlibWrapper_getAddress(JNIEnv *env,
2101 jclass clazz,
2102 jobject o) {
2103 return ptr_to_jlong(o);
2104 }
2105
2106 JNIEXPORT void JNICALL
2107 Java_sun_awt_X11_XlibWrapper_copyIntArray(JNIEnv *env,
2108 jclass clazz,
2109 jlong dest, jobject array, jint size) {
2110 jboolean isCopy = JNI_FALSE;
2111 jint * ints = (*env)->GetIntArrayElements(env, array, &isCopy);
2112 memcpy(jlong_to_ptr(dest), ints, size);
2113 if (isCopy) {
2114 (*env)->ReleaseIntArrayElements(env, array, ints, JNI_ABORT);
2115 }
2116 }
2117
2118 JNIEXPORT void JNICALL
2119 Java_sun_awt_X11_XlibWrapper_copyLongArray(JNIEnv *env,
2120 jclass clazz,
2121 jlong dest, jobject array, jint size) {
2122 jboolean isCopy = JNI_FALSE;
2123 jlong * longs = (*env)->GetLongArrayElements(env, array, &isCopy);
2124 memcpy(jlong_to_ptr(dest), longs, size);
2125 if (isCopy) {
2126 (*env)->ReleaseLongArrayElements(env, array, longs, JNI_ABORT);
2127 }
2128 }
2129
2130 JNIEXPORT jint JNICALL
2131 Java_sun_awt_X11_XlibWrapper_XSynchronize(JNIEnv *env, jclass clazz, jlong display, jboolean onoff)
2132 {
2133 return (jint) XSynchronize((Display*)jlong_to_ptr(display), (onoff == JNI_TRUE ? True : False));
2134 }
2135
2136 JNIEXPORT jboolean JNICALL
2137 Java_sun_awt_X11_XlibWrapper_XShapeQueryExtension
2138 (JNIEnv *env, jclass clazz, jlong display, jlong event_base_return, jlong error_base_return)
2139 {
2140 jboolean status;
2141
2142 AWT_CHECK_HAVE_LOCK();
2143
2144 status = XShapeQueryExtension((Display *)jlong_to_ptr(display),
2145 (int *)jlong_to_ptr(event_base_return), (int *)jlong_to_ptr(error_base_return));
2146 return status;
2147 }
2148
2149 /*
2150 * Class: XlibWrapper
2151 * Method: SetRectangularShape
2152 */
2153
2154 JNIEXPORT void JNICALL
2155 Java_sun_awt_X11_XlibWrapper_SetRectangularShape
2156 (JNIEnv *env, jclass clazz, jlong display, jlong window,
2157 jint x1, jint y1, jint x2, jint y2,
2158 jobject region)
2159 {
2160 AWT_CHECK_HAVE_LOCK();
2161
2162 // If all the params are zeros, the shape must be simply reset.
2163 // Otherwise, the shape may be not rectangular.
2164 if (region || x1 || x2 || y1 || y2) {
2165 XRectangle rects[256];
2166 XRectangle *pRect = rects;
2167
2168 int numrects = RegionToYXBandedRectangles(env, x1, y1, x2, y2, region,
2169 &pRect, 256);
2170
2171 XShapeCombineRectangles((Display *)jlong_to_ptr(display), (Window)jlong_to_ptr(window),
2172 ShapeClip, 0, 0, pRect, numrects, ShapeSet, YXBanded);
2173 XShapeCombineRectangles((Display *)jlong_to_ptr(display), (Window)jlong_to_ptr(window),
2174 ShapeBounding, 0, 0, pRect, numrects, ShapeSet, YXBanded);
2175
2176 if (pRect != rects) {
2177 free(pRect);
2178 }
2179 } else {
2180 // Reset the shape to a rectangular form.
2181 XShapeCombineMask((Display *)jlong_to_ptr(display), (Window)jlong_to_ptr(window),
2182 ShapeClip, 0, 0, None, ShapeSet);
2183 XShapeCombineMask((Display *)jlong_to_ptr(display), (Window)jlong_to_ptr(window),
2184 ShapeBounding, 0, 0, None, ShapeSet);
2185 }
2186 }
2187
2188 /*
2189 * Class: XlibWrapper
2190 * Method: SetZOrder
2191 */
2192
2193 JNIEXPORT void JNICALL
2194 Java_sun_awt_X11_XlibWrapper_SetZOrder
2195 (JNIEnv *env, jclass clazz, jlong display, jlong window, jlong above)
2196 {
2197 unsigned int value_mask = CWStackMode;
2198
2199 XWindowChanges wc;
2200 wc.sibling = (Window)jlong_to_ptr(above);
2201
2202 AWT_CHECK_HAVE_LOCK();
2203
2204 if (above == 0) {
2205 wc.stack_mode = Above;
2206 } else {
2207 wc.stack_mode = Below;
2208 value_mask |= CWSibling;
2209 }
2210
2211 XConfigureWindow((Display *)jlong_to_ptr(display),
2212 (Window)jlong_to_ptr(window),
2213 value_mask, &wc );
2214 }
2215
2216 /*
2217 * Class: XlibWrapper
2218 * Method: SetBitmapShape
2219 */
2220 JNIEXPORT void JNICALL
2221 Java_sun_awt_X11_XlibWrapper_SetBitmapShape
2222 (JNIEnv *env, jclass clazz, jlong display, jlong window,
2223 jint width, jint height, jintArray bitmap)
2224 {
2225 jsize len;
2226 jint *values;
2227 jboolean isCopy = JNI_FALSE;
2228 size_t worstBufferSize = (size_t)((width / 2 + 1) * height);
2229 RECT_T * pRect;
2230 int numrects;
2231
2232 if (!IS_SAFE_SIZE_MUL(width / 2 + 1, height)) {
2233 return;
2234 }
2235
2236 AWT_CHECK_HAVE_LOCK();
2237
2238 len = (*env)->GetArrayLength(env, bitmap);
2239 if (len == 0 || len < width * height) {
2240 return;
2241 }
2242
2243 values = (*env)->GetIntArrayElements(env, bitmap, &isCopy);
2244 if (JNU_IsNull(env, values)) {
2245 return;
2246 }
2247
2248 pRect = (RECT_T *)SAFE_SIZE_ARRAY_ALLOC(malloc, worstBufferSize, sizeof(RECT_T));
2249 if (!pRect) {
2250 return;
2251 }
2252
2253 /* Note: the values[0] and values[1] are supposed to contain the width
2254 * and height (see XIconInfo.getIntData() for details). So, we do +2.
2255 */
2256 numrects = BitmapToYXBandedRectangles(32, (int)width, (int)height,
2257 (unsigned char *)(values + 2), pRect);
2258
2259 XShapeCombineRectangles((Display *)jlong_to_ptr(display), (Window)jlong_to_ptr(window),
2260 ShapeClip, 0, 0, pRect, numrects, ShapeSet, YXBanded);
2261 XShapeCombineRectangles((Display *)jlong_to_ptr(display), (Window)jlong_to_ptr(window),
2262 ShapeBounding, 0, 0, pRect, numrects, ShapeSet, YXBanded);
2263
2264 free(pRect);
2265
2266 (*env)->ReleaseIntArrayElements(env, bitmap, values, JNI_ABORT);
2267 }
2268