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