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