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