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