CoCalc -- XlibWrapper.c

GitHub Repository: PojavLauncherTeam/openjdk-multiarch-jdk8u
Path: blob/aarch64-shenandoah-jdk8u272-b10/jdk/src/solaris/native/sun/xawt/XlibWrapper.c
³²²⁸⁷ views
1
/*
2
 * Copyright (c) 2002, 2014, Oracle and/or its affiliates. All rights reserved.
3
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4
 *
5
 * This code is free software; you can redistribute it and/or modify it
6
 * under the terms of the GNU General Public License version 2 only, as
7
 * published by the Free Software Foundation.  Oracle designates this
8
 * particular file as subject to the "Classpath" exception as provided
9
 * by Oracle in the LICENSE file that accompanied this code.
10
 *
11
 * This code is distributed in the hope that it will be useful, but WITHOUT
12
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
14
 * version 2 for more details (a copy is included in the LICENSE file that
15
 * accompanied this code).
16
 *
17
 * You should have received a copy of the GNU General Public License version
18
 * 2 along with this work; if not, write to the Free Software Foundation,
19
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20
 *
21
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22
 * or visit www.oracle.com if you need additional information or have any
23
 * questions.
24
 */
25

26
#include "sun_awt_X11_XlibWrapper.h"
27
#include <X11/Xlib.h>
28
#include <X11/keysym.h>
29
#include <X11/Xutil.h>
30
#include <X11/Xos.h>
31
#include <X11/Xatom.h>
32
#include <X11/extensions/Xdbe.h>
33
#include <X11/extensions/shape.h>
34
#include <string.h>
35
#include <stdlib.h>
36
#include <X11/Sunkeysym.h>
37

38
#include <jni.h>
39
#include <jni_util.h>
40
#include <jlong.h>
41
#include <sizecalc.h>
42

43
#include <awt.h>
44
#include <awt_util.h>
45
#include <jvm.h>
46

47
#include <Region.h>
48
#include "utility/rect.h"
49

50
#include <X11/XKBlib.h>
51

52
#if defined(DEBUG) || defined(INTERNAL_BUILD)
53
static jmethodID lockIsHeldMID = NULL;
54

55
static void
56
CheckHaveAWTLock(JNIEnv *env)
57
{
58
    if (lockIsHeldMID == NULL) {
59
        if (tkClass == NULL) return;
60
        lockIsHeldMID =
61
            (*env)->GetStaticMethodID(env, tkClass,
62
                                      "isAWTLockHeldByCurrentThread", "()Z");
63
        if (lockIsHeldMID == NULL) return;
64
    }
65
    if (!(*env)->CallStaticBooleanMethod(env, tkClass, lockIsHeldMID)) {
66
        JNU_ThrowInternalError(env, "Current thread does not hold AWT_LOCK!");
67
    }
68
}
69

70
#define AWT_CHECK_HAVE_LOCK()                       \
71
    do {                                            \
72
        CheckHaveAWTLock(env);                      \
73
        if ((*env)->ExceptionCheck(env)) {          \
74
            return;                                 \
75
        }                                           \
76
    } while (0);                                    \
77

78
#define AWT_CHECK_HAVE_LOCK_RETURN(ret)             \
79
    do {                                            \
80
        CheckHaveAWTLock(env);                      \
81
        if ((*env)->ExceptionCheck(env)) {          \
82
            return (ret);                           \
83
        }                                           \
84
    } while (0);                                    \
85

86
#else
87
#define AWT_CHECK_HAVE_LOCK()
88
#define AWT_CHECK_HAVE_LOCK_RETURN(ret)
89
#endif
90

91
void freeNativeStringArray(char **array, jsize length) {
92
    int i;
93
    if (array == NULL) {
94
        return;
95
    }
96
    for (i = 0; i < length; i++) {
97
        free(array[i]);
98
    }
99
    free(array);
100
}
101

102
char** stringArrayToNative(JNIEnv *env, jobjectArray array, jsize * ret_length) {
103
    Bool err = FALSE;
104
    char ** strings;
105
    int index, str_index = 0;
106
    jsize length = (*env)->GetArrayLength(env, array);
107

108
    if (length == 0) {
109
        return NULL;
110
    }
111

112
    strings = (char**) calloc(length, sizeof (char*));
113

114
    if (strings == NULL) {
115
        JNU_ThrowOutOfMemoryError(env, "");
116
        return NULL;
117
    }
118

119
    for (index = 0; index < length; index++) {
120
        jstring str = (*env)->GetObjectArrayElement(env, array, index);
121
        if (str != NULL) {
122
            const char * str_char = JNU_GetStringPlatformChars(env, str, NULL);
123
            if (str_char != NULL) {
124
                char * dup_str = strdup(str_char);
125
                if (dup_str != NULL) {
126
                    strings[str_index++] = dup_str;
127
                } else {
128
                    JNU_ThrowOutOfMemoryError(env, "");
129
                    err = TRUE;
130
                }
131
                JNU_ReleaseStringPlatformChars(env, str, str_char);
132
            } else {
133
                err = TRUE;
134
            }
135
            (*env)->DeleteLocalRef(env, str);
136
            if (err) {
137
                break;
138
            }
139
        }
140
    }
141

142
    if (err) {
143
        freeNativeStringArray(strings, str_index);
144
        strings = NULL;
145
        str_index = -1;
146
    }
147
    *ret_length = str_index;
148

149
    return strings;
150
}
151

152
/*
153
 * Class:     XlibWrapper
154
 * Method:    XOpenDisplay
155
 * Signature: (J)J
156
 */
157

158
JNIEXPORT jlong JNICALL Java_sun_awt_X11_XlibWrapper_XOpenDisplay
159
(JNIEnv *env, jclass clazz, jlong display_name)
160
{
161
    Display *dp;
162
    AWT_CHECK_HAVE_LOCK_RETURN(0);
163
    dp  =  XOpenDisplay((char *) jlong_to_ptr(display_name));
164

165
    return ptr_to_jlong(dp);
166
}
167

168
JNIEXPORT void JNICALL
169
Java_sun_awt_X11_XlibWrapper_XCloseDisplay(JNIEnv *env, jclass clazz,
170
                       jlong display) {
171
    AWT_CHECK_HAVE_LOCK();
172
    XCloseDisplay((Display*) jlong_to_ptr(display));
173
}
174

175
JNIEXPORT jlong JNICALL
176
Java_sun_awt_X11_XlibWrapper_XDisplayString(JNIEnv *env, jclass clazz,
177
                        jlong display) {
178
    AWT_CHECK_HAVE_LOCK_RETURN(0);
179
    return ptr_to_jlong(XDisplayString((Display*) jlong_to_ptr(display)));
180
}
181

182
JNIEXPORT void JNICALL
183
Java_sun_awt_X11_XlibWrapper_XSetCloseDownMode(JNIEnv *env, jclass clazz,
184
                           jlong display, jint mode) {
185
    AWT_CHECK_HAVE_LOCK();
186
    XSetCloseDownMode((Display*) jlong_to_ptr(display), (int)mode);
187
}
188

189
/*
190
 * Class:     sun_awt_X11_XlibWrapper
191
 * Method:    DefaultScreen
192
 * Signature: (J)J
193
 */
194
JNIEXPORT jlong JNICALL Java_sun_awt_X11_XlibWrapper_DefaultScreen (JNIEnv *env, jclass clazz, jlong display) {
195

196
    AWT_CHECK_HAVE_LOCK_RETURN(0);
197
    return (jlong) DefaultScreen((Display *) jlong_to_ptr(display));
198
}
199

200
/*
201
 * Class:     sun_awt_X11_XlibWrapper
202
 * Method:    ScreenOfDisplay
203
 * Signature: (JJ)J
204
 */
205
JNIEXPORT jlong JNICALL Java_sun_awt_X11_XlibWrapper_ScreenOfDisplay(JNIEnv *env, jclass clazz, jlong display, jlong screen_number) {
206
    AWT_CHECK_HAVE_LOCK_RETURN(0);
207
    return ptr_to_jlong(ScreenOfDisplay((Display *) jlong_to_ptr(display),
208
                                        screen_number));
209
}
210

211
/*
212
 * Class:     sun_awt_X11_XlibWrapper
213
 * Method:    DoesBackingStore
214
 * Signature: (J)I
215
 */
216
JNIEXPORT jint JNICALL Java_sun_awt_X11_XlibWrapper_DoesBackingStore(JNIEnv *env, jclass clazz, jlong screen) {
217
    AWT_CHECK_HAVE_LOCK_RETURN(0);
218
    return (jint) DoesBackingStore((Screen*) jlong_to_ptr(screen));
219
}
220

221
/*
222
 * Class:     sun_awt_X11_XlibWrapper
223
 * Method:    DisplayWidth
224
 * Signature: (JJ)J
225
 */
226
JNIEXPORT jlong JNICALL Java_sun_awt_X11_XlibWrapper_DisplayWidth
227
(JNIEnv *env, jclass clazz, jlong display, jlong screen) {
228

229
    AWT_CHECK_HAVE_LOCK_RETURN(0);
230
    return (jlong) DisplayWidth((Display *) jlong_to_ptr(display),screen);
231

232
}
233

234
/*
235
 * Class:     sun_awt_X11_XlibWrapper
236
 * Method:    DisplayWidthMM
237
 * Signature: (JJ)J
238
 */
239
JNIEXPORT jlong JNICALL Java_sun_awt_X11_XlibWrapper_DisplayWidthMM
240
(JNIEnv *env, jclass clazz, jlong display, jlong screen) {
241
    AWT_CHECK_HAVE_LOCK_RETURN(0);
242
    return (jlong) DisplayWidthMM((Display *) jlong_to_ptr(display),screen);
243
}
244

245
/*
246
 * Class:     sun_awt_X11_XlibWrapper
247
 * Method:    DisplayHeight
248
 * Signature: (JJ)J
249
 */
250
JNIEXPORT jlong JNICALL Java_sun_awt_X11_XlibWrapper_DisplayHeight
251
(JNIEnv *env, jclass clazz, jlong display, jlong screen) {
252

253
    AWT_CHECK_HAVE_LOCK_RETURN(0);
254
    return (jlong) DisplayHeight((Display *) jlong_to_ptr(display),screen);
255
}
256
/*
257
 * Class:     sun_awt_X11_XlibWrapper
258
 * Method:    DisplayHeightMM
259
 * Signature: (JJ)J
260
 */
261
JNIEXPORT jlong JNICALL Java_sun_awt_X11_XlibWrapper_DisplayHeightMM
262
(JNIEnv *env, jclass clazz, jlong display, jlong screen) {
263
    AWT_CHECK_HAVE_LOCK_RETURN(0);
264
    return (jlong) DisplayHeightMM((Display *) jlong_to_ptr(display),screen);
265
}
266

267
/*
268
 * Class:     sun_awt_X11_XlibWrapper
269
 * Method:    RootWindow
270
 * Signature: (JJ)J
271
 */
272
JNIEXPORT jlong JNICALL Java_sun_awt_X11_XlibWrapper_RootWindow
273
(JNIEnv *env , jclass clazz, jlong display, jlong screen_number) {
274
    AWT_CHECK_HAVE_LOCK_RETURN(0);
275
    return (jlong) RootWindow((Display *) jlong_to_ptr(display), screen_number);
276
}
277

278
/*
279
 * Class:     sun_awt_X11_XlibWrapper
280
 * Method:    ScreenCount
281
 */
282
JNIEXPORT jint JNICALL Java_sun_awt_X11_XlibWrapper_ScreenCount
283
(JNIEnv *env , jclass clazz, jlong display) {
284
    AWT_CHECK_HAVE_LOCK_RETURN(0);
285
    return ScreenCount((Display *) jlong_to_ptr(display));
286
}
287

288

289
/*
290
 * Class:     XlibWrapper
291
 * Method:    XCreateWindow
292
 * Signature: (JJIIIIIIJJJJ)J
293
 */
294
JNIEXPORT jlong JNICALL Java_sun_awt_X11_XlibWrapper_XCreateWindow
295
  (JNIEnv *env, jclass clazz, jlong display, jlong window,
296
   jint x, jint y, jint w, jint h , jint border_width, jint depth,
297
   jlong wclass, jlong visual, jlong valuemask, jlong attributes)
298
{
299
    AWT_CHECK_HAVE_LOCK_RETURN(0);
300
    return  XCreateWindow((Display *) jlong_to_ptr(display),(Window) window, x, y, w, h,
301
              border_width, depth, wclass, (Visual *) jlong_to_ptr(visual),
302
              valuemask, (XSetWindowAttributes *) jlong_to_ptr(attributes));
303

304
}
305

306
/*
307
 * Class:     XlibWrapper
308
 * Method:    XConvertCase
309
 * Signature: (JJJ)V
310
 */
311
JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XConvertCase
312
  (JNIEnv *env, jclass clazz, jlong keysym,
313
   jlong keysym_lowercase, jlong keysym_uppercase)
314
{
315
    AWT_CHECK_HAVE_LOCK();
316
    XConvertCase(keysym, (jlong_to_ptr(keysym_lowercase)),
317
                         (jlong_to_ptr(keysym_uppercase)));
318
}
319

320

321
/*
322
 * Class:     XlibWrapper
323
 * Method:    XMapWindow
324
 * Signature: (JJ)V
325
 */
326
JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XMapWindow
327
(JNIEnv *env, jclass clazz, jlong display, jlong window)
328
{
329
    AWT_CHECK_HAVE_LOCK();
330
    XMapWindow( (Display *)jlong_to_ptr(display),(Window) window);
331

332
}
333

334
/*
335
 * Class:     XlibWrapper
336
 * Method:    XMapRaised
337
 * Signature: (JJ)V
338
 */
339
JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XMapRaised
340
(JNIEnv *env, jclass clazz, jlong display, jlong window)
341
{
342
    AWT_CHECK_HAVE_LOCK();
343
    XMapRaised( (Display *)jlong_to_ptr(display),(Window) window);
344

345
}
346

347
/*
348
 * Class:     XlibWrapper
349
 * Method:    XRaiseWindow
350
 * Signature: (JJ)V
351
 */
352
JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XRaiseWindow
353
(JNIEnv *env, jclass clazz, jlong display, jlong window)
354
{
355

356
    AWT_CHECK_HAVE_LOCK();
357
    XRaiseWindow( (Display *)jlong_to_ptr(display),(Window) window);
358

359
}
360

361
/*
362
 * Class:     XlibWrapper
363
 * Method:    XLowerWindow
364
 * Signature: (JJ)V
365
 */
366
JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XLowerWindow
367
(JNIEnv *env, jclass clazz, jlong display, jlong window)
368
{
369

370
    AWT_CHECK_HAVE_LOCK();
371
    XLowerWindow( (Display *)jlong_to_ptr(display),(Window) window);
372

373
}
374

375
/*
376
 * Class:     XlibWrapper
377
 * Method:    XRestackWindows
378
 * Signature: (JJI)V
379
 */
380
JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XRestackWindows
381
(JNIEnv *env, jclass clazz, jlong display, jlong windows, jint length)
382
{
383

384
    AWT_CHECK_HAVE_LOCK();
385
    XRestackWindows( (Display *) jlong_to_ptr(display), (Window *) jlong_to_ptr(windows), length);
386

387
}
388

389
/*
390
 * Class:     XlibWrapper
391
 * Method:    XConfigureWindow
392
 * Signature: (JJJJ)V
393
 */
394
JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XConfigureWindow
395
(JNIEnv *env, jclass clazz, jlong display, jlong window, jlong value_mask,
396
 jlong values)
397
{
398
    AWT_CHECK_HAVE_LOCK();
399
    XConfigureWindow((Display*)jlong_to_ptr(display), (Window)window,
400
            (unsigned int)value_mask, (XWindowChanges*)jlong_to_ptr(values));
401
}
402

403
/*
404
 * Class:     XlibWrapper
405
 * Method:    XSetInputFocus
406
 * Signature: (JJ)V
407
 */
408
JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XSetInputFocus
409
(JNIEnv *env, jclass clazz, jlong display, jlong window)
410
{
411

412
    AWT_CHECK_HAVE_LOCK();
413
    XSetInputFocus( (Display *)jlong_to_ptr(display),(Window) window, RevertToPointerRoot, CurrentTime);
414

415
}
416
/*
417
 * Class:     XlibWrapper
418
 * Method:    XSetInputFocus2
419
 * Signature: (JJJ)V
420
 */
421
JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XSetInputFocus2
422
(JNIEnv *env, jclass clazz, jlong display, jlong window, jlong time)
423
{
424

425
    AWT_CHECK_HAVE_LOCK();
426
    XSetInputFocus( (Display *)jlong_to_ptr(display),(Window) window, RevertToPointerRoot, time);
427

428
}
429

430
/*
431
 * Class:     XlibWrapper
432
 * Method:    XGetInputFocus
433
 * Signature: (JJ)V
434
 */
435
JNIEXPORT jlong JNICALL Java_sun_awt_X11_XlibWrapper_XGetInputFocus
436
(JNIEnv *env, jclass clazz, jlong display)
437
{
438

439
    Window focusOwner;
440
    int revert_to;
441
    AWT_CHECK_HAVE_LOCK_RETURN(0);
442
    XGetInputFocus( (Display *)jlong_to_ptr(display), &focusOwner, &revert_to);
443
    return focusOwner;
444
}
445

446

447
/*
448
 * Class:     XlibWrapper
449
 * Method:    XDestroyWindow
450
 * Signature: (JJ)V
451
 */
452
JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XDestroyWindow
453
(JNIEnv *env, jclass clazz, jlong display, jlong window)
454
{
455
    AWT_CHECK_HAVE_LOCK();
456
    XDestroyWindow( (Display *)jlong_to_ptr(display),(Window) window);
457
}
458

459
JNIEXPORT jint JNICALL Java_sun_awt_X11_XlibWrapper_XGrabPointer
460
(JNIEnv *env, jclass clazz, jlong display, jlong window,
461
 jint owner_events, jint event_mask, jint pointer_mode,
462
 jint keyboard_mode, jlong confine_to, jlong cursor, jlong time)
463
{
464
    AWT_CHECK_HAVE_LOCK_RETURN(0);
465
    return XGrabPointer( (Display *)jlong_to_ptr(display), (Window) window,
466
             (Bool) owner_events, (unsigned int) event_mask, (int) pointer_mode,
467
             (int) keyboard_mode, (Window) confine_to, (Cursor) cursor, (Time) time);
468
}
469

470
JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XUngrabPointer
471
(JNIEnv *env, jclass clazz, jlong display, jlong time)
472
{
473
    AWT_CHECK_HAVE_LOCK();
474
    XUngrabPointer( (Display *)jlong_to_ptr(display), (Time) time);
475
}
476

477
JNIEXPORT jint JNICALL Java_sun_awt_X11_XlibWrapper_XGrabKeyboard
478
(JNIEnv *env, jclass clazz, jlong display, jlong window,
479
 jint owner_events, jint pointer_mode,
480
 jint keyboard_mode, jlong time)
481
{
482
    AWT_CHECK_HAVE_LOCK_RETURN(0);
483
    return XGrabKeyboard( (Display *)jlong_to_ptr(display), (Window) window,
484
              (Bool) owner_events, (int) pointer_mode,
485
              (int) keyboard_mode, (Time) time);
486
}
487

488
JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XUngrabKeyboard
489
(JNIEnv *env, jclass clazz, jlong display, jlong time)
490
{
491
    AWT_CHECK_HAVE_LOCK();
492
    XUngrabKeyboard( (Display *)jlong_to_ptr(display), (Time) time);
493
}
494

495
JNIEXPORT void JNICALL
496
Java_sun_awt_X11_XlibWrapper_XGrabServer(JNIEnv *env, jclass clazz,
497
                                         jlong display) {
498
     AWT_CHECK_HAVE_LOCK();
499
     XGrabServer((Display*)jlong_to_ptr(display));
500
}
501

502
JNIEXPORT void JNICALL
503
Java_sun_awt_X11_XlibWrapper_XUngrabServer(JNIEnv *env, jclass clazz,
504
                                           jlong display) {
505
     AWT_CHECK_HAVE_LOCK();
506
     XUngrabServer((Display*)jlong_to_ptr(display));
507
     /* Workaround for bug 5039226 */
508
     XSync((Display*)jlong_to_ptr(display), False);
509
}
510

511
/*
512
 * Class:     XlibWrapper
513
 * Method:    XUnmapWindow
514
 * Signature: (JJ)V
515
 */
516
JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XUnmapWindow
517
(JNIEnv *env, jclass clazz, jlong display, jlong window)
518
{
519

520
    AWT_CHECK_HAVE_LOCK();
521
    XUnmapWindow( (Display *)jlong_to_ptr(display),(Window) window);
522

523
}
524

525

526

527
JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XSelectInput
528
(JNIEnv *env, jclass clazz, jlong display, jlong window, jlong mask)
529
{
530
    AWT_CHECK_HAVE_LOCK();
531
    XSelectInput((Display *) jlong_to_ptr(display), (Window) window, mask);
532
}
533

534
JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XkbSelectEvents
535
(JNIEnv *env, jclass clazz, jlong display, jlong device, jlong bits_to_change, jlong values_for_bits)
536
{
537
    AWT_CHECK_HAVE_LOCK();
538
    XkbSelectEvents((Display *) jlong_to_ptr(display), (unsigned int)device,
539
                   (unsigned long)bits_to_change,
540
                   (unsigned long)values_for_bits);
541
}
542
JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XkbSelectEventDetails
543
(JNIEnv *env, jclass clazz, jlong display, jlong device, jlong event_type, jlong bits_to_change, jlong values_for_bits)
544
{
545
    AWT_CHECK_HAVE_LOCK();
546
    XkbSelectEventDetails((Display *) jlong_to_ptr(display), (unsigned int)device,
547
                   (unsigned int) event_type,
548
                   (unsigned long)bits_to_change,
549
                   (unsigned long)values_for_bits);
550
}
551
JNIEXPORT jboolean JNICALL Java_sun_awt_X11_XlibWrapper_XkbQueryExtension
552
(JNIEnv *env, jclass clazz, jlong display, jlong opcode_rtrn, jlong event_rtrn,
553
              jlong error_rtrn, jlong major_in_out, jlong minor_in_out)
554
{
555
    AWT_CHECK_HAVE_LOCK_RETURN(JNI_FALSE);
556
    return XkbQueryExtension( (Display *) jlong_to_ptr(display),
557
                       (int *) jlong_to_ptr(opcode_rtrn),
558
                       (int *) jlong_to_ptr(event_rtrn),
559
                       (int *) jlong_to_ptr(error_rtrn),
560
                       (int *) jlong_to_ptr(major_in_out),
561
                       (int *) jlong_to_ptr(minor_in_out));
562
}
563
JNIEXPORT jboolean JNICALL Java_sun_awt_X11_XlibWrapper_XkbLibraryVersion
564
(JNIEnv *env, jclass clazz, jlong lib_major_in_out, jlong lib_minor_in_out)
565
{
566
    AWT_CHECK_HAVE_LOCK_RETURN(JNI_FALSE);
567
    *((int *)jlong_to_ptr(lib_major_in_out)) =  XkbMajorVersion;
568
    *((int *)jlong_to_ptr(lib_minor_in_out)) =  XkbMinorVersion;
569
    return  XkbLibraryVersion((int *)jlong_to_ptr(lib_major_in_out), (int *)jlong_to_ptr(lib_minor_in_out));
570
}
571

572
JNIEXPORT jlong JNICALL Java_sun_awt_X11_XlibWrapper_XkbGetMap
573
(JNIEnv *env, jclass clazz, jlong display, jlong which, jlong device_spec)
574
{
575
    AWT_CHECK_HAVE_LOCK_RETURN(0);
576
    return (jlong) XkbGetMap( (Display *) jlong_to_ptr(display),
577
                              (unsigned int) which,
578
                              (unsigned int) device_spec);
579
}
580
JNIEXPORT jlong JNICALL Java_sun_awt_X11_XlibWrapper_XkbGetUpdatedMap
581
(JNIEnv *env, jclass clazz, jlong display, jlong which, jlong xkb)
582
{
583
    AWT_CHECK_HAVE_LOCK_RETURN(0);
584
    return (jlong) XkbGetUpdatedMap( (Display *) jlong_to_ptr(display),
585
                              (unsigned int) which,
586
                              (XkbDescPtr) jlong_to_ptr(xkb));
587
}
588
JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XkbFreeKeyboard
589
(JNIEnv *env, jclass clazz, jlong xkb, jlong which, jboolean free_all)
590
{
591
    AWT_CHECK_HAVE_LOCK();
592
    XkbFreeKeyboard(jlong_to_ptr(xkb), (unsigned int)which, free_all);
593
}
594
JNIEXPORT jboolean JNICALL Java_sun_awt_X11_XlibWrapper_XkbTranslateKeyCode
595
(JNIEnv *env, jclass clazz, jlong xkb, jint keycode, jlong mods, jlong mods_rtrn, jlong keysym_rtrn)
596
{
597
    AWT_CHECK_HAVE_LOCK_RETURN(JNI_FALSE);
598
    Bool b;
599
    b = XkbTranslateKeyCode((XkbDescPtr)xkb, (unsigned int)keycode, (unsigned int)mods,
600
                              (unsigned int *)jlong_to_ptr(mods_rtrn),
601
                               (KeySym *)jlong_to_ptr(keysym_rtrn));
602
    //printf("native,  input: keycode:0x%0X; mods:0x%0X\n", keycode, mods);
603
    //printf("native, output:  keysym:0x%0X; mods:0x%0X\n", *(unsigned int *)jlong_to_ptr(keysym_rtrn), *(unsigned int *)jlong_to_ptr(mods_rtrn));
604
    return b;
605
}
606
JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XkbSetDetectableAutoRepeat
607
(JNIEnv *env, jclass clazz, jlong display, jboolean detectable)
608
{
609
    AWT_CHECK_HAVE_LOCK();
610
    XkbSetDetectableAutoRepeat((Display *) jlong_to_ptr(display), detectable, NULL);
611
}
612
/*
613
 * Class:     sun_awt_X11_XlibWrapper
614
 * Method:    XNextEvent
615
 * Signature: (JJ)V
616
 */
617

618

619
JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XNextEvent
620
(JNIEnv *env, jclass clazz, jlong display, jlong ptr)
621
{
622
    AWT_CHECK_HAVE_LOCK();
623
    XNextEvent( (Display *) jlong_to_ptr(display), jlong_to_ptr(ptr));
624
}
625

626
/*
627
 * Class:     sun_awt_X11_XlibWrapper
628
 * Method:    XMaskEvent
629
 * Signature: (JJJ)V
630
 */
631

632
JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XMaskEvent
633
  (JNIEnv *env, jclass clazz, jlong display, jlong event_mask, jlong event_return)
634
{
635
    AWT_CHECK_HAVE_LOCK();
636
    XMaskEvent( (Display *) jlong_to_ptr(display), event_mask, (XEvent *) jlong_to_ptr(event_return));
637
}
638

639
/*
640
 * Class:     sun_awt_X11_XlibWrapper
641
 * Method:    XWindowEvent
642
 * Signature: (JJJJ)V
643
 */
644

645
JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XWindowEvent
646
  (JNIEnv *env, jclass clazz, jlong display, jlong window, jlong event_mask, jlong event_return)
647
{
648
    AWT_CHECK_HAVE_LOCK();
649
    XWindowEvent( (Display *) jlong_to_ptr(display), (Window)window, event_mask, (XEvent *) jlong_to_ptr(event_return));
650
}
651

652
/*
653
 * Class:     sun_awt_X11_XlibWrapper
654
 * Method:    XFilterEvent
655
 * Signature: (JJ)Z
656
 */
657
JNIEXPORT jboolean JNICALL Java_sun_awt_X11_XlibWrapper_XFilterEvent
658
(JNIEnv *env, jclass clazz, jlong ptr, jlong window)
659
{
660
    AWT_CHECK_HAVE_LOCK_RETURN(JNI_FALSE);
661
    return (jboolean) XFilterEvent((XEvent *) jlong_to_ptr(ptr), (Window) window);
662
}
663

664
/*
665
 * Class:     sun_awt_X11_XlibWrapper
666
 * Method:    XSupportsLocale
667
 * Signature: ()Z
668
 */
669
JNIEXPORT jboolean JNICALL Java_sun_awt_X11_XlibWrapper_XSupportsLocale
670
(JNIEnv *env, jclass clazz)
671
{
672
    AWT_CHECK_HAVE_LOCK_RETURN(JNI_FALSE);
673
    return (jboolean)XSupportsLocale();
674
}
675

676
/*
677
 * Class:     sun_awt_X11_XlibWrapper
678
 * Method:    XSetLocaleModifiers
679
 * Signature: (Ljava/lang/String;)Ljava/lang/String;
680
 */
681
JNIEXPORT jstring JNICALL Java_sun_awt_X11_XlibWrapper_XSetLocaleModifiers
682
(JNIEnv *env, jclass clazz, jstring jstr)
683
{
684
    char * modifier_list = NULL;
685
    char * ret = NULL;
686

687
    if (!JNU_IsNull(env, jstr)) {
688
        modifier_list = (char *)JNU_GetStringPlatformChars(env, jstr, NULL);
689
        CHECK_NULL_RETURN(modifier_list, NULL);
690
    }
691

692
    AWT_CHECK_HAVE_LOCK_RETURN(NULL);
693
    if (modifier_list) {
694
        ret = XSetLocaleModifiers(modifier_list);
695
        JNU_ReleaseStringPlatformChars(env, jstr, (const char *) modifier_list);
696
    } else {
697
        ret = XSetLocaleModifiers("");
698
    }
699

700
    return (ret != NULL ? JNU_NewStringPlatform(env, ret): NULL);
701
}
702

703

704
/*
705
 * Class:     sun_awt_X11_wrappers_XlibWrapper
706
 * Method:    XPeekEvent
707
 * Signature: (JJ)V
708
 */
709

710

711
JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XPeekEvent
712
(JNIEnv *env, jclass clazz, jlong display, jlong ptr)
713
{
714
    AWT_CHECK_HAVE_LOCK();
715
    XPeekEvent((Display *) jlong_to_ptr(display),jlong_to_ptr(ptr));
716
}
717

718

719
/*
720
 * Class:     sun_awt_X11_XlibWrapper
721
 * Method:    XMoveResizeWindow
722
 * Signature: (JJIIII)V
723
 */
724

725
JNIEXPORT void JNICALL  Java_sun_awt_X11_XlibWrapper_XMoveResizeWindow
726
(JNIEnv *env, jclass clazz, jlong display, jlong window, jint x , jint y , jint width, jint height) {
727

728
    AWT_CHECK_HAVE_LOCK();
729
    XMoveResizeWindow( (Display *) jlong_to_ptr(display), (Window) window, x, y, width, height);
730

731
}
732

733
/*
734
 * Class:     sun_awt_X11_XlibWrapper
735
 * Method:    XResizeWindow
736
 * Signature: (JJII)V
737
 */
738

739
JNIEXPORT void JNICALL  Java_sun_awt_X11_XlibWrapper_XResizeWindow
740
(JNIEnv *env, jclass clazz, jlong display, jlong window, jint width, jint height)
741
{
742
    AWT_CHECK_HAVE_LOCK();
743
    XResizeWindow( (Display *) jlong_to_ptr(display),(Window) window,width,height);
744
}
745

746
/*
747
 * Class:     sun_awt_X11_XlibWrapper
748
 * Method:    XMoveWindow
749
 * Signature: (JJII)V
750
 */
751

752
JNIEXPORT void JNICALL  Java_sun_awt_X11_XlibWrapper_XMoveWindow
753
(JNIEnv *env, jclass clazz, jlong display, jlong window, jint width, jint height)
754
{
755
    AWT_CHECK_HAVE_LOCK();
756
    XMoveWindow( (Display *) jlong_to_ptr(display),(Window) window,width,height);
757
}
758

759

760
/*
761
 * Class:     sun_awt_X11_XlibWrapper
762
 * Method:    XSetWindowBackground
763
 * Signature: (JJJ)V
764
 */
765

766
JNIEXPORT void JNICALL  Java_sun_awt_X11_XlibWrapper_XSetWindowBackground
767
(JNIEnv *env, jclass clazz, jlong display, jlong window, jlong background_pixel) {
768

769
    AWT_CHECK_HAVE_LOCK();
770
    XSetWindowBackground((Display *) jlong_to_ptr(display),window,background_pixel);
771

772
}
773

774

775
/*
776
 * Class:     sun_awt_X11_XlibWrapper
777
 * Method:    XFlush
778
 * Signature: (J)V
779
 */
780
JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XFlush
781
(JNIEnv *env, jclass clazz, jlong display) {
782

783
    AWT_CHECK_HAVE_LOCK();
784
    XFlush((Display *)jlong_to_ptr(display));
785
}
786

787
/*
788
 * Class:     sun_awt_X11_XlibWrapper
789
 * Method:    XSync
790
 * Signature: (JI)V
791
 */
792
JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XSync
793
(JNIEnv *env, jclass clazz, jlong display, jint discard) {
794

795
    AWT_CHECK_HAVE_LOCK();
796
    XSync((Display *) jlong_to_ptr(display), discard);
797

798
}
799

800
JNIEXPORT jint JNICALL Java_sun_awt_X11_XlibWrapper_XTranslateCoordinates
801
(JNIEnv *env, jclass clazz, jlong display, jlong src_w, jlong dest_w,
802
 jlong src_x, jlong src_y, jlong dest_x_return, jlong dest_y_return,
803
 jlong child_return)
804
{
805
    AWT_CHECK_HAVE_LOCK_RETURN(0);
806
    return XTranslateCoordinates( (Display *) jlong_to_ptr(display), src_w, dest_w,
807
                  src_x, src_y,
808
                  (int *) jlong_to_ptr(dest_x_return),
809
                  (int *) jlong_to_ptr(dest_y_return),
810
                  (Window *) jlong_to_ptr(child_return));
811
}
812

813
JNIEXPORT jint JNICALL Java_sun_awt_X11_XlibWrapper_XEventsQueued
814
(JNIEnv *env, jclass clazz, jlong display, jint mode) {
815

816
    AWT_CHECK_HAVE_LOCK_RETURN(0);
817
    return XEventsQueued((Display *) jlong_to_ptr(display), mode);
818

819
}
820

821
/*
822
 * Class:     sun_awt_X11_XlibWrapper
823
 * Method:    SetProperty
824
 * Signature: (JJJLjava/lang/String;)V
825
 */
826
JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_SetProperty
827
(JNIEnv *env, jclass clazz, jlong display, jlong window, jlong atom, jstring jstr) {
828
    char *cname;
829
    XTextProperty tp;
830
    int32_t status;
831

832
    /*
833
       In case there are direct support of UTF-8 declared, use UTF-8 strings.
834
    */
835
    if (!JNU_IsNull(env, jstr)) {
836
#ifdef X_HAVE_UTF8_STRING
837
        cname = (char *) (*env)->GetStringUTFChars(env, jstr, JNI_FALSE);
838
#else
839
        cname = (char *) JNU_GetStringPlatformChars(env, jstr, NULL);
840
#endif
841
        CHECK_NULL(cname);
842
    } else {
843
        cname = "";
844
    }
845

846

847
    AWT_CHECK_HAVE_LOCK();
848

849
#ifdef X_HAVE_UTF8_STRING
850
    status = Xutf8TextListToTextProperty((Display *)jlong_to_ptr(display), &cname, 1,
851
                                       XStdICCTextStyle, &tp);
852
#else
853
    status = XmbTextListToTextProperty((Display *)jlong_to_ptr(display), &cname, 1,
854
                                       XStdICCTextStyle, &tp);
855
#endif
856

857

858
    if (status == Success || status > 0) {
859
        XChangeProperty((Display *)jlong_to_ptr(display), window, atom, tp.encoding, tp.format, PropModeReplace, tp.value, tp.nitems);
860
        if (tp.value != NULL) {
861
            XFree(tp.value);
862
        }
863
    }
864

865
    if (!JNU_IsNull(env, jstr)) {
866
#ifdef X_HAVE_UTF8_STRING
867
        (*env)->ReleaseStringUTFChars(env, jstr, (const char *) cname);
868
#else
869
        JNU_ReleaseStringPlatformChars(env, jstr, (const char *) cname);
870
#endif
871
    }
872
}
873

874
/*
875
 * Class:     sun_awt_X11_XlibWrapper
876
 * Method:    XChangeProperty
877
 * Signature: (JJJJJJJJJJJ)V
878
 */
879
JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XChangePropertyImpl(
880
    JNIEnv *env, jclass clazz, jlong display, jlong window, jlong property,
881
    jlong type, jint format, jint mode, jlong data, jint nelements)
882
{
883
    AWT_CHECK_HAVE_LOCK();
884
    XChangeProperty((Display*) jlong_to_ptr(display), (Window) window, (Atom) property,
885
            (Atom) type, format, mode, (unsigned char*) jlong_to_ptr(data),
886
            nelements);
887
}
888
/*
889
 * Class:     sun_awt_X11_XlibWrapper
890
 * Method:    XChangePropertyS
891
 * Signature: (JJJJJJJJJLjava/lang/String;)V
892
 */
893
JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XChangePropertyS(
894
    JNIEnv *env, jclass clazz, jlong display, jlong window, jlong property,
895
    jlong type, jint format, jint mode, jstring value)
896
{
897
    jboolean iscopy;
898
    AWT_CHECK_HAVE_LOCK();
899
    const char * chars = JNU_GetStringPlatformChars(env, value, &iscopy);
900
    CHECK_NULL(chars);
901
    XChangeProperty((Display*)jlong_to_ptr(display), window, (Atom)property,
902
                    (Atom)type, format, mode, (unsigned char*)chars, strlen(chars));
903
    if (iscopy) {
904
        JNU_ReleaseStringPlatformChars(env, value, chars);
905
    }
906
}
907

908
/*
909
 * Class:     sun_awt_X11_XlibWrapper
910
 * Method:    XGetWindowProperty
911
 * Signature: (JJJJJJJJJJJ)J;
912
 */
913
JNIEXPORT jint JNICALL Java_sun_awt_X11_XlibWrapper_XGetWindowProperty
914
(JNIEnv *env, jclass clazz, jlong display, jlong window, jlong property, jlong long_offset,
915
 jlong long_length, jlong delete, jlong req_type, jlong actual_type,
916
 jlong actual_format, jlong nitems_ptr, jlong bytes_after, jlong data_ptr)
917
{
918
    AWT_CHECK_HAVE_LOCK_RETURN(0);
919
    return XGetWindowProperty((Display*) jlong_to_ptr(display), window, property, long_offset, long_length,
920
                  delete, (Atom) req_type, (Atom*) jlong_to_ptr(actual_type),
921
                  (int *) jlong_to_ptr(actual_format), (unsigned long *) jlong_to_ptr(nitems_ptr),
922
                  (unsigned long*) jlong_to_ptr(bytes_after), (unsigned char**) jlong_to_ptr(data_ptr));
923
}
924

925
/*
926
 * Class:     sun_awt_X11_XlibWrapper
927
 * Method:    GetProperty
928
 * Signature: (JJJ)Ljava/lang/String;
929
 */
930
JNIEXPORT jstring JNICALL Java_sun_awt_X11_XlibWrapper_GetProperty
931
(JNIEnv *env, jclass clazz, jlong display, jlong window, jlong atom)
932
{
933
    /* Request status */
934
    int status;
935

936
    /* Returns of XGetWindowProperty */
937
    Atom actual_type;
938
    int actual_format;
939
    unsigned long nitems;
940
    unsigned long bytes_after;
941
    unsigned char * string;
942
    jstring res = NULL;
943
    AWT_CHECK_HAVE_LOCK_RETURN(NULL);
944
    status = XGetWindowProperty((Display*)jlong_to_ptr(display), window,
945
                                atom, 0, 0xFFFF, False, XA_STRING,
946
                                &actual_type, &actual_format, &nitems, &bytes_after,
947
                                &string);
948

949
    if (status != Success || string == NULL) {
950
        return NULL;
951
    }
952

953
    if (actual_type == XA_STRING && actual_format == 8) {
954
        res = JNU_NewStringPlatform(env,(char*) string);
955
    }
956
    XFree(string);
957
    return res;
958
}
959

960
/*
961
 * Class:     sun_awt_X11_XlibWrapper
962
 * Method:    InternAtom
963
 * Signature: (JLjava/lang/String;I)J
964
 */
965
JNIEXPORT jlong JNICALL Java_sun_awt_X11_XlibWrapper_InternAtom
966
(JNIEnv *env, jclass clazz, jlong display, jstring jstr, jint ife) {
967

968
    char *cname;
969
    unsigned long atom;
970

971
    AWT_CHECK_HAVE_LOCK_RETURN(0);
972

973
    if (!JNU_IsNull(env, jstr)) {
974
        cname = (char *)JNU_GetStringPlatformChars(env, jstr, NULL);
975
        CHECK_NULL_RETURN(cname, 0);
976
    } else {
977
        cname = "";
978
    }
979

980
    atom = XInternAtom((Display *) jlong_to_ptr(display), cname, ife);
981

982
    if (!JNU_IsNull(env, jstr)) {
983
        JNU_ReleaseStringPlatformChars(env, jstr, (const char *) cname);
984
    }
985

986
    return (jlong) atom;
987

988
}
989

990
JNIEXPORT jint JNICALL Java_sun_awt_X11_XlibWrapper_XCreateFontCursor
991
(JNIEnv *env, jclass clazz, jlong display, jint shape) {
992
    AWT_CHECK_HAVE_LOCK_RETURN(0);
993
    return XCreateFontCursor((Display *) jlong_to_ptr(display), (int) shape);
994
}
995

996

997
/*
998
 * Class:     sun_awt_X11_XlibWrapper
999
 * Method:    XCreatePixmapCursor
1000
 * Signature: (JJJJJII)J
1001
 */
1002
JNIEXPORT jlong JNICALL Java_sun_awt_X11_XlibWrapper_XCreatePixmapCursor
1003
(JNIEnv *env , jclass clazz, jlong display, jlong source, jlong mask, jlong fore, jlong back, jint x , jint y) {
1004

1005
    AWT_CHECK_HAVE_LOCK_RETURN(0);
1006
    return (jlong) XCreatePixmapCursor((Display *) jlong_to_ptr(display), (Pixmap) source, (Pixmap) mask,
1007
                                       (XColor *) jlong_to_ptr(fore), (XColor *) jlong_to_ptr(back), x, y);
1008
}
1009

1010

1011
/*
1012
 * Class:     sun_awt_X11_XlibWrapper
1013
 * Method:    XQueryBestCursor
1014
 * Signature: (JJIIJJ)Z
1015
 */
1016
JNIEXPORT jboolean JNICALL Java_sun_awt_X11_XlibWrapper_XQueryBestCursor
1017
(JNIEnv *env, jclass clazz, jlong display, jlong drawable, jint width, jint height, jlong width_return, jlong height_return) {
1018

1019
    Status status;
1020

1021
    AWT_CHECK_HAVE_LOCK_RETURN(JNI_FALSE);
1022
    status  =  XQueryBestCursor((Display *) jlong_to_ptr(display), (Drawable) drawable, width,height,
1023
                                (unsigned int *) jlong_to_ptr(width_return), (unsigned int *) jlong_to_ptr(height_return));
1024

1025
    if (status == 0) return JNI_FALSE;
1026
    else return JNI_TRUE;
1027
}
1028

1029

1030
/*
1031
 * Class:     sun_awt_X11_XlibWrapper
1032
 * Method:    XFreeCursor
1033
 * Signature: (JJ)V
1034
 */
1035
JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XFreeCursor
1036
(JNIEnv *env, jclass clazz, jlong display, jlong cursor) {
1037

1038
    AWT_CHECK_HAVE_LOCK();
1039
    XFreeCursor( (Display *) jlong_to_ptr(display), (Cursor) cursor);
1040
}
1041

1042
/*
1043
 * Class:     sun_awt_X11_XlibWrapper
1044
 * Method:    XQueryPointer
1045
 * Signature: (JJJJJJJJJ)Z
1046
 */
1047
JNIEXPORT jboolean JNICALL Java_sun_awt_X11_XlibWrapper_XQueryPointer
1048
(JNIEnv *env, jclass clazz, jlong display, jlong w, jlong root_return, jlong child_return, jlong root_x_return , jlong root_y_return, jlong win_x_return, jlong win_y_return, jlong mask_return) {
1049

1050
    Bool b;
1051

1052
    AWT_CHECK_HAVE_LOCK_RETURN(JNI_FALSE);
1053
    b = XQueryPointer((Display *) jlong_to_ptr(display),
1054
                      (Window) w, (Window *) jlong_to_ptr(root_return), (Window *) jlong_to_ptr(child_return),
1055
                      (int *) jlong_to_ptr(root_x_return), (int *) jlong_to_ptr(root_y_return),
1056
                      (int *) jlong_to_ptr(win_x_return), (int *) jlong_to_ptr(win_y_return),
1057
                      (unsigned int *) jlong_to_ptr(mask_return));
1058

1059
    return b ? JNI_TRUE : JNI_FALSE;
1060
}
1061

1062
/*
1063
 * Class:     sun_awt_X11_XlibWrapper
1064
 * Method:    XChangeWindowAttributes
1065
 * Signature: (JJJJ)V
1066
 */
1067
JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XChangeWindowAttributes
1068
(JNIEnv *env, jclass clazz, jlong display, jlong window, jlong valuemask, jlong attributes) {
1069

1070
    AWT_CHECK_HAVE_LOCK();
1071
    XChangeWindowAttributes((Display *) jlong_to_ptr(display), (Window) window, (unsigned long) valuemask,
1072
                            (XSetWindowAttributes *) jlong_to_ptr(attributes));
1073
}
1074

1075

1076
/*
1077
 * Class:     sun_awt_X11_XlibWrapper
1078
 * Method:    XSetTransientFor
1079
 * Signature: (JJJ)V
1080
 */
1081
JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XSetTransientFor
1082
(JNIEnv *env, jclass clazz, jlong display, jlong window, jlong transient_for_window)
1083
{
1084
    AWT_CHECK_HAVE_LOCK();
1085
    XSetTransientForHint((Display *) jlong_to_ptr(display), window, transient_for_window);
1086
}
1087

1088
/*
1089
 * Class:     sun_awt_X11_XlibWrapper
1090
 * Method:    XSetWMHints
1091
 * Signature: (JJJ)V
1092
 */
1093
JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XSetWMHints
1094
(JNIEnv *env, jclass clazz, jlong display, jlong window, jlong hints)
1095
{
1096
    AWT_CHECK_HAVE_LOCK();
1097
    XSetWMHints((Display *) jlong_to_ptr(display), window, (XWMHints *) jlong_to_ptr(hints));
1098
}
1099

1100
/*
1101
 * Class:     sun_awt_X11_XlibWrapper
1102
 * Method:    XGetWMHints
1103
 * Signature: (JJJ)V
1104
 */
1105
JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XGetWMHints
1106
(JNIEnv *env, jclass clazz, jlong display, jlong window, jlong hints)
1107
{
1108
    XWMHints * get_hints;
1109
    AWT_CHECK_HAVE_LOCK();
1110
    get_hints = XGetWMHints((Display*)jlong_to_ptr(display), window);
1111
    if (get_hints != NULL) {
1112
        memcpy(jlong_to_ptr(hints), get_hints, sizeof(XWMHints));
1113
        XFree(get_hints);
1114
    } else {
1115
        memset(jlong_to_ptr(hints), 0, sizeof(XWMHints));
1116
    }
1117
}
1118

1119
/*
1120
 * Class:     sun_awt_X11_XlibWrapper
1121
 * Method:    XGetPointerMapping
1122
 * Signature: (JJI)I
1123
 */
1124
JNIEXPORT jint JNICALL Java_sun_awt_X11_XlibWrapper_XGetPointerMapping
1125
(JNIEnv *env, jclass clazz, jlong display, jlong map, jint buttonNumber)
1126
{
1127
    AWT_CHECK_HAVE_LOCK_RETURN(0);
1128
    return XGetPointerMapping((Display*)jlong_to_ptr(display), (unsigned char*) jlong_to_ptr(map), buttonNumber);
1129
}
1130

1131
/*
1132
 * Class:     sun_awt_X11_XlibWrapper
1133
 * Method:    XGetDefault
1134
 * Signature: (JJI)I
1135
 */
1136
JNIEXPORT jstring JNICALL Java_sun_awt_X11_XlibWrapper_XGetDefault
1137
(JNIEnv *env, jclass clazz, jlong display, jstring program, jstring option)
1138
{
1139
    char * c_program = NULL;
1140
    char * c_option = NULL;
1141
    char * c_res = NULL;
1142

1143
    if (!JNU_IsNull(env, program)) {
1144
        c_program = (char *)JNU_GetStringPlatformChars(env, program, NULL);
1145
    }
1146
    CHECK_NULL_RETURN(c_program, NULL);
1147

1148
    if (!JNU_IsNull(env, option)) {
1149
        c_option = (char *)JNU_GetStringPlatformChars(env, option, NULL);
1150
    }
1151

1152
    if (c_option == NULL) {
1153
        JNU_ReleaseStringPlatformChars(env, program, (const char *) c_program);
1154
        return NULL;
1155
    }
1156

1157
    AWT_CHECK_HAVE_LOCK_RETURN(NULL);
1158
    c_res = XGetDefault((Display*)jlong_to_ptr(display), c_program, c_option);
1159
    // The strings returned by XGetDefault() are owned by Xlib and
1160
    // should not be modified or freed by the client.
1161

1162
    JNU_ReleaseStringPlatformChars(env, program, (const char *) c_program);
1163
    JNU_ReleaseStringPlatformChars(env, option, (const char *) c_option);
1164

1165
    if (c_res != NULL) {
1166
        return JNU_NewStringPlatform(env, c_res);
1167
    } else {
1168
        return NULL;
1169
    }
1170
}
1171

1172

1173
/*
1174
 * Class:     sun_awt_X11_XlibWrapper
1175
 * Method:    getScreenOfWindow
1176
 * Signature: (JJ)J
1177
 */
1178
JNIEXPORT jlong JNICALL Java_sun_awt_X11_XlibWrapper_getScreenOfWindow
1179
(JNIEnv *env, jclass clazz, jlong display, jlong window)
1180
{
1181
    XWindowAttributes attrs;
1182
    memset(&attrs, 0, sizeof(attrs));
1183
    AWT_CHECK_HAVE_LOCK_RETURN(0);
1184
    XGetWindowAttributes((Display *) jlong_to_ptr(display), window, &attrs);
1185
    return ptr_to_jlong(attrs.screen);
1186
}
1187

1188
/*
1189
 * Class:     sun_awt_X11_XlibWrapper
1190
 * Method:    XScreenNumberOfScreen
1191
 * Signature: (J)J
1192
 */
1193
JNIEXPORT jlong JNICALL Java_sun_awt_X11_XlibWrapper_XScreenNumberOfScreen
1194
(JNIEnv *env, jclass clazz, jlong screen)
1195
{
1196
    AWT_CHECK_HAVE_LOCK_RETURN(-1);
1197
    if(jlong_to_ptr(screen) == NULL) {
1198
        return -1;
1199
    }
1200
    return XScreenNumberOfScreen((Screen*) jlong_to_ptr(screen));
1201
}
1202

1203
/*
1204
 * Class:     sun_awt_X11_XlibWrapper
1205
 * Method:    XIconifyWindow
1206
 * Signature: (JJJ)V
1207
 */
1208
JNIEXPORT jint JNICALL Java_sun_awt_X11_XlibWrapper_XIconifyWindow
1209
(JNIEnv *env, jclass clazz, jlong display, jlong window, jlong screenNumber)
1210
{
1211
    AWT_CHECK_HAVE_LOCK_RETURN(0);
1212
    return XIconifyWindow((Display*) jlong_to_ptr(display), window, screenNumber);
1213
}
1214

1215
/*
1216
 * Class:     sun_awt_X11_XlibWrapper
1217
 * Method:    XFree
1218
 * Signature: (J)V
1219
 */
1220
JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XFree
1221
(JNIEnv *env, jclass clazz, jlong ptr)
1222
{
1223
    AWT_CHECK_HAVE_LOCK();
1224
    XFree(jlong_to_ptr(ptr));
1225
}
1226

1227
/*
1228
 * Class:     sun_awt_X11_XlibWrapper
1229
 * Method:    XFree
1230
 * Signature: (J)V
1231
 */
1232
JNIEXPORT jbyteArray JNICALL Java_sun_awt_X11_XlibWrapper_getStringBytes
1233
(JNIEnv *env, jclass clazz, jlong str_ptr)
1234
{
1235
    unsigned char * str = (unsigned char*) jlong_to_ptr(str_ptr);
1236
    long length = strlen((char*)str);
1237
    jbyteArray res = (*env)->NewByteArray(env, length);
1238
    CHECK_NULL_RETURN(res, NULL);
1239
    (*env)->SetByteArrayRegion(env, res, 0, length,
1240
                   (const signed char*) str);
1241
    return res;
1242
}
1243

1244

1245
/*
1246
 * Class:     sun_awt_X11_XlibWrapper
1247
 * Method:    ServerVendor
1248
 * Signature: (J)Ljava/lang/String;
1249
 */
1250
JNIEXPORT jstring JNICALL Java_sun_awt_X11_XlibWrapper_ServerVendor
1251
(JNIEnv *env, jclass clazz, jlong display)
1252
{
1253
    AWT_CHECK_HAVE_LOCK_RETURN(NULL);
1254
    return JNU_NewStringPlatform(env, ServerVendor((Display*)jlong_to_ptr(display)));
1255
}
1256
/*
1257
 * Class:     sun_awt_X11_XlibWrapper
1258
 * Method:    VendorRelease
1259
 * Signature: (J)I;
1260
 */
1261
JNIEXPORT jint JNICALL Java_sun_awt_X11_XlibWrapper_VendorRelease
1262
(JNIEnv *env, jclass clazz, jlong display)
1263
{
1264
    AWT_CHECK_HAVE_LOCK_RETURN(0);
1265
    return VendorRelease((Display*)jlong_to_ptr(display));
1266
}
1267
/*
1268
 * Class:     sun_awt_X11_XlibWrapper
1269
 * Method:    IsXsunKPBehavior
1270
 * Signature: (J)Z;
1271
 */
1272
JNIEXPORT jboolean JNICALL Java_sun_awt_X11_XlibWrapper_IsXsunKPBehavior
1273
(JNIEnv *env, jclass clazz, jlong display)
1274
{
1275
    // Xsun without XKB uses keysymarray[2] keysym to determine if it is KP event.
1276
    // Otherwise, it is [1] or sometimes [0].
1277
    // This sniffer first tries to determine what is a keycode for XK_KP_7
1278
    // using XKeysymToKeycode;
1279
    // second, in which place in the keysymarray is XK_KP_7
1280
    // using XKeycodeToKeysym.
1281
    int kc7;
1282
    AWT_CHECK_HAVE_LOCK_RETURN(JNI_FALSE);
1283
    kc7 = XKeysymToKeycode((Display*)jlong_to_ptr(display), XK_KP_7);
1284
    if( !kc7 ) {
1285
        // keycode is not defined. Why, it's a reduced keyboard perhaps:
1286
        // report arbitrarily false.
1287
        return JNI_FALSE;
1288
    } else {
1289
        long ks2 = XKeycodeToKeysym((Display*)jlong_to_ptr(display), kc7, 2);
1290
        if( ks2 == XK_KP_7 ) {
1291
            //XXX If some Xorg server would put XK_KP_7 in keysymarray[2] as well,
1292
            //XXX for yet unknown to me reason, the sniffer would lie.
1293
            return JNI_TRUE;
1294
        }else{
1295
            return JNI_FALSE;
1296
        }
1297
    }
1298
}
1299

1300

1301
JNIEXPORT jboolean JNICALL Java_sun_awt_X11_XlibWrapper_IsSunKeyboard
1302
(JNIEnv *env, jclass clazz, jlong display)
1303
{
1304
    int xx;
1305
    AWT_CHECK_HAVE_LOCK_RETURN(JNI_FALSE);
1306
    xx = XKeysymToKeycode((Display*)jlong_to_ptr(display), SunXK_F37);
1307
    return (!xx) ? JNI_FALSE : JNI_TRUE;
1308
}
1309

1310
JNIEXPORT jboolean JNICALL Java_sun_awt_X11_XlibWrapper_IsKanaKeyboard
1311
(JNIEnv *env, jclass clazz, jlong display)
1312
{
1313
    int xx;
1314
    static jboolean result = JNI_FALSE;
1315

1316
    int32_t minKeyCode, maxKeyCode, keySymsPerKeyCode;
1317
    KeySym *keySyms, *keySymsStart, keySym;
1318
    int32_t i;
1319
    int32_t kanaCount = 0;
1320

1321
    AWT_CHECK_HAVE_LOCK_RETURN(JNI_FALSE);
1322

1323
    // There's no direct way to determine whether the keyboard has
1324
    // a kana lock key. From available keyboard mapping tables, it looks
1325
    // like only keyboards with the kana lock key can produce keysyms
1326
    // for kana characters. So, as an indirect test, we check for those.
1327
    XDisplayKeycodes((Display*)jlong_to_ptr(display), &minKeyCode, &maxKeyCode);
1328
    keySyms = XGetKeyboardMapping((Display*)jlong_to_ptr(display), minKeyCode, maxKeyCode - minKeyCode + 1, &keySymsPerKeyCode);
1329
    keySymsStart = keySyms;
1330
    for (i = 0; i < (maxKeyCode - minKeyCode + 1) * keySymsPerKeyCode; i++) {
1331
        keySym = *keySyms++;
1332
        if ((keySym & 0xff00) == 0x0400) {
1333
            kanaCount++;
1334
        }
1335
    }
1336
    XFree(keySymsStart);
1337

1338
    // use a (somewhat arbitrary) minimum so we don't get confused by a stray function key
1339
    result = kanaCount > 10;
1340
    return result ? JNI_TRUE : JNI_FALSE;
1341
}
1342

1343
JavaVM* jvm = NULL;
1344
static int ToolkitErrorHandler(Display * dpy, XErrorEvent * event) {
1345
    JNIEnv * env;
1346
    // First call the native synthetic error handler declared in "awt_util.h" file.
1347
    if (current_native_xerror_handler != NULL) {
1348
        current_native_xerror_handler(dpy, event);
1349
    }
1350
    if (jvm != NULL) {
1351
        env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
1352
        if (env) {
1353
            return JNU_CallStaticMethodByName(env, NULL, "sun/awt/X11/XErrorHandlerUtil",
1354
                "globalErrorHandler", "(JJ)I", ptr_to_jlong(dpy), ptr_to_jlong(event)).i;
1355
        }
1356
    }
1357
    return 0;
1358
}
1359

1360
/*
1361
 * Class:     sun_awt_X11_XlibWrapper
1362
 * Method:    SetToolkitErrorHandler
1363
 * Signature: ()J
1364
 */
1365
JNIEXPORT jlong JNICALL Java_sun_awt_X11_XlibWrapper_SetToolkitErrorHandler
1366
(JNIEnv *env, jclass clazz)
1367
{
1368
    if ((*env)->GetJavaVM(env, &jvm) < 0) {
1369
        return 0;
1370
    }
1371
    AWT_CHECK_HAVE_LOCK_RETURN(0);
1372
    return ptr_to_jlong(XSetErrorHandler(ToolkitErrorHandler));
1373
}
1374

1375
/*
1376
 * Class:     sun_awt_X11_XlibWrapper
1377
 * Method:    XSetErrorHandler
1378
 * Signature: (J)V
1379
 */
1380
JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XSetErrorHandler
1381
(JNIEnv *env, jclass clazz, jlong handler)
1382
{
1383
    AWT_CHECK_HAVE_LOCK();
1384
    XSetErrorHandler((XErrorHandler) jlong_to_ptr(handler));
1385
}
1386

1387
/*
1388
 * Class:     sun_awt_X11_XlibWrapper
1389
 * Method:    CallErrorHandler
1390
 * Signature: (JJJ)I
1391
 */
1392
JNIEXPORT jint JNICALL Java_sun_awt_X11_XlibWrapper_CallErrorHandler
1393
(JNIEnv *env, jclass clazz, jlong handler, jlong display, jlong event_ptr)
1394
{
1395
    return (*(XErrorHandler)jlong_to_ptr(handler))((Display*) jlong_to_ptr(display), (XErrorEvent*) jlong_to_ptr(event_ptr));
1396
}
1397

1398

1399
/*
1400
 * Class:     sun_awt_X11_XlibWrapper
1401
 * Method:    PrintXErrorEvent
1402
 * Signature: (JJ)V
1403
 */
1404
JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_PrintXErrorEvent
1405
(JNIEnv *env, jclass clazz, jlong display, jlong event_ptr)
1406
{
1407
    char msg[128];
1408
    char buf[128];
1409

1410
    XErrorEvent* err = (XErrorEvent *)jlong_to_ptr(event_ptr);
1411

1412
    XGetErrorText((Display *)jlong_to_ptr(display), err->error_code, msg, sizeof(msg));
1413
    jio_fprintf(stderr, "Xerror %s, XID %x, ser# %d\n", msg, err->resourceid, err->serial);
1414
    jio_snprintf(buf, sizeof(buf), "%d", err->request_code);
1415
    XGetErrorDatabaseText((Display *)jlong_to_ptr(display), "XRequest", buf, "Unknown", msg, sizeof(msg));
1416
    jio_fprintf(stderr, "Major opcode %d (%s)\n", err->request_code, msg);
1417
    if (err->request_code > 128) {
1418
        jio_fprintf(stderr, "Minor opcode %d\n", err->minor_code);
1419
    }
1420
}
1421

1422

1423
/*
1424
 * Class:     sun_awt_X11_XlibWrapper
1425
 * Method:    XInternAtoms
1426
 * Signature: (J[Ljava/lang/String;ZJ)I
1427
 */
1428
JNIEXPORT jint JNICALL Java_sun_awt_X11_XlibWrapper_XInternAtoms
1429
(JNIEnv *env, jclass clazz, jlong display, jobjectArray names_arr, jboolean only_if_exists, jlong atoms)
1430
{
1431
    int status = 0;
1432
    AWT_CHECK_HAVE_LOCK_RETURN(0);
1433
    jsize length;
1434
    char** names = stringArrayToNative(env, names_arr, &length);
1435
    if (names) {
1436
        status = XInternAtoms((Display*)jlong_to_ptr(display), names, length, only_if_exists, (Atom*) jlong_to_ptr(atoms));
1437
        freeNativeStringArray(names, length);
1438
    }
1439
    return status;
1440
}
1441

1442

1443

1444
/*
1445
 * Class:     sun_awt_X11_XlibWrapper
1446
 * Method:    XGetWindowAttributes
1447
 * Signature: (JJJ)I
1448
 */
1449
JNIEXPORT jint JNICALL Java_sun_awt_X11_XlibWrapper_XGetWindowAttributes
1450
(JNIEnv *env, jclass clazz, jlong display, jlong window, jlong attr_ptr)
1451
{
1452
    jint status;
1453
    AWT_CHECK_HAVE_LOCK_RETURN(0);
1454
    memset((XWindowAttributes*) jlong_to_ptr(attr_ptr), 0, sizeof(XWindowAttributes));
1455
    status =  XGetWindowAttributes((Display*)jlong_to_ptr(display), window, (XWindowAttributes*) jlong_to_ptr(attr_ptr));
1456
    return status;
1457
}
1458

1459

1460
/*
1461
 * Class:     sun_awt_X11_XlibWrapper
1462
 * Method:    XGetGeometry
1463
 * Signature: (JJJJJJJJJ)I
1464
 */
1465
JNIEXPORT jint JNICALL Java_sun_awt_X11_XlibWrapper_XGetGeometry
1466
(JNIEnv *env, jclass clazz, jlong display, jlong drawable, jlong root_return,
1467
     jlong x_return, jlong y_return, jlong width_return, jlong height_return,
1468
     jlong border_width_return, jlong depth_return)
1469
{
1470
    jint status;
1471
    AWT_CHECK_HAVE_LOCK_RETURN(0);
1472
    status = XGetGeometry((Display *)jlong_to_ptr(display),
1473
                          (Drawable)drawable, (Window *)jlong_to_ptr(root_return),
1474
                          (int *)jlong_to_ptr(x_return), (int *)jlong_to_ptr(y_return),
1475
                          (unsigned int *)jlong_to_ptr(width_return), (unsigned int *)jlong_to_ptr(height_return),
1476
                          (unsigned int *)jlong_to_ptr(border_width_return),
1477
                          (unsigned int *)jlong_to_ptr(depth_return));
1478
    return status;
1479
}
1480

1481

1482
/*
1483
 * Class:     sun_awt_X11_XlibWrapper
1484
 * Method:    XGetWMNormalHints
1485
 * Signature: (JJJJ)I
1486
 */
1487
JNIEXPORT jint JNICALL Java_sun_awt_X11_XlibWrapper_XGetWMNormalHints
1488
(JNIEnv *env, jclass clazz, jlong display, jlong window, jlong hints, jlong supplied_return)
1489
{
1490
    AWT_CHECK_HAVE_LOCK_RETURN(0);
1491
    return XGetWMNormalHints((Display*) jlong_to_ptr(display),
1492
                             window,
1493
                             (XSizeHints*) jlong_to_ptr(hints),
1494
                             (long*) jlong_to_ptr(supplied_return));
1495
}
1496

1497
/*
1498
 * Class:     sun_awt_X11_XlibWrapper
1499
 * Method:    XSetWMNormalHints
1500
 * Signature: (JJJ)V
1501
 */
1502
JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XSetWMNormalHints
1503
(JNIEnv *env, jclass clazz, jlong display, jlong window, jlong hints)
1504
{
1505
    AWT_CHECK_HAVE_LOCK();
1506
    XSetWMNormalHints((Display*) jlong_to_ptr(display), window, (XSizeHints*) jlong_to_ptr(hints));
1507
}
1508

1509
/*
1510
 * Class:     sun_awt_X11_XlibWrapper
1511
 * Method:    XDeleteProperty
1512
 * Signature: (JJJ)V
1513
 */
1514
JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XDeleteProperty
1515
(JNIEnv *env, jclass clazz, jlong display, jlong window, jlong atom)
1516
{
1517
    AWT_CHECK_HAVE_LOCK();
1518
    XDeleteProperty((Display*) jlong_to_ptr(display), window, (Atom)atom);
1519
}
1520

1521
/*
1522
 * Class:     sun_awt_X11_XlibWrapper
1523
 * Method:    XSendEvent
1524
 * Signature: (JJZJJ)V
1525
 */
1526
JNIEXPORT jint JNICALL Java_sun_awt_X11_XlibWrapper_XSendEvent
1527
(JNIEnv *env, jclass clazz, jlong display, jlong window, jboolean propagate, jlong event_mask, jlong event)
1528
{
1529
    AWT_CHECK_HAVE_LOCK_RETURN(0);
1530
    return XSendEvent((Display*) jlong_to_ptr(display),
1531
                      window,
1532
                      propagate==JNI_TRUE?True:False,
1533
                      (long) event_mask,
1534
                      (XEvent*) jlong_to_ptr(event));
1535
}
1536

1537

1538
/*
1539
 * Class:     sun_awt_X11_XlibWrapper
1540
 * Method:    XQueryTree
1541
 * Signature: (JJJJJJ)I
1542
 */
1543
JNIEXPORT jint JNICALL Java_sun_awt_X11_XlibWrapper_XQueryTree
1544
(JNIEnv *env, jclass clazz, jlong display, jlong window, jlong root_return, jlong parent_return, jlong children_return, jlong nchildren_return)
1545
{
1546
    AWT_CHECK_HAVE_LOCK_RETURN(0);
1547
    return XQueryTree((Display*) jlong_to_ptr(display),
1548
                      window,
1549
                      (Window *) jlong_to_ptr(root_return),
1550
                      (Window*) jlong_to_ptr(parent_return),
1551
                      (Window**) jlong_to_ptr(children_return),
1552
                      (unsigned int*) jlong_to_ptr(nchildren_return));
1553
}
1554

1555

1556
/*
1557
 * Class:     sun_awt_X11_XlibWrapper
1558
 * Method:    memcpy
1559
 * Signature: (JJJ)V
1560
 */
1561
JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_memcpy
1562
(JNIEnv *env, jclass clazz, jlong dest_ptr, jlong src_ptr, jlong length)
1563
{
1564
    memcpy(jlong_to_ptr(dest_ptr), jlong_to_ptr(src_ptr), length);
1565
}
1566

1567

1568
JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XSetMinMaxHints
1569
(JNIEnv *env, jclass clazz, jlong display, jlong window, jint x, jint y, jint width, jint height, jlong flags) {
1570
    XSizeHints * hints;
1571
    AWT_CHECK_HAVE_LOCK();
1572
    hints = XAllocSizeHints();
1573
    hints->flags = flags;
1574
    hints->width = width;
1575
    hints->min_width = width;
1576
    hints->max_width = width;
1577
    hints->height = height;
1578
    hints->min_height = height;
1579
    hints->max_height = height;
1580
    hints->x = x;
1581
    hints->y = y;
1582
    XSetWMNormalHints((Display*) jlong_to_ptr(display), window, hints);
1583
    XFree(hints);
1584
}
1585

1586

1587
JNIEXPORT jlong JNICALL Java_sun_awt_X11_XlibWrapper_XGetVisualInfo
1588
(JNIEnv *env, jclass clazz, jlong display, jlong vinfo_mask, jlong vinfo_template,
1589
 jlong nitems_return)
1590
{
1591
    AWT_CHECK_HAVE_LOCK_RETURN(0);
1592
    return ptr_to_jlong(XGetVisualInfo((Display*) jlong_to_ptr(display),
1593
                                       (long) vinfo_mask,
1594
                                       (XVisualInfo*) jlong_to_ptr(vinfo_template),
1595
                                       (int*) jlong_to_ptr(nitems_return)));
1596
}
1597

1598
JNIEXPORT jlong JNICALL Java_sun_awt_X11_XlibWrapper_XAllocSizeHints
1599
  (JNIEnv *env, jclass clazz)
1600
{
1601
    AWT_CHECK_HAVE_LOCK_RETURN(0);
1602
    return ptr_to_jlong(XAllocSizeHints());
1603
}
1604

1605
/*
1606
 * Class:     sun_awt_X11_XlibWrapper
1607
 * Method:    XIconifyWindow
1608
 * Signature: (JJJ)V
1609
 */
1610
JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XBell
1611
(JNIEnv *env, jclass clazz, jlong display, jint percent)
1612
{
1613
    AWT_CHECK_HAVE_LOCK();
1614
    XBell((Display*)jlong_to_ptr(display), percent);
1615
}
1616

1617

1618
/*
1619
 * Class:     sun_awt_X11_XlibWrapper
1620
 * Method:    XAllocColor
1621
 * Signature: (JJJ)Z
1622
 */
1623
JNIEXPORT jboolean JNICALL Java_sun_awt_X11_XlibWrapper_XAllocColor
1624
(JNIEnv *env, jclass clazz, jlong display , jlong colormap, jlong xcolor) {
1625

1626
    Status status;
1627
    AWT_CHECK_HAVE_LOCK_RETURN(JNI_FALSE);
1628
    status = XAllocColor((Display *) jlong_to_ptr(display), (Colormap) colormap, (XColor *) jlong_to_ptr(xcolor));
1629

1630
    if (status == 0) return JNI_FALSE;
1631
    else return JNI_TRUE;
1632
}
1633

1634

1635
/*
1636
 * Class:     sun_awt_X11_XlibWrapper
1637
 * Method:    XCreateBitmapFromData
1638
 * Signature: (JJJII)J
1639
 */
1640
JNIEXPORT jlong JNICALL Java_sun_awt_X11_XlibWrapper_XCreateBitmapFromData
1641
(JNIEnv *env, jclass clazz, jlong display, jlong drawable, jlong data, jint width, jint height) {
1642
    AWT_CHECK_HAVE_LOCK_RETURN(0);
1643

1644
    return (jlong) XCreateBitmapFromData((Display *) jlong_to_ptr(display), (Drawable) drawable,
1645
                                         (char *) jlong_to_ptr(data), width, height);
1646
}
1647

1648

1649
/*
1650
 * Class:     sun_awt_X11_XlibWrapper
1651
 * Method:    XFreePixmap
1652
 * Signature: (JJ)V
1653
 */
1654
JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XFreePixmap
1655
(JNIEnv *env, jclass clazz, jlong display, jlong pixmap) {
1656
    AWT_CHECK_HAVE_LOCK();
1657
    XFreePixmap((Display *)jlong_to_ptr(display), (Pixmap) pixmap);
1658
}
1659

1660
/*
1661
 * Class:     sun_awt_X11_XlibWrapper
1662
 * Method:    XReparentWindow
1663
 * Signature: (JJJII)V
1664
 */
1665
JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XReparentWindow
1666
(JNIEnv *env, jclass clazz, jlong display, jlong window, jlong parent, jint x, jint y) {
1667
    AWT_CHECK_HAVE_LOCK();
1668
    XReparentWindow((Display*)jlong_to_ptr(display), window, parent, x, y);
1669
}
1670

1671
/*
1672
 * Class:     sun_awt_X11_XlibWrapper
1673
 * Method:    XConvertSelection
1674
 * Signature: (JJJJJJ)V
1675
 */
1676
JNIEXPORT void JNICALL
1677
Java_sun_awt_X11_XlibWrapper_XConvertSelection(JNIEnv *env, jclass clazz,
1678
                           jlong display, jlong selection,
1679
                           jlong target, jlong property,
1680
                           jlong requestor, jlong time) {
1681
    AWT_CHECK_HAVE_LOCK();
1682
    XConvertSelection((Display*)jlong_to_ptr(display), selection, target, property, requestor,
1683
              time);
1684
}
1685

1686
/*
1687
 * Class:     sun_awt_X11_XlibWrapper
1688
 * Method:    XSetSelectionOwner
1689
 * Signature: (JJJJ)V
1690
 */
1691
JNIEXPORT void JNICALL
1692
Java_sun_awt_X11_XlibWrapper_XSetSelectionOwner(JNIEnv *env, jclass clazz,
1693
                        jlong display, jlong selection,
1694
                        jlong owner, jlong time) {
1695
    AWT_CHECK_HAVE_LOCK();
1696
    XSetSelectionOwner((Display*)jlong_to_ptr(display), selection, owner, time);
1697
}
1698

1699
/*
1700
 * Class:     sun_awt_X11_XlibWrapper
1701
 * Method:    XGetSelectionOwner
1702
 * Signature: (JJ)J
1703
 */
1704
JNIEXPORT jlong JNICALL
1705
Java_sun_awt_X11_XlibWrapper_XGetSelectionOwner(JNIEnv *env, jclass clazz,
1706
                        jlong display, jlong selection) {
1707
    AWT_CHECK_HAVE_LOCK_RETURN(0);
1708
    return (jlong)XGetSelectionOwner((Display*)jlong_to_ptr(display), selection);
1709
}
1710

1711
/*
1712
 * Class:     sun_awt_X11_XlibWrapper
1713
 * Method:    XGetAtomName
1714
 * Signature: (JJ)Ljava/lang/String;
1715
 */
1716
JNIEXPORT jstring JNICALL
1717
Java_sun_awt_X11_XlibWrapper_XGetAtomName(JNIEnv *env, jclass clazz,
1718
                      jlong display, jlong atom)
1719
{
1720
    jstring string = NULL;
1721
    char* name;
1722
    AWT_CHECK_HAVE_LOCK_RETURN(NULL);
1723
    name = (char*) XGetAtomName((Display*)jlong_to_ptr(display), atom);
1724

1725
    if (name == NULL) {
1726
        fprintf(stderr, "Atom was %d\n", (int)atom);
1727
        JNU_ThrowNullPointerException(env, "Failed to retrieve atom name.");
1728
        return NULL;
1729
    }
1730

1731
    string = (*env)->NewStringUTF(env, (const char *)name);
1732

1733
    XFree(name);
1734

1735
    return string;
1736
}
1737

1738
/*
1739
 * Class:     sun_awt_X11_XlibWrapper
1740
 * Method:    XMaxRequestSize
1741
 * Signature: (J)J
1742
 */
1743
JNIEXPORT jlong JNICALL
1744
Java_sun_awt_X11_XlibWrapper_XMaxRequestSize(JNIEnv *env, jclass clazz,
1745
                         jlong display) {
1746
    AWT_CHECK_HAVE_LOCK_RETURN(0);
1747
    return XMaxRequestSize((Display*) jlong_to_ptr(display));
1748
}
1749

1750
JNIEXPORT jlong JNICALL
1751
Java_sun_awt_X11_XlibWrapper_XAllocWMHints(JNIEnv *env, jclass clazz)
1752
{
1753
    AWT_CHECK_HAVE_LOCK_RETURN(0);
1754
    return ptr_to_jlong(XAllocWMHints());
1755
}
1756

1757
JNIEXPORT jlong JNICALL
1758
Java_sun_awt_X11_XlibWrapper_XCreatePixmap(JNIEnv *env, jclass clazz, jlong display, jlong drawable, jint width, jint height, jint depth)
1759
{
1760
    AWT_CHECK_HAVE_LOCK_RETURN(0);
1761
    return XCreatePixmap((Display*)jlong_to_ptr(display), (Drawable)drawable, width, height, depth);
1762
}
1763
JNIEXPORT jlong JNICALL
1764
Java_sun_awt_X11_XlibWrapper_XCreateImage
1765
  (JNIEnv *env, jclass clazz, jlong display, jlong visual_ptr,
1766
   jint depth, jint format, jint offset, jlong data, jint width,
1767
   jint height, jint bitmap_pad, jint bytes_per_line)
1768
{
1769
    AWT_CHECK_HAVE_LOCK_RETURN(0);
1770
    return ptr_to_jlong(XCreateImage((Display*) jlong_to_ptr(display), (Visual*) jlong_to_ptr(visual_ptr),
1771
                depth, format, offset, (char*) jlong_to_ptr(data),
1772
                width, height, bitmap_pad, bytes_per_line));
1773
}
1774
JNIEXPORT jlong JNICALL
1775
Java_sun_awt_X11_XlibWrapper_XCreateGC
1776
  (JNIEnv *env, jclass clazz, jlong display, jlong drawable,
1777
   jlong valuemask, jlong values)
1778
{
1779
    AWT_CHECK_HAVE_LOCK_RETURN(0);
1780
    return ptr_to_jlong(XCreateGC((Display*) jlong_to_ptr(display), (Drawable)drawable, valuemask, (XGCValues*) jlong_to_ptr(values)));
1781
}
1782

1783
JNIEXPORT void JNICALL
1784
Java_sun_awt_X11_XlibWrapper_XDestroyImage(JNIEnv *env, jclass clazz, jlong image)
1785
{
1786
    XImage *img = (XImage*) jlong_to_ptr(image);
1787
    AWT_CHECK_HAVE_LOCK();
1788

1789
    // Fix for bug 4903671 :
1790
    // We should be careful to not double free the memory pointed to data
1791
    // Since we use unsafe to allocate it, we should use unsafe to free it.
1792
    // So we should NULL the data pointer before calling XDestroyImage so
1793
    // that X does not free the pointer for us.
1794
    img->data = NULL;
1795
    XDestroyImage(img);
1796
}
1797
JNIEXPORT void JNICALL
1798
Java_sun_awt_X11_XlibWrapper_XPutImage(JNIEnv *env, jclass clazz, jlong display, jlong drawable, jlong gc, jlong image, jint src_x, jint src_y, jint dest_x, jint dest_y, jint width, jint height)
1799
{
1800
    AWT_CHECK_HAVE_LOCK();
1801
    XPutImage((Display*)jlong_to_ptr(display), (Drawable)drawable, (GC) jlong_to_ptr(gc), (XImage*) jlong_to_ptr(image), src_x, src_y,
1802
              dest_x, dest_y, width, height);
1803
}
1804
JNIEXPORT void JNICALL
1805
Java_sun_awt_X11_XlibWrapper_XFreeGC(JNIEnv *env, jclass clazz, jlong display, jlong gc)
1806
{
1807
    AWT_CHECK_HAVE_LOCK();
1808
    XFreeGC((Display*) jlong_to_ptr(display), (GC) jlong_to_ptr(gc));
1809
}
1810
JNIEXPORT void JNICALL
1811
Java_sun_awt_X11_XlibWrapper_XSetWindowBackgroundPixmap(JNIEnv *env, jclass clazz, jlong display, jlong window, jlong pixmap)
1812
{
1813
    AWT_CHECK_HAVE_LOCK();
1814
    XSetWindowBackgroundPixmap((Display*) jlong_to_ptr(display), (Window)window, (Pixmap)pixmap);
1815
}
1816
JNIEXPORT void JNICALL
1817
Java_sun_awt_X11_XlibWrapper_XClearWindow(JNIEnv *env, jclass clazz, jlong display, jlong window)
1818
{
1819
    AWT_CHECK_HAVE_LOCK();
1820
    XClearWindow((Display*) jlong_to_ptr(display), (Window)window);
1821
}
1822

1823
JNIEXPORT jint JNICALL
1824
Java_sun_awt_X11_XlibWrapper_XGetIconSizes(JNIEnv *env, jclass clazz, jlong display, jlong window, jlong ret_sizes, jlong ret_count)
1825
{
1826
    XIconSize** psize = (XIconSize**) jlong_to_ptr(ret_sizes);
1827
    int * pcount = (int *) jlong_to_ptr(ret_count);
1828
    Status res;
1829
    AWT_CHECK_HAVE_LOCK_RETURN(0);
1830
    res = XGetIconSizes((Display*) jlong_to_ptr(display), (Window)window, psize, pcount);
1831
    return res;
1832
}
1833

1834
JNIEXPORT jint JNICALL Java_sun_awt_X11_XlibWrapper_XdbeQueryExtension
1835
  (JNIEnv *env, jclass clazz, jlong display, jlong major_version_return,
1836
   jlong minor_version_return)
1837
{
1838
    AWT_CHECK_HAVE_LOCK_RETURN(0);
1839
    return XdbeQueryExtension((Display*) jlong_to_ptr(display), (int *) jlong_to_ptr(major_version_return),
1840
                  (int *) jlong_to_ptr(minor_version_return));
1841
}
1842

1843
JNIEXPORT jboolean JNICALL Java_sun_awt_X11_XlibWrapper_XQueryExtension
1844
  (JNIEnv *env, jclass clazz, jlong display, jstring jstr, jlong mop_return,
1845
   jlong feve_return, jlong err_return)
1846
{
1847
    char *cname;
1848
    Boolean bu;
1849
    if (!JNU_IsNull(env, jstr)) {
1850
        cname = (char *)JNU_GetStringPlatformChars(env, jstr, NULL);
1851
        CHECK_NULL_RETURN(cname, JNI_FALSE);
1852
    } else {
1853
        cname = "";
1854
    }
1855

1856
    AWT_CHECK_HAVE_LOCK_RETURN(JNI_FALSE);
1857
    bu = XQueryExtension((Display*) jlong_to_ptr(display), cname, (int *) jlong_to_ptr(mop_return),
1858
                (int *) jlong_to_ptr(feve_return),  (int *) jlong_to_ptr(err_return));
1859
    if (!JNU_IsNull(env, jstr)) {
1860
        JNU_ReleaseStringPlatformChars(env, jstr, (const char *) cname);
1861
    }
1862
    return bu ? JNI_TRUE : JNI_FALSE;
1863
}
1864

1865
JNIEXPORT jboolean JNICALL Java_sun_awt_X11_XlibWrapper_IsKeypadKey
1866
  (JNIEnv *env, jclass clazz, jlong keysym)
1867
{
1868
    AWT_CHECK_HAVE_LOCK_RETURN(JNI_FALSE);
1869
    if(IsKeypadKey(keysym)) {
1870
        return JNI_TRUE;
1871
    }
1872
    return JNI_FALSE;
1873
}
1874

1875
JNIEXPORT jlong JNICALL Java_sun_awt_X11_XlibWrapper_XdbeAllocateBackBufferName
1876
  (JNIEnv *env, jclass clazz, jlong display, jlong window, jint swap_action)
1877
{
1878
    AWT_CHECK_HAVE_LOCK_RETURN(0);
1879
    return XdbeAllocateBackBufferName((Display*) jlong_to_ptr(display), (Window) window,
1880
                      (XdbeSwapAction) swap_action);
1881
}
1882

1883
JNIEXPORT jint JNICALL Java_sun_awt_X11_XlibWrapper_XdbeDeallocateBackBufferName
1884
  (JNIEnv *env, jclass clazz, jlong display, jlong buffer)
1885
{
1886
    AWT_CHECK_HAVE_LOCK_RETURN(0);
1887
    return XdbeDeallocateBackBufferName((Display*) jlong_to_ptr(display), (XdbeBackBuffer) buffer);
1888
}
1889

1890
JNIEXPORT jint JNICALL Java_sun_awt_X11_XlibWrapper_XdbeBeginIdiom
1891
  (JNIEnv *env, jclass clazz, jlong display)
1892
{
1893
    AWT_CHECK_HAVE_LOCK_RETURN(0);
1894
    return XdbeBeginIdiom((Display*) jlong_to_ptr(display));
1895
}
1896

1897
JNIEXPORT jint JNICALL Java_sun_awt_X11_XlibWrapper_XdbeEndIdiom
1898
  (JNIEnv *env, jclass clazz, jlong display)
1899
{
1900
    AWT_CHECK_HAVE_LOCK_RETURN(0);
1901
    return XdbeEndIdiom((Display*) jlong_to_ptr(display));
1902
}
1903

1904
JNIEXPORT jint JNICALL Java_sun_awt_X11_XlibWrapper_XdbeSwapBuffers
1905
  (JNIEnv *env, jclass clazz, jlong display, jlong swap_info, jint num_windows)
1906
{
1907
    AWT_CHECK_HAVE_LOCK_RETURN(0);
1908
    return XdbeSwapBuffers((Display*) jlong_to_ptr(display), (XdbeSwapInfo *) jlong_to_ptr(swap_info), num_windows);
1909
}
1910
JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XQueryKeymap
1911
(JNIEnv *env, jclass clazz, jlong display, jlong vector)
1912
{
1913

1914
    AWT_CHECK_HAVE_LOCK();
1915
    XQueryKeymap( (Display *) jlong_to_ptr(display), (char *) jlong_to_ptr(vector));
1916
}
1917

1918
JNIEXPORT jlong JNICALL
1919
Java_sun_awt_X11_XlibWrapper_XKeycodeToKeysym(JNIEnv *env, jclass clazz,
1920
                                              jlong display, jint keycode,
1921
                                              jint index) {
1922
    AWT_CHECK_HAVE_LOCK_RETURN(0);
1923
    return XKeycodeToKeysym((Display*) jlong_to_ptr(display), (unsigned int)keycode, (int)index);
1924
}
1925

1926
JNIEXPORT jint JNICALL
1927
Java_sun_awt_X11_XlibWrapper_XkbGetEffectiveGroup(JNIEnv *env, jclass clazz,
1928
                                              jlong display) {
1929
    XkbStateRec sr;
1930
    AWT_CHECK_HAVE_LOCK_RETURN(0);
1931
    memset(&sr, 0, sizeof(XkbStateRec));
1932
    XkbGetState((Display*) jlong_to_ptr(display), XkbUseCoreKbd, &sr);
1933
//    printf("-------------------------------------VVVV\n");
1934
//    printf("                 group:0x%0X\n",sr.group);
1935
//    printf("            base_group:0x%0X\n",sr.base_group);
1936
//    printf("         latched_group:0x%0X\n",sr.latched_group);
1937
//    printf("          locked_group:0x%0X\n",sr.locked_group);
1938
//    printf("                  mods:0x%0X\n",sr.mods);
1939
//    printf("             base_mods:0x%0X\n",sr.base_mods);
1940
//    printf("          latched_mods:0x%0X\n",sr.latched_mods);
1941
//    printf("           locked_mods:0x%0X\n",sr.locked_mods);
1942
//    printf("          compat_state:0x%0X\n",sr.compat_state);
1943
//    printf("             grab_mods:0x%0X\n",sr.grab_mods);
1944
//    printf("      compat_grab_mods:0x%0X\n",sr.compat_grab_mods);
1945
//    printf("           lookup_mods:0x%0X\n",sr.lookup_mods);
1946
//    printf("    compat_lookup_mods:0x%0X\n",sr.compat_lookup_mods);
1947
//    printf("           ptr_buttons:0x%0X\n",sr.ptr_buttons);
1948
//    printf("-------------------------------------^^^^\n");
1949
    return (jint)(sr.group);
1950
}
1951
JNIEXPORT jlong JNICALL
1952
Java_sun_awt_X11_XlibWrapper_XkbKeycodeToKeysym(JNIEnv *env, jclass clazz,
1953
                                              jlong display, jint keycode,
1954
                                              jint group, jint level) {
1955
    AWT_CHECK_HAVE_LOCK_RETURN(0);
1956
    return XkbKeycodeToKeysym((Display*) jlong_to_ptr(display), (unsigned int)keycode, (unsigned int)group, (unsigned int)level);
1957
}
1958

1959
JNIEXPORT jint JNICALL
1960
Java_sun_awt_X11_XlibWrapper_XKeysymToKeycode(JNIEnv *env, jclass clazz,
1961
                                              jlong display, jlong keysym) {
1962
    AWT_CHECK_HAVE_LOCK_RETURN(0);
1963
    return XKeysymToKeycode((Display*) jlong_to_ptr(display), (KeySym)keysym);
1964
}
1965

1966
JNIEXPORT jlong JNICALL
1967
Java_sun_awt_X11_XlibWrapper_XGetModifierMapping(JNIEnv *env, jclass clazz,
1968
                                              jlong display) {
1969
    AWT_CHECK_HAVE_LOCK_RETURN(0);
1970
    return ptr_to_jlong(XGetModifierMapping((Display*) jlong_to_ptr(display)));
1971
}
1972

1973
JNIEXPORT void JNICALL
1974
Java_sun_awt_X11_XlibWrapper_XFreeModifiermap(JNIEnv *env, jclass clazz,
1975
                                              jlong keymap) {
1976
    AWT_CHECK_HAVE_LOCK();
1977
    XFreeModifiermap((XModifierKeymap*) jlong_to_ptr(keymap));
1978
}
1979
/*
1980
 * Class:     sun_awt_X11_XlibWrapper
1981
 * Method:    XRefreshKeyboardMapping
1982
 * Signature: (J)V
1983
 */
1984
JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XRefreshKeyboardMapping
1985
(JNIEnv *env, jclass clazz, jlong event_ptr)
1986
{
1987
    AWT_CHECK_HAVE_LOCK();
1988
    XRefreshKeyboardMapping((XMappingEvent*) jlong_to_ptr(event_ptr));
1989
}
1990

1991
JNIEXPORT void JNICALL
1992
Java_sun_awt_X11_XlibWrapper_XChangeActivePointerGrab(JNIEnv *env, jclass clazz,
1993
                                                      jlong display, jint mask,
1994
                                                      jlong cursor, jlong time) {
1995
    AWT_CHECK_HAVE_LOCK();
1996
    XChangeActivePointerGrab((Display*)jlong_to_ptr(display), (unsigned int)mask,
1997
                             (Cursor)cursor, (Time)time);
1998
}
1999

2000
/******************* Secondary loop support ************************************/
2001
#define AWT_SECONDARY_LOOP_TIMEOUT 250
2002

2003
static Bool exitSecondaryLoop = True;
2004

2005
/*
2006
 * This predicate procedure allows the Toolkit thread to process specific events
2007
 * while it is blocked waiting for the event dispatch thread to process
2008
 * a SunDropTargetEvent. We need this to prevent deadlock when the client code
2009
 * processing SunDropTargetEvent sets or gets the contents of the system
2010
 * clipboard/selection. In this case the event dispatch thread waits for the
2011
 * Toolkit thread to process PropertyNotify or SelectionNotify events.
2012
 */
2013
static Bool
2014
secondary_loop_event(Display* dpy, XEvent* event, XPointer xawt_root_window) {
2015
    return (
2016
                event->type == SelectionNotify ||
2017
                event->type == SelectionClear  ||
2018
                event->type == PropertyNotify  ||
2019
                (event->type == ConfigureNotify
2020
                    && event->xany.window == *(Window*) xawt_root_window)
2021
            ) ? True : False;
2022
}
2023

2024

2025
JNIEXPORT jboolean JNICALL
2026
Java_sun_awt_X11_XlibWrapper_XNextSecondaryLoopEvent(JNIEnv *env, jclass clazz,
2027
                                                     jlong display, jlong ptr) {
2028
    uint32_t timeout = 1;
2029

2030
    AWT_CHECK_HAVE_LOCK_RETURN(JNI_FALSE);
2031
    exitSecondaryLoop = False;
2032
    Window xawt_root_window = get_xawt_root_shell(env);
2033

2034
    while (!exitSecondaryLoop) {
2035
        if (XCheckIfEvent((Display*) jlong_to_ptr(display),
2036
                (XEvent*) jlong_to_ptr(ptr), secondary_loop_event, (XPointer) &xawt_root_window)) {
2037
            return JNI_TRUE;
2038
        }
2039
        timeout = (timeout < AWT_SECONDARY_LOOP_TIMEOUT) ? (timeout << 1) : AWT_SECONDARY_LOOP_TIMEOUT;
2040
        AWT_WAIT(timeout);
2041
    }
2042
    return JNI_FALSE;
2043
}
2044

2045
JNIEXPORT void JNICALL
2046
Java_sun_awt_X11_XlibWrapper_ExitSecondaryLoop(JNIEnv *env, jclass clazz) {
2047
    DASSERT(!exitSecondaryLoop);
2048
    AWT_CHECK_HAVE_LOCK();
2049
    exitSecondaryLoop = True;
2050
    AWT_NOTIFY_ALL();
2051
}
2052
/*******************************************************************************/
2053

2054
JNIEXPORT jobjectArray JNICALL
2055
Java_sun_awt_X11_XlibWrapper_XTextPropertyToStringList(JNIEnv *env,
2056
                                                       jclass clazz,
2057
                                                       jbyteArray bytes,
2058
                                                       jlong encodingAtom) {
2059
    XTextProperty tp;
2060
    jbyte         *value;
2061

2062
    char**        strings  = (char **)NULL;
2063
    int32_t       nstrings = 0;
2064
    jobjectArray  ret = NULL;
2065
    int32_t       i;
2066
    jsize         len;
2067
    jboolean      isCopy = JNI_FALSE;
2068
    static jclass stringClass = NULL;
2069
    jclass        stringClassLocal = NULL;
2070

2071
    AWT_CHECK_HAVE_LOCK_RETURN(NULL);
2072

2073
    if (JNU_IsNull(env, stringClass)) {
2074
        stringClassLocal = (*env)->FindClass(env, "java/lang/String");
2075

2076
        if ((*env)->ExceptionCheck(env)) {
2077
            (*env)->ExceptionDescribe(env);
2078
            (*env)->ExceptionClear(env);
2079
            DASSERT(False);
2080
        }
2081

2082
        if (JNU_IsNull(env, stringClassLocal)) {
2083
            return NULL;
2084
        }
2085

2086
        stringClass = (*env)->NewGlobalRef(env, stringClassLocal); /* never freed! */
2087
        (*env)->DeleteLocalRef(env, stringClassLocal);
2088

2089
        if (JNU_IsNull(env, stringClass)) {
2090
            JNU_ThrowOutOfMemoryError(env, "");
2091
            return NULL;
2092
        }
2093
    }
2094

2095
    /*
2096
     * If the length of the byte array is 0 just return a null
2097
     */
2098
    len = (*env)->GetArrayLength(env, bytes);
2099
    if (len == 0) {
2100
        return (*env)->NewObjectArray(env, 0, stringClass, NULL);
2101
    }
2102

2103
    value = (*env)->GetByteArrayElements(env, bytes, &isCopy);
2104
    if (JNU_IsNull(env, value)) {
2105
        return NULL;
2106
    }
2107

2108
    tp.encoding = encodingAtom;
2109
    tp.value    = (unsigned char *)value;
2110
    tp.nitems   = len;
2111
    tp.format   = 8;
2112

2113
    /*
2114
     * Convert the byte stream into a list of X11 strings
2115
     */
2116
    if (XTextPropertyToStringList(&tp, &strings, &nstrings) == 0) {
2117
        (*env)->ReleaseByteArrayElements(env, bytes, value, JNI_ABORT);
2118
        return NULL;
2119
    }
2120

2121
    (*env)->ReleaseByteArrayElements(env, bytes, value, JNI_ABORT);
2122

2123
    if (nstrings == 0) {
2124
        return (*env)->NewObjectArray(env, 0, stringClass, NULL);
2125
    }
2126

2127
    ret = (*env)->NewObjectArray(env, nstrings, stringClass, NULL);
2128

2129
    if ((*env)->ExceptionCheck(env)) {
2130
        (*env)->ExceptionDescribe(env);
2131
        (*env)->ExceptionClear(env);
2132
        goto wayout;
2133
    }
2134

2135
    if (JNU_IsNull(env, ret)) {
2136
        goto wayout;
2137
    }
2138

2139
    for (i = 0; i < nstrings; i++) {
2140
        jstring string = (*env)->NewStringUTF(env,
2141
                                              (const char *)strings[i]);
2142
        if ((*env)->ExceptionCheck(env)) {
2143
            (*env)->ExceptionDescribe(env);
2144
            (*env)->ExceptionClear(env);
2145
            goto wayout;
2146
        }
2147

2148
        if (JNU_IsNull(env, string)) {
2149
            goto wayout;
2150
        }
2151

2152
        (*env)->SetObjectArrayElement(env, ret, i, string);
2153

2154
        if ((*env)->ExceptionCheck(env)) {
2155
            (*env)->ExceptionDescribe(env);
2156
            (*env)->ExceptionClear(env);
2157
            goto wayout;
2158
        }
2159

2160
        (*env)->DeleteLocalRef(env, string);
2161
    }
2162

2163
 wayout:
2164
    /*
2165
     * Clean up and return
2166
     */
2167
    XFreeStringList(strings);
2168
    return ret;
2169
}
2170

2171

2172
JNIEXPORT void JNICALL
2173
Java_sun_awt_X11_XlibWrapper_XPutBackEvent(JNIEnv *env,
2174
                                           jclass clazz,
2175
                                           jlong display,
2176
                                           jlong event) {
2177
    XPutBackEvent((Display*)jlong_to_ptr(display), (XEvent*) jlong_to_ptr(event));
2178
}
2179

2180
JNIEXPORT jlong JNICALL
2181
Java_sun_awt_X11_XlibWrapper_getAddress(JNIEnv *env,
2182
                                           jclass clazz,
2183
                                           jobject o) {
2184
    return ptr_to_jlong(o);
2185
}
2186

2187
JNIEXPORT void JNICALL
2188
Java_sun_awt_X11_XlibWrapper_copyIntArray(JNIEnv *env,
2189
                                           jclass clazz,
2190
                                           jlong dest, jobject array, jint size) {
2191
    jboolean isCopy = JNI_FALSE;
2192
    jint * ints = (*env)->GetIntArrayElements(env, array, &isCopy);
2193
    memcpy(jlong_to_ptr(dest), ints, size);
2194
    if (isCopy) {
2195
        (*env)->ReleaseIntArrayElements(env, array, ints, JNI_ABORT);
2196
    }
2197
}
2198

2199
JNIEXPORT void JNICALL
2200
Java_sun_awt_X11_XlibWrapper_copyLongArray(JNIEnv *env,
2201
                                           jclass clazz,
2202
                                           jlong dest, jobject array, jint size) {
2203
    jboolean isCopy = JNI_FALSE;
2204
    jlong * longs = (*env)->GetLongArrayElements(env, array, &isCopy);
2205
    memcpy(jlong_to_ptr(dest), longs, size);
2206
    if (isCopy) {
2207
        (*env)->ReleaseLongArrayElements(env, array, longs, JNI_ABORT);
2208
    }
2209
}
2210

2211
JNIEXPORT jint JNICALL
2212
Java_sun_awt_X11_XlibWrapper_XSynchronize(JNIEnv *env, jclass clazz, jlong display, jboolean onoff)
2213
{
2214
    return (jint) XSynchronize((Display*)jlong_to_ptr(display), (onoff == JNI_TRUE ? True : False));
2215
}
2216

2217
JNIEXPORT jboolean JNICALL
2218
Java_sun_awt_X11_XlibWrapper_XShapeQueryExtension
2219
(JNIEnv *env, jclass clazz, jlong display, jlong event_base_return, jlong error_base_return)
2220
{
2221
    jboolean status;
2222

2223
    AWT_CHECK_HAVE_LOCK_RETURN(JNI_FALSE);
2224

2225
    status = XShapeQueryExtension((Display *)jlong_to_ptr(display),
2226
            (int *)jlong_to_ptr(event_base_return), (int *)jlong_to_ptr(error_base_return));
2227
    return status;
2228
}
2229

2230
/*
2231
 * Class:     XlibWrapper
2232
 * Method:    SetRectangularShape
2233
 */
2234

2235
JNIEXPORT void JNICALL
2236
Java_sun_awt_X11_XlibWrapper_SetRectangularShape
2237
(JNIEnv *env, jclass clazz, jlong display, jlong window,
2238
 jint x1, jint y1, jint x2, jint y2,
2239
 jobject region)
2240
{
2241
    AWT_CHECK_HAVE_LOCK();
2242

2243
    // If all the params are zeros, the shape must be simply reset.
2244
    // Otherwise, the shape may be not rectangular.
2245
    if (region || x1 || x2 || y1 || y2) {
2246
        XRectangle rects[256];
2247
        XRectangle *pRect = rects;
2248

2249
        int numrects = RegionToYXBandedRectangles(env, x1, y1, x2, y2, region,
2250
                &pRect, 256);
2251

2252
        XShapeCombineRectangles((Display *)jlong_to_ptr(display), (Window)jlong_to_ptr(window),
2253
                ShapeClip, 0, 0, pRect, numrects, ShapeSet, YXBanded);
2254
        XShapeCombineRectangles((Display *)jlong_to_ptr(display), (Window)jlong_to_ptr(window),
2255
                ShapeBounding, 0, 0, pRect, numrects, ShapeSet, YXBanded);
2256

2257
        if (pRect != rects) {
2258
            free(pRect);
2259
        }
2260
    } else {
2261
        // Reset the shape to a rectangular form.
2262
        XShapeCombineMask((Display *)jlong_to_ptr(display), (Window)jlong_to_ptr(window),
2263
                ShapeClip, 0, 0, None, ShapeSet);
2264
        XShapeCombineMask((Display *)jlong_to_ptr(display), (Window)jlong_to_ptr(window),
2265
                ShapeBounding, 0, 0, None, ShapeSet);
2266
    }
2267
}
2268

2269
/*
2270
 * Class:     XlibWrapper
2271
 * Method:    SetZOrder
2272
 */
2273

2274
JNIEXPORT void JNICALL
2275
Java_sun_awt_X11_XlibWrapper_SetZOrder
2276
(JNIEnv *env, jclass clazz, jlong display, jlong window, jlong above)
2277
{
2278
    unsigned int value_mask = CWStackMode;
2279

2280
    XWindowChanges wc;
2281
    wc.sibling = (Window)jlong_to_ptr(above);
2282

2283
    AWT_CHECK_HAVE_LOCK();
2284

2285
    if (above == 0) {
2286
        wc.stack_mode = Above;
2287
    } else {
2288
        wc.stack_mode = Below;
2289
        value_mask |= CWSibling;
2290
    }
2291

2292
    XConfigureWindow((Display *)jlong_to_ptr(display),
2293
                     (Window)jlong_to_ptr(window),
2294
                     value_mask, &wc );
2295
}
2296

2297
/*
2298
 * Class:     XlibWrapper
2299
 * Method:    SetBitmapShape
2300
 */
2301
JNIEXPORT void JNICALL
2302
Java_sun_awt_X11_XlibWrapper_SetBitmapShape
2303
(JNIEnv *env, jclass clazz, jlong display, jlong window,
2304
 jint width, jint height, jintArray bitmap)
2305
{
2306
    jsize len;
2307
    jint *values;
2308
    jboolean isCopy = JNI_FALSE;
2309
    size_t worstBufferSize = (size_t)((width / 2 + 1) * height);
2310
    RECT_T * pRect;
2311
    int numrects;
2312

2313
    if (!IS_SAFE_SIZE_MUL(width / 2 + 1, height)) {
2314
        return;
2315
    }
2316

2317
    AWT_CHECK_HAVE_LOCK();
2318

2319
    len = (*env)->GetArrayLength(env, bitmap);
2320
    if (len == 0 || len < width * height) {
2321
        return;
2322
    }
2323

2324
    values = (*env)->GetIntArrayElements(env, bitmap, &isCopy);
2325
    if (JNU_IsNull(env, values)) {
2326
        return;
2327
    }
2328

2329
    pRect = (RECT_T *)SAFE_SIZE_ARRAY_ALLOC(malloc, worstBufferSize, sizeof(RECT_T));
2330
    if (!pRect) {
2331
        return;
2332
    }
2333

2334
    /* Note: the values[0] and values[1] are supposed to contain the width
2335
     * and height (see XIconInfo.getIntData() for details). So, we do +2.
2336
     */
2337
    numrects = BitmapToYXBandedRectangles(32, (int)width, (int)height,
2338
            (unsigned char *)(values + 2), pRect);
2339

2340
    XShapeCombineRectangles((Display *)jlong_to_ptr(display), (Window)jlong_to_ptr(window),
2341
            ShapeClip, 0, 0, pRect, numrects, ShapeSet, YXBanded);
2342
    XShapeCombineRectangles((Display *)jlong_to_ptr(display), (Window)jlong_to_ptr(window),
2343
            ShapeBounding, 0, 0, pRect, numrects, ShapeSet, YXBanded);
2344

2345
    free(pRect);
2346

2347
    (*env)->ReleaseIntArrayElements(env, bitmap, values, JNI_ABORT);
2348
}
2349

2350

2351
Product

Resources

Company
