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