1 /*
2 * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26 #include "awt_p.h"
27 #include "awt.h"
28 #include "color.h"
29 #include <java_awt_DisplayMode.h>
30 #include <sun_awt_X11GraphicsEnvironment.h>
31 #include <sun_awt_X11GraphicsDevice.h>
32 #include <sun_awt_X11GraphicsConfig.h>
33 #ifndef HEADLESS
34 #include <X11/extensions/Xdbe.h>
35 #include <X11/XKBlib.h>
36 #include "Xrandr.h"
37 #include "GLXGraphicsConfig.h"
38 #endif /* !HEADLESS */
39
40 #include <jni.h>
41 #include <jni_util.h>
42 #include <jvm.h>
43 #include <jvm_md.h>
44 #include <jlong.h>
45
46 #include <stdlib.h>
47
48 #include "awt_GraphicsEnv.h"
49 #include "awt_util.h"
50 #include "gdefs.h"
51 #include <dlfcn.h>
52 #include "Trace.h"
53
54 #ifdef NETSCAPE
55 #include <signal.h>
56 extern int awt_init_xt;
57 #endif
58
59 #ifndef HEADLESS
60
61 int awt_numScreens; /* Xinerama-aware number of screens */
62
63 AwtScreenDataPtr x11Screens;
64
65 /*
66 * Set in initDisplay() to indicate whether we should attempt to initialize
67 * GLX for the default configuration.
68 */
69 static jboolean glxRequested = JNI_FALSE;
70
71 #endif /* !HEADLESS */
72
73 #ifdef HEADLESS
74 #define Display void
75 #endif /* HEADLESS */
76
77 Display *awt_display;
78
79 jclass tkClass = NULL;
80 jmethodID awtLockMID = NULL;
81 jmethodID awtUnlockMID = NULL;
82 jmethodID awtWaitMID = NULL;
83 jmethodID awtNotifyMID = NULL;
84 jmethodID awtNotifyAllMID = NULL;
85 jboolean awtLockInited = JNI_FALSE;
86
87 /** Convenience macro for loading the lock-related method IDs. */
88 #define GET_STATIC_METHOD(klass, method_id, method_name, method_sig) \
89 do { \
90 method_id = (*env)->GetStaticMethodID(env, klass, \
91 method_name, method_sig); \
92 if (method_id == NULL) return NULL; \
93 } while (0)
94
95 struct X11GraphicsConfigIDs x11GraphicsConfigIDs;
96 struct X11GraphicsDeviceIDs x11GraphicsDeviceIDs;
97
98 #ifndef HEADLESS
99 int awtCreateX11Colormap(AwtGraphicsConfigDataPtr adata);
100 #endif /* HEADLESS */
101
102 static char *x11GraphicsConfigClassName = "sun/awt/X11GraphicsConfig";
103
104 /* AWT and Xinerama
105 *
106 * As of fix 4356756, AWT is Xinerama-aware. X11GraphicsDevices are created for
107 * each screen of a Xinerama setup, though X11 itself still only sees a single
108 * display.
109 * In many places where we talk to X11, a xinawareScreen variable is used to
110 * pass the correct Display value, depending on the circumstances (a single
111 * X display, multiple X displays, or a single X display with multiple
112 * Xinerama screens).
113 *
114 * Solaris and Linux differ in the functions used to access Xinerama-related
115 * data. This is in part because at this time, the X consortium has not
116 * finalized the "official" Xinerama API. Once this spec is available, and
117 * both OSes are conformant, one code base should be sufficient for Xinerama
118 * operation on both OSes. Until then, some of the Xinerama-related code
119 * is ifdef'd appropriately. -bchristi, 7/12/01
120 */
121
122 #define MAXFRAMEBUFFERS 16
123 #if defined(__linux__) || defined(MACOSX)
124 typedef struct {
125 int screen_number;
126 short x_org;
127 short y_org;
128 short width;
129 short height;
130 } XineramaScreenInfo;
131
132 typedef XineramaScreenInfo* XineramaQueryScreensFunc(Display*, int*);
133
134 #else /* SOLARIS */
135 typedef Status XineramaGetInfoFunc(Display* display, int screen_number,
136 XRectangle* framebuffer_rects, unsigned char* framebuffer_hints,
137 int* num_framebuffers);
138 typedef Status XineramaGetCenterHintFunc(Display* display, int screen_number,
139 int* x, int* y);
140
141 XineramaGetCenterHintFunc* XineramaSolarisCenterFunc = NULL;
142 #endif
143
144 Bool usingXinerama = False;
145 XRectangle fbrects[MAXFRAMEBUFFERS];
146
147 JNIEXPORT void JNICALL
148 Java_sun_awt_X11GraphicsConfig_initIDs (JNIEnv *env, jclass cls)
149 {
150 x11GraphicsConfigIDs.aData = NULL;
151 x11GraphicsConfigIDs.bitsPerPixel = NULL;
152 x11GraphicsConfigIDs.screen = NULL;
153
154 x11GraphicsConfigIDs.aData = (*env)->GetFieldID (env, cls, "aData", "J");
155 x11GraphicsConfigIDs.bitsPerPixel = (*env)->GetFieldID (env, cls, "bitsPerPixel", "I");
156 x11GraphicsConfigIDs.screen = (*env)->GetFieldID (env, cls, "screen", "Lsun/awt/X11GraphicsDevice;");
157
158 if (x11GraphicsConfigIDs.aData == NULL ||
159 x11GraphicsConfigIDs.bitsPerPixel == NULL ||
160 x11GraphicsConfigIDs.screen == NULL) {
161
162 JNU_ThrowNoSuchFieldError(env, "Can't find a field");
163 return;
164 }
165 }
166
167 JNIEXPORT void JNICALL
168 Java_sun_awt_X11GraphicsDevice_initIDs (JNIEnv *env, jclass cls)
169 {
170 x11GraphicsDeviceIDs.screen = NULL;
171 x11GraphicsDeviceIDs.screen = (*env)->GetFieldID (env, cls, "screen", "I");
172 DASSERT(x11GraphicsDeviceIDs.screen);
173 }
174
175 #ifndef HEADLESS
176
177 /*
178 * XIOErrorHandler
179 */
180 static int xioerror_handler(Display *disp)
181 {
182 if (awtLockInited) {
183 if (errno == EPIPE) {
184 jio_fprintf(stderr, "X connection to %s host broken (explicit kill or server shutdown)\n", XDisplayName(NULL));
185 }
186 /*SignalError(lockedee->lastpc, lockedee, "fp/ade/gui/GUIException", "I/O error"); */
187 }
188 return 0;
189 }
190
191 static AwtGraphicsConfigDataPtr
192 findWithTemplate(XVisualInfo *vinfo,
193 long mask)
194 {
195
196 XVisualInfo *visualList;
197 XColor color;
198 AwtGraphicsConfigDataPtr defaultConfig;
199 int visualsMatched, i;
200
201 visualList = XGetVisualInfo(awt_display,
202 mask, vinfo, &visualsMatched);
203 if (visualList) {
204 defaultConfig = ZALLOC(_AwtGraphicsConfigData);
205 for (i = 0; i < visualsMatched; i++) {
206 memcpy(&defaultConfig->awt_visInfo, &visualList[i], sizeof(XVisualInfo));
207 defaultConfig->awt_depth = visualList[i].depth;
208
209 /* we can't use awtJNI_CreateColorData here, because it'll pull,
210 SystemColor, which in turn will cause toolkit to be reinitialized */
211 if (awtCreateX11Colormap(defaultConfig)) {
212 /* Allocate white and black pixels for this visual */
213 color.flags = DoRed | DoGreen | DoBlue;
214 color.red = color.green = color.blue = 0x0000;
215 XAllocColor(awt_display, defaultConfig->awt_cmap, &color);
216 x11Screens[visualList[i].screen].blackpixel = color.pixel;
217 color.flags = DoRed | DoGreen | DoBlue;
218 color.red = color.green = color.blue = 0xffff;
219 XAllocColor(awt_display, defaultConfig->awt_cmap, &color);
220 x11Screens[visualList[i].screen].whitepixel = color.pixel;
221
222 XFree(visualList);
223 return defaultConfig;
224 }
225 }
226 XFree(visualList);
227 free((void *)defaultConfig);
228 }
229 return NULL;
230 }
231
232 /* default config is based on X11 screen. All Xinerama screens of that X11
233 screen will have the same default config */
234 /* Need more notes about which fields of the structure are based on the X
235 screen, and which are based on the Xinerama screen */
236 static AwtGraphicsConfigDataPtr
237 makeDefaultConfig(JNIEnv *env, int screen) {
238
239 AwtGraphicsConfigDataPtr defaultConfig;
240 int xinawareScreen = 0;
241 VisualID forcedVisualID = 0, defaultVisualID;
242 char *forcedVisualStr;
243 XVisualInfo vinfo;
244 long mask;
245
246 xinawareScreen = usingXinerama ? 0 : screen;
247 defaultVisualID =
248 XVisualIDFromVisual(DefaultVisual(awt_display, xinawareScreen));
249
250 memset(&vinfo, 0, sizeof(XVisualInfo));
251 vinfo.screen = xinawareScreen;
252
253 if ((forcedVisualStr = getenv("FORCEDEFVIS"))) {
254 mask = VisualIDMask | VisualScreenMask;
255 if (sscanf(forcedVisualStr, "%lx", &forcedVisualID) > 0 &&
256 forcedVisualID > 0)
257 {
258 vinfo.visualid = forcedVisualID;
259 } else {
260 vinfo.visualid = defaultVisualID;
261 }
262 } else {
263 VisualID bestGLXVisualID;
264 if (glxRequested &&
265 (bestGLXVisualID = GLXGC_FindBestVisual(env, xinawareScreen)) > 0)
266 {
267 /* we've found the best visual for use with GLX, so use it */
268 vinfo.visualid = bestGLXVisualID;
269 mask = VisualIDMask | VisualScreenMask;
270 } else {
271 /* otherwise, continue looking for the best X11 visual */
272 vinfo.depth = 24;
273 vinfo.class = TrueColor;
274 mask = VisualDepthMask | VisualScreenMask | VisualClassMask;
275 }
276 }
277
278 /* try the best, or forced visual */
279 defaultConfig = findWithTemplate(&vinfo, mask);
280 if (defaultConfig) {
281 return defaultConfig;
282 }
283
284 /* try the default visual */
285 vinfo.visualid = defaultVisualID;
286 mask = VisualIDMask | VisualScreenMask;
287 defaultConfig = findWithTemplate(&vinfo, mask);
288 if (defaultConfig) {
289 return defaultConfig;
290 }
291
292 /* try any TrueColor */
293 vinfo.class = TrueColor;
294 mask = VisualScreenMask | VisualClassMask;
295 defaultConfig = findWithTemplate(&vinfo, mask);
296 if (defaultConfig) {
297 return defaultConfig;
298 }
299
300 /* try 8-bit PseudoColor */
301 vinfo.depth = 8;
302 vinfo.class = PseudoColor;
303 mask = VisualDepthMask | VisualScreenMask | VisualClassMask;
304 defaultConfig = findWithTemplate(&vinfo, mask);
305 if (defaultConfig) {
306 return defaultConfig;
307 }
308
309 /* try any 8-bit */
310 vinfo.depth = 8;
311 mask = VisualDepthMask | VisualScreenMask;
312 defaultConfig = findWithTemplate(&vinfo, mask);
313 if (defaultConfig) {
314 return defaultConfig;
315 }
316
317 /* we tried everything, give up */
318 JNU_ThrowInternalError(env, "Can't find supported visual");
319 XCloseDisplay(awt_display);
320 awt_display = NULL;
321 return NULL;
322 }
323
324 static void
325 getAllConfigs (JNIEnv *env, int screen, AwtScreenDataPtr screenDataPtr) {
326
327 int i;
328 int n8p=0, n12p=0, n8s=0, n8gs=0, n8sg=0, n1sg=0, nTrue=0;
329 int nConfig;
330 XVisualInfo *pVI8p, *pVI12p, *pVI8s, *pVITrue, *pVI8gs,
331 *pVI8sg, *pVI1sg = NULL, viTmp;
332 AwtGraphicsConfigDataPtr *graphicsConfigs;
333 AwtGraphicsConfigDataPtr defaultConfig;
334 int ind;
335 char errmsg[128];
336 int xinawareScreen;
337 void* xrenderLibHandle = NULL;
338 XRenderFindVisualFormatFunc* xrenderFindVisualFormat = NULL;
339 int major_opcode, first_event, first_error;
340
341 if (usingXinerama) {
342 xinawareScreen = 0;
343 }
344 else {
345 xinawareScreen = screen;
346 }
347
348 AWT_LOCK ();
349
350 viTmp.screen = xinawareScreen;
351
352 viTmp.depth = 8;
353 viTmp.class = PseudoColor;
354 viTmp.colormap_size = 256;
355 pVI8p = XGetVisualInfo (awt_display,
356 VisualDepthMask | VisualClassMask |
357 VisualColormapSizeMask | VisualScreenMask,
358 &viTmp, &n8p);
359
360 viTmp.depth = 12;
361 viTmp.class = PseudoColor;
362 viTmp.colormap_size = 4096;
363 pVI12p = XGetVisualInfo (awt_display,
364 VisualDepthMask | VisualClassMask |
365 VisualColormapSizeMask | VisualScreenMask,
366 &viTmp, &n12p);
367
368 viTmp.class = TrueColor;
369 pVITrue = XGetVisualInfo (awt_display,
370 VisualClassMask |
371 VisualScreenMask,
372 &viTmp, &nTrue);
373
374 viTmp.depth = 8;
375 viTmp.class = StaticColor;
376 pVI8s = XGetVisualInfo (awt_display, VisualDepthMask | VisualClassMask |
377 VisualScreenMask, &viTmp, &n8s);
378
379 viTmp.depth = 8;
380 viTmp.class = GrayScale;
381 viTmp.colormap_size = 256;
382 pVI8gs = XGetVisualInfo (awt_display,
383 VisualDepthMask | VisualClassMask |
384 VisualColormapSizeMask | VisualScreenMask,
385 &viTmp, &n8gs);
386 viTmp.depth = 8;
387 viTmp.class = StaticGray;
388 viTmp.colormap_size = 256;
389 pVI8sg = XGetVisualInfo (awt_display,
390 VisualDepthMask | VisualClassMask |
391 VisualColormapSizeMask | VisualScreenMask,
392 &viTmp, &n8sg);
393
394 /* REMIND.. remove when we have support for the color classes below */
395 /* viTmp.depth = 1; */
396 /* viTmp.class = StaticGray; */
397 /* pVI1sg = XGetVisualInfo (awt_display, VisualDepthMask | VisualClassMask, */
398 /* viTmp, &n1sg); */
399
400 nConfig = n8p + n12p + n8s + n8gs + n8sg + n1sg + nTrue + 1;
401 graphicsConfigs = (AwtGraphicsConfigDataPtr *)
402 calloc(nConfig, sizeof(AwtGraphicsConfigDataPtr));
403 if (graphicsConfigs == NULL) {
404 JNU_ThrowOutOfMemoryError((JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2),
405 NULL);
406 AWT_UNLOCK();
407 return;
408 }
409
410 if (screenDataPtr->defaultConfig == NULL) {
411 /*
412 * After a display change event, the default config field will have
413 * been reset, so we need to recreate the default config here.
414 */
415 screenDataPtr->defaultConfig = makeDefaultConfig(env, screen);
416 }
417
418 defaultConfig = screenDataPtr->defaultConfig;
419 graphicsConfigs[0] = defaultConfig;
420 nConfig = 1; /* reserve index 0 for default config */
421
422 // Only use the RENDER extension if it is available on the X server
423 if (XQueryExtension(awt_display, "RENDER",
424 &major_opcode, &first_event, &first_error))
425 {
426 xrenderLibHandle = dlopen("libXrender.so.1", RTLD_LAZY | RTLD_GLOBAL);
427
428 #ifdef MACOSX
429 #define XRENDER_LIB "/usr/X11/lib/libXrender.dylib"
430 #else
431 #define XRENDER_LIB "libXrender.so"
432 #endif
433
434 if (xrenderLibHandle == NULL) {
435 xrenderLibHandle = dlopen(XRENDER_LIB,
436 RTLD_LAZY | RTLD_GLOBAL);
437 }
438
439 #ifndef __linux__ /* SOLARIS */
440 if (xrenderLibHandle == NULL) {
441 xrenderLibHandle = dlopen("/usr/sfw/lib/libXrender.so.1",
442 RTLD_LAZY | RTLD_GLOBAL);
443 }
444 #endif
445
446 if (xrenderLibHandle != NULL) {
447 xrenderFindVisualFormat =
448 (XRenderFindVisualFormatFunc*)dlsym(xrenderLibHandle,
449 "XRenderFindVisualFormat");
450 }
451 }
452
453 for (i = 0; i < nTrue; i++) {
454 if (XVisualIDFromVisual(pVITrue[i].visual) ==
455 XVisualIDFromVisual(defaultConfig->awt_visInfo.visual) ||
456 pVITrue[i].depth == 12) {
457 /* Skip the non-supported 12-bit TrueColor visual */
458 continue;
459 } else {
460 ind = nConfig++;
461 }
462 graphicsConfigs [ind] = ZALLOC (_AwtGraphicsConfigData);
463 graphicsConfigs [ind]->awt_depth = pVITrue [i].depth;
464 memcpy (&graphicsConfigs [ind]->awt_visInfo, &pVITrue [i],
465 sizeof (XVisualInfo));
466 if (xrenderFindVisualFormat != NULL) {
467 XRenderPictFormat *format = xrenderFindVisualFormat (awt_display,
468 pVITrue [i].visual);
469 if (format &&
470 format->type == PictTypeDirect &&
471 format->direct.alphaMask)
472 {
473 graphicsConfigs [ind]->isTranslucencySupported = 1;
474 memcpy(&graphicsConfigs [ind]->renderPictFormat, format,
475 sizeof(*format));
476 }
477 }
478 }
479
480 if (xrenderLibHandle != NULL) {
481 dlclose(xrenderLibHandle);
482 xrenderLibHandle = NULL;
483 }
484
485 for (i = 0; i < n8p; i++) {
486 if (XVisualIDFromVisual(pVI8p[i].visual) ==
487 XVisualIDFromVisual(defaultConfig->awt_visInfo.visual)) {
488 continue;
489 } else {
490 ind = nConfig++;
491 }
492 graphicsConfigs [ind] = ZALLOC (_AwtGraphicsConfigData);
493 graphicsConfigs [ind]->awt_depth = pVI8p [i].depth;
494 memcpy (&graphicsConfigs [ind]->awt_visInfo, &pVI8p [i],
495 sizeof (XVisualInfo));
496 }
497
498 for (i = 0; i < n12p; i++) {
499 if (XVisualIDFromVisual(pVI12p[i].visual) ==
500 XVisualIDFromVisual(defaultConfig->awt_visInfo.visual)) {
501 continue;
502 } else {
503 ind = nConfig++;
504 }
505 graphicsConfigs [ind] = ZALLOC (_AwtGraphicsConfigData);
506 graphicsConfigs [ind]->awt_depth = pVI12p [i].depth;
507 memcpy (&graphicsConfigs [ind]->awt_visInfo, &pVI12p [i],
508 sizeof (XVisualInfo));
509 }
510
511 for (i = 0; i < n8s; i++) {
512 if (XVisualIDFromVisual(pVI8s[i].visual) ==
513 XVisualIDFromVisual(defaultConfig->awt_visInfo.visual)) {
514 continue;
515 } else {
516 ind = nConfig++;
517 }
518 graphicsConfigs [ind] = ZALLOC (_AwtGraphicsConfigData);
519 graphicsConfigs [ind]->awt_depth = pVI8s [i].depth;
520 memcpy (&graphicsConfigs [ind]->awt_visInfo, &pVI8s [i],
521 sizeof (XVisualInfo));
522 }
523
524 for (i = 0; i < n8gs; i++) {
525 if (XVisualIDFromVisual(pVI8gs[i].visual) ==
526 XVisualIDFromVisual(defaultConfig->awt_visInfo.visual)) {
527 continue;
528 } else {
529 ind = nConfig++;
530 }
531 graphicsConfigs [ind] = ZALLOC (_AwtGraphicsConfigData);
532 graphicsConfigs [ind]->awt_depth = pVI8gs [i].depth;
533 memcpy (&graphicsConfigs [ind]->awt_visInfo, &pVI8gs [i],
534 sizeof (XVisualInfo));
535 }
536
537 for (i = 0; i < n8sg; i++) {
538 if (XVisualIDFromVisual(pVI8sg[i].visual) ==
539 XVisualIDFromVisual(defaultConfig->awt_visInfo.visual)) {
540 continue;
541 } else {
542 ind = nConfig++;
543 }
544 graphicsConfigs [ind] = ZALLOC (_AwtGraphicsConfigData);
545 graphicsConfigs [ind]->awt_depth = pVI8sg [i].depth;
546 memcpy (&graphicsConfigs [ind]->awt_visInfo, &pVI8sg [i],
547 sizeof (XVisualInfo));
548 }
549
550 for (i = 0; i < n1sg; i++) {
551 if (XVisualIDFromVisual(pVI1sg[i].visual) ==
552 XVisualIDFromVisual(defaultConfig->awt_visInfo.visual)) {
553 continue;
554 } else {
555 ind = nConfig++;
556 }
557 graphicsConfigs [ind] = ZALLOC (_AwtGraphicsConfigData);
558 graphicsConfigs [ind]->awt_depth = pVI1sg [i].depth;
559 memcpy (&graphicsConfigs [ind]->awt_visInfo, &pVI1sg [i],
560 sizeof (XVisualInfo));
561 }
562
563 if (n8p != 0)
564 XFree (pVI8p);
565 if (n12p != 0)
566 XFree (pVI12p);
567 if (n8s != 0)
568 XFree (pVI8s);
569 if (n8gs != 0)
570 XFree (pVI8gs);
571 if (n8sg != 0)
572 XFree (pVI8sg);
573 if (n1sg != 0)
574 XFree (pVI1sg);
575
576 screenDataPtr->numConfigs = nConfig;
577 screenDataPtr->configs = graphicsConfigs;
578
579 AWT_UNLOCK ();
580 }
581
582 #ifndef HEADLESS
583 #if defined(__linux__) || defined(MACOSX)
584 static void xinerama_init_linux()
585 {
586 void* libHandle = NULL;
587 int32_t locNumScr = 0;
588 XineramaScreenInfo *xinInfo;
589 char* XineramaQueryScreensName = "XineramaQueryScreens";
590 XineramaQueryScreensFunc* XineramaQueryScreens = NULL;
591
592 /* load library */
593 libHandle = dlopen(VERSIONED_JNI_LIB_NAME("Xinerama", "1"),
594 RTLD_LAZY | RTLD_GLOBAL);
595 if (libHandle == NULL) {
596 libHandle = dlopen(JNI_LIB_NAME("Xinerama"), RTLD_LAZY | RTLD_GLOBAL);
597 }
598 if (libHandle != NULL) {
599 XineramaQueryScreens = (XineramaQueryScreensFunc*)
600 dlsym(libHandle, XineramaQueryScreensName);
601
602 if (XineramaQueryScreens != NULL) {
603 DTRACE_PRINTLN("calling XineramaQueryScreens func on Linux");
604 xinInfo = (*XineramaQueryScreens)(awt_display, &locNumScr);
605 if (xinInfo != NULL && locNumScr > XScreenCount(awt_display)) {
606 int32_t idx;
607 DTRACE_PRINTLN("Enabling Xinerama support");
608 usingXinerama = True;
609 /* set global number of screens */
610 DTRACE_PRINTLN1(" num screens = %i\n", locNumScr);
611 awt_numScreens = locNumScr;
612
613 /* stuff values into fbrects */
614 for (idx = 0; idx < awt_numScreens; idx++) {
615 DASSERT(xinInfo[idx].screen_number == idx);
616
617 fbrects[idx].width = xinInfo[idx].width;
618 fbrects[idx].height = xinInfo[idx].height;
619 fbrects[idx].x = xinInfo[idx].x_org;
620 fbrects[idx].y = xinInfo[idx].y_org;
621 }
622 } else {
623 DTRACE_PRINTLN("calling XineramaQueryScreens didn't work");
624 }
625 } else {
626 DTRACE_PRINTLN("couldn't load XineramaQueryScreens symbol");
627 }
628 dlclose(libHandle);
629 } else {
630 DTRACE_PRINTLN1("\ncouldn't open shared library: %s\n", dlerror());
631 }
632 }
633 #endif
634 #if !defined(__linux__) && !defined(MACOSX) /* Solaris */
635 static void xinerama_init_solaris()
636 {
637 void* libHandle = NULL;
638 unsigned char fbhints[MAXFRAMEBUFFERS];
639 int32_t locNumScr = 0;
640 /* load and run XineramaGetInfo */
641 char* XineramaGetInfoName = "XineramaGetInfo";
642 char* XineramaGetCenterHintName = "XineramaGetCenterHint";
643 XineramaGetInfoFunc* XineramaSolarisFunc = NULL;
644
645 /* load library */
646 libHandle = dlopen(JNI_LIB_NAME("Xext"), RTLD_LAZY | RTLD_GLOBAL);
647 if (libHandle != NULL) {
648 XineramaSolarisFunc = (XineramaGetInfoFunc*)dlsym(libHandle, XineramaGetInfoName);
649 XineramaSolarisCenterFunc =
650 (XineramaGetCenterHintFunc*)dlsym(libHandle, XineramaGetCenterHintName);
651
652 if (XineramaSolarisFunc != NULL) {
653 DTRACE_PRINTLN("calling XineramaGetInfo func on Solaris");
654 if ((*XineramaSolarisFunc)(awt_display, 0, &fbrects[0],
655 &fbhints[0], &locNumScr) != 0 &&
656 locNumScr > XScreenCount(awt_display))
657 {
658 DTRACE_PRINTLN("Enabling Xinerama support");
659 usingXinerama = True;
660 /* set global number of screens */
661 DTRACE_PRINTLN1(" num screens = %i\n", locNumScr);
662 awt_numScreens = locNumScr;
663 } else {
664 DTRACE_PRINTLN("calling XineramaGetInfo didn't work");
665 }
666 } else {
667 DTRACE_PRINTLN("couldn't load XineramaGetInfo symbol");
668 }
669 dlclose(libHandle);
670 } else {
671 DTRACE_PRINTLN1("\ncouldn't open shared library: %s\n", dlerror());
672 }
673 }
674 #endif
675
676 /*
677 * Checks if Xinerama is running and perform Xinerama-related
678 * platform dependent initialization.
679 */
680 static void xineramaInit(void) {
681 char* XinExtName = "XINERAMA";
682 int32_t major_opcode, first_event, first_error;
683 Bool gotXinExt = False;
684
685 gotXinExt = XQueryExtension(awt_display, XinExtName, &major_opcode,
686 &first_event, &first_error);
687
688 if (!gotXinExt) {
689 DTRACE_PRINTLN("Xinerama extension is not available");
690 return;
691 }
692
693 DTRACE_PRINTLN("Xinerama extension is available");
694 #if defined(__linux__) || defined(MACOSX)
695 xinerama_init_linux();
696 #else /* Solaris */
697 xinerama_init_solaris();
698 #endif /* __linux__ || MACOSX */
699 }
700 #endif /* HEADLESS */
701
702 Display *
703 awt_init_Display(JNIEnv *env, jobject this)
704 {
705 jclass klass;
706 Display *dpy;
707 char errmsg[128];
708 int i;
709 #ifdef NETSCAPE
710 sigset_t alarm_set, oldset;
711 #endif
712
713 if (awt_display) {
714 return awt_display;
715 }
716
717 #ifdef NETSCAPE
718 /* Disable interrupts during XtOpenDisplay to avoid bugs in unix os select
719 code: some unix systems don't implement SA_RESTART properly and
720 because of this, select returns with EINTR. Most implementations of
721 gethostbyname don't cope with EINTR properly and as a result we get
722 stuck (forever) in the gethostbyname code
723 */
724 sigemptyset(&alarm_set);
725 sigaddset(&alarm_set, SIGALRM);
726 sigprocmask(SIG_BLOCK, &alarm_set, &oldset);
727 #endif
728
729 /* Load AWT lock-related methods in SunToolkit */
730 klass = (*env)->FindClass(env, "sun/awt/SunToolkit");
731 if (klass == NULL) return NULL;
732 GET_STATIC_METHOD(klass, awtLockMID, "awtLock", "()V");
733 GET_STATIC_METHOD(klass, awtUnlockMID, "awtUnlock", "()V");
734 GET_STATIC_METHOD(klass, awtWaitMID, "awtLockWait", "(J)V");
735 GET_STATIC_METHOD(klass, awtNotifyMID, "awtLockNotify", "()V");
736 GET_STATIC_METHOD(klass, awtNotifyAllMID, "awtLockNotifyAll", "()V");
737 tkClass = (*env)->NewGlobalRef(env, klass);
738 awtLockInited = JNI_TRUE;
739
740 if (getenv("_AWT_IGNORE_XKB") != NULL &&
741 strlen(getenv("_AWT_IGNORE_XKB")) > 0) {
742 if (XkbIgnoreExtension(True)) {
743 printf("Ignoring XKB.\n");
744 }
745 }
746
747 dpy = awt_display = XOpenDisplay(NULL);
748 #ifdef NETSCAPE
749 sigprocmask(SIG_SETMASK, &oldset, NULL);
750 #endif
751 if (!dpy) {
752 jio_snprintf(errmsg,
753 sizeof(errmsg),
754 "Can't connect to X11 window server using '%s' as the value of the DISPLAY variable.",
755 (getenv("DISPLAY") == NULL) ? ":0.0" : getenv("DISPLAY"));
756 JNU_ThrowByName(env, "java/awt/AWTError", errmsg);
757 return NULL;
758 }
759
760 XSetIOErrorHandler(xioerror_handler);
761
762 /* set awt_numScreens, and whether or not we're using Xinerama */
763 xineramaInit();
764
765 if (!usingXinerama) {
766 awt_numScreens = XScreenCount(awt_display);
767 }
768
769 DTRACE_PRINTLN1("allocating %i screens\n", awt_numScreens);
770 /* Allocate screen data structure array */
771 x11Screens = calloc(awt_numScreens, sizeof(AwtScreenData));
772 if (x11Screens == NULL) {
773 JNU_ThrowOutOfMemoryError((JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2),
774 NULL);
775 return NULL;
776 }
777
778 for (i = 0; i < awt_numScreens; i++) {
779 if (usingXinerama) {
780 /* All Xinerama screens use the same X11 root for now */
781 x11Screens[i].root = RootWindow(awt_display, 0);
782 }
783 else {
784 x11Screens[i].root = RootWindow(awt_display, i);
785 }
786 x11Screens[i].defaultConfig = makeDefaultConfig(env, i);
787 }
788
789 return dpy;
790 }
791 #endif /* !HEADLESS */
792
793 /*
794 * Class: sun_awt_X11GraphicsEnvironment
795 * Method: getDefaultScreenNum
796 * Signature: ()I
797 */
798 JNIEXPORT jint JNICALL
799 Java_sun_awt_X11GraphicsEnvironment_getDefaultScreenNum(
800 JNIEnv *env, jobject this)
801 {
802 #ifdef HEADLESS
803 return (jint)0;
804 #else
805 return DefaultScreen(awt_display);
806 #endif /* !HEADLESS */
807 }
808
809 #ifndef HEADLESS
810 static void ensureConfigsInited(JNIEnv* env, int screen) {
811 if (x11Screens[screen].numConfigs == 0) {
812 if (env == NULL) {
813 env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
814 }
815 getAllConfigs (env, screen, &(x11Screens[screen]));
816 }
817 }
818 #endif
819
820 #ifdef HEADLESS
821 void* getDefaultConfig(int screen) {
822 return NULL;
823 }
824 #else
825 AwtGraphicsConfigDataPtr
826 getDefaultConfig(int screen) {
827 ensureConfigsInited(NULL, screen);
828 return x11Screens[screen].defaultConfig;
829 }
830
831 AwtScreenDataPtr
832 getScreenData(int screen) {
833 return &(x11Screens[screen]);
834 }
835 #endif /* !HEADLESS */
836
837 /*
838 * Class: sun_awt_X11GraphicsEnvironment
839 * Method: initDisplay
840 * Signature: (Z)V
841 */
842 JNIEXPORT void JNICALL
843 Java_sun_awt_X11GraphicsEnvironment_initDisplay(JNIEnv *env, jobject this,
844 jboolean glxReq)
845 {
846 #ifndef HEADLESS
847 glxRequested = glxReq;
848 (void) awt_init_Display(env, this);
849 #endif /* !HEADLESS */
850 }
851
852 /*
853 * Class: sun_awt_X11GraphicsEnvironment
854 * Method: initGLX
855 * Signature: ()Z
856 */
857 JNIEXPORT jboolean JNICALL
858 Java_sun_awt_X11GraphicsEnvironment_initGLX(JNIEnv *env, jclass x11ge)
859 {
860 #ifndef HEADLESS
861 jboolean glxAvailable;
862
863 AWT_LOCK();
864 glxAvailable = GLXGC_IsGLXAvailable();
865 AWT_UNLOCK();
866
867 return glxAvailable;
868 #else
869 return JNI_FALSE;
870 #endif /* !HEADLESS */
871 }
872
873 /*
874 * Class: sun_awt_X11GraphicsEnvironment
875 * Method: getNumScreens
876 * Signature: ()I
877 */
878 JNIEXPORT jint JNICALL
879 Java_sun_awt_X11GraphicsEnvironment_getNumScreens(JNIEnv *env, jobject this)
880 {
881 #ifdef HEADLESS
882 return (jint)0;
883 #else
884 return awt_numScreens;
885 #endif /* !HEADLESS */
886 }
887
888 /*
889 * Class: sun_awt_X11GraphicsDevice
890 * Method: getDisplay
891 * Signature: ()J
892 */
893 JNIEXPORT jlong JNICALL
894 Java_sun_awt_X11GraphicsDevice_getDisplay(JNIEnv *env, jobject this)
895 {
896 #ifdef HEADLESS
897 return NULL;
898 #else
899 return ptr_to_jlong(awt_display);
900 #endif /* !HEADLESS */
901 }
902
903 #ifdef MITSHM
904
905 static jint canUseShmExt = UNSET_MITSHM;
906 static jint canUseShmExtPixmaps = UNSET_MITSHM;
907 static jboolean xshmAttachFailed = JNI_FALSE;
908
909 int J2DXErrHandler(Display *display, XErrorEvent *xerr) {
910 int ret = 0;
911 if (xerr->minor_code == X_ShmAttach) {
912 xshmAttachFailed = JNI_TRUE;
913 } else {
914 ret = (*xerror_saved_handler)(display, xerr);
915 }
916 return ret;
917 }
918 jboolean isXShmAttachFailed() {
919 return xshmAttachFailed;
920 }
921 void resetXShmAttachFailed() {
922 xshmAttachFailed = JNI_FALSE;
923 }
924
925 void TryInitMITShm(JNIEnv *env, jint *shmExt, jint *shmPixmaps) {
926 XShmSegmentInfo shminfo;
927 int XShmMajor, XShmMinor;
928 int a, b, c;
929
930 AWT_LOCK();
931 if (canUseShmExt != UNSET_MITSHM) {
932 *shmExt = canUseShmExt;
933 *shmPixmaps = canUseShmExtPixmaps;
934 AWT_UNLOCK();
935 return;
936 }
937
938 *shmExt = canUseShmExt = CANT_USE_MITSHM;
939 *shmPixmaps = canUseShmExtPixmaps = CANT_USE_MITSHM;
940
941 if (awt_display == (Display *)NULL) {
942 AWT_NOFLUSH_UNLOCK();
943 return;
944 }
945
946 /**
947 * XShmQueryExtension returns False in remote server case.
948 * Unfortunately it also returns True in ssh case, so
949 * we need to test that we can actually do XShmAttach.
950 */
951 if (XShmQueryExtension(awt_display)) {
952 shminfo.shmid = shmget(IPC_PRIVATE, 0x10000, IPC_CREAT|0777);
953 if (shminfo.shmid < 0) {
954 AWT_UNLOCK();
955 J2dRlsTraceLn1(J2D_TRACE_ERROR,
956 "TryInitMITShm: shmget has failed: %s",
957 strerror(errno));
958 return;
959 }
960 shminfo.shmaddr = (char *) shmat(shminfo.shmid, 0, 0);
961 if (shminfo.shmaddr == ((char *) -1)) {
962 shmctl(shminfo.shmid, IPC_RMID, 0);
963 AWT_UNLOCK();
964 J2dRlsTraceLn1(J2D_TRACE_ERROR,
965 "TryInitMITShm: shmat has failed: %s",
966 strerror(errno));
967 return;
968 }
969 shminfo.readOnly = True;
970
971 resetXShmAttachFailed();
972 /**
973 * The J2DXErrHandler handler will set xshmAttachFailed
974 * to JNI_TRUE if any Shm error has occured.
975 */
976 EXEC_WITH_XERROR_HANDLER(J2DXErrHandler,
977 XShmAttach(awt_display, &shminfo));
978
979 /**
980 * Get rid of the id now to reduce chances of leaking
981 * system resources.
982 */
983 shmctl(shminfo.shmid, IPC_RMID, 0);
984
985 if (isXShmAttachFailed() == JNI_FALSE) {
986 canUseShmExt = CAN_USE_MITSHM;
987 /* check if we can use shared pixmaps */
988 XShmQueryVersion(awt_display, &XShmMajor, &XShmMinor,
989 (Bool*)&canUseShmExtPixmaps);
990 canUseShmExtPixmaps = canUseShmExtPixmaps &&
991 (XShmPixmapFormat(awt_display) == ZPixmap);
992 XShmDetach(awt_display, &shminfo);
993 }
994 shmdt(shminfo.shmaddr);
995 *shmExt = canUseShmExt;
996 *shmPixmaps = canUseShmExtPixmaps;
997 }
998 AWT_UNLOCK();
999 }
1000 #endif /* MITSHM */
1001
1002 /*
1003 * Class: sun_awt_X11GraphicsEnvironment
1004 * Method: checkShmExt
1005 * Signature: ()I
1006 */
1007 JNIEXPORT jint JNICALL
1008 Java_sun_awt_X11GraphicsEnvironment_checkShmExt(JNIEnv *env, jobject this)
1009 {
1010
1011 int shmExt = NOEXT_MITSHM, shmPixmaps;
1012 #ifdef MITSHM
1013 TryInitMITShm(env, &shmExt, &shmPixmaps);
1014 #endif
1015 return shmExt;
1016 }
1017
1018 /*
1019 * Class: sun_awt_X11GraphicsEnvironment
1020 * Method: getDisplayString
1021 * Signature: ()Ljava/lang/String
1022 */
1023 JNIEXPORT jstring JNICALL
1024 Java_sun_awt_X11GraphicsEnvironment_getDisplayString
1025 (JNIEnv *env, jobject this)
1026 {
1027 #ifdef HEADLESS
1028 return (jstring)NULL;
1029 #else
1030 return (*env)->NewStringUTF(env, DisplayString(awt_display));
1031 #endif /* HEADLESS */
1032 }
1033
1034
1035 /*
1036 * Class: sun_awt_X11GraphicsDevice
1037 * Method: getNumConfigs
1038 * Signature: ()I
1039 */
1040 JNIEXPORT jint JNICALL
1041 Java_sun_awt_X11GraphicsDevice_getNumConfigs(
1042 JNIEnv *env, jobject this, jint screen)
1043 {
1044 #ifdef HEADLESS
1045 return (jint)0;
1046 #else
1047 ensureConfigsInited(env, screen);
1048 return x11Screens[screen].numConfigs;
1049 #endif /* !HEADLESS */
1050 }
1051
1052 /*
1053 * Class: sun_awt_X11GraphicsDevice
1054 * Method: getConfigVisualId
1055 * Signature: (I)I
1056 */
1057 JNIEXPORT jint JNICALL
1058 Java_sun_awt_X11GraphicsDevice_getConfigVisualId(
1059 JNIEnv *env, jobject this, jint index, jint screen)
1060 {
1061 #ifdef HEADLESS
1062 return (jint)0;
1063 #else
1064 int visNum;
1065
1066 ensureConfigsInited(env, screen);
1067 if (index == 0) {
1068 return ((jint)x11Screens[screen].defaultConfig->awt_visInfo.visualid);
1069 } else {
1070 return ((jint)x11Screens[screen].configs[index]->awt_visInfo.visualid);
1071 }
1072 #endif /* !HEADLESS */
1073 }
1074
1075 /*
1076 * Class: sun_awt_X11GraphicsDevice
1077 * Method: getConfigDepth
1078 * Signature: (I)I
1079 */
1080 JNIEXPORT jint JNICALL
1081 Java_sun_awt_X11GraphicsDevice_getConfigDepth(
1082 JNIEnv *env, jobject this, jint index, jint screen)
1083 {
1084 #ifdef HEADLESS
1085 return (jint)0;
1086 #else
1087 int visNum;
1088
1089 ensureConfigsInited(env, screen);
1090 if (index == 0) {
1091 return ((jint)x11Screens[screen].defaultConfig->awt_visInfo.depth);
1092 } else {
1093 return ((jint)x11Screens[screen].configs[index]->awt_visInfo.depth);
1094 }
1095 #endif /* !HEADLESS */
1096 }
1097
1098 /*
1099 * Class: sun_awt_X11GraphicsDevice
1100 * Method: getConfigColormap
1101 * Signature: (I)I
1102 */
1103 JNIEXPORT jint JNICALL
1104 Java_sun_awt_X11GraphicsDevice_getConfigColormap(
1105 JNIEnv *env, jobject this, jint index, jint screen)
1106 {
1107 #ifdef HEADLESS
1108 return (jint)0;
1109 #else
1110 int visNum;
1111
1112 ensureConfigsInited(env, screen);
1113 if (index == 0) {
1114 return ((jint)x11Screens[screen].defaultConfig->awt_cmap);
1115 } else {
1116 return ((jint)x11Screens[screen].configs[index]->awt_cmap);
1117 }
1118 #endif /* !HEADLESS */
1119 }
1120
1121 /*
1122 * Class: sun_awt_X11GraphicsDevice
1123 * Method: resetNativeData
1124 * Signature: (I)V
1125 */
1126 JNIEXPORT void JNICALL
1127 Java_sun_awt_X11GraphicsDevice_resetNativeData
1128 (JNIEnv *env, jclass x11gd, jint screen)
1129 {
1130 #ifndef HEADLESS
1131 /*
1132 * Reset references to the various configs; the actual native config data
1133 * will be free'd later by the Disposer mechanism when the Java-level
1134 * X11GraphicsConfig objects go away. By setting these values to NULL,
1135 * we ensure that they will be reinitialized as necessary (for example,
1136 * see the getNumConfigs() method).
1137 */
1138 if (x11Screens[screen].configs) {
1139 free(x11Screens[screen].configs);
1140 x11Screens[screen].configs = NULL;
1141 }
1142 x11Screens[screen].defaultConfig = NULL;
1143 x11Screens[screen].numConfigs = 0;
1144 #endif /* !HEADLESS */
1145 }
1146
1147 /*
1148 * Class: sun_awt_X11GraphicsConfig
1149 * Method: dispose
1150 * Signature: (J)V
1151 */
1152 JNIEXPORT void JNICALL
1153 Java_sun_awt_X11GraphicsConfig_dispose
1154 (JNIEnv *env, jclass x11gc, jlong configData)
1155 {
1156 #ifndef HEADLESS
1157 AwtGraphicsConfigDataPtr aData = (AwtGraphicsConfigDataPtr)
1158 jlong_to_ptr(configData);
1159
1160 if (aData == NULL) {
1161 return;
1162 }
1163
1164 AWT_LOCK();
1165 if (aData->awt_cmap) {
1166 XFreeColormap(awt_display, aData->awt_cmap);
1167 }
1168 if (aData->awtImage) {
1169 free(aData->awtImage);
1170 }
1171 if (aData->monoImage) {
1172 XFree(aData->monoImage);
1173 }
1174 if (aData->monoPixmap) {
1175 XFreePixmap(awt_display, aData->monoPixmap);
1176 }
1177 if (aData->monoPixmapGC) {
1178 XFreeGC(awt_display, aData->monoPixmapGC);
1179 }
1180 if (aData->color_data) {
1181 free(aData->color_data);
1182 }
1183 AWT_UNLOCK();
1184
1185 if (aData->glxInfo) {
1186 /*
1187 * The native GLXGraphicsConfig data needs to be disposed separately
1188 * on the OGL queue flushing thread (should not be called while
1189 * the AWT lock is held).
1190 */
1191 JNU_CallStaticMethodByName(env, NULL,
1192 "sun/java2d/opengl/OGLRenderQueue",
1193 "disposeGraphicsConfig", "(J)V",
1194 ptr_to_jlong(aData->glxInfo));
1195 }
1196
1197 free(aData);
1198 #endif /* !HEADLESS */
1199 }
1200
1201 /*
1202 * Class: sun_awt_X11GraphicsConfig
1203 * Method: getXResolution
1204 * Signature: ()I
1205 */
1206 JNIEXPORT jdouble JNICALL
1207 Java_sun_awt_X11GraphicsConfig_getXResolution(
1208 JNIEnv *env, jobject this, jint screen)
1209 {
1210 #ifdef HEADLESS
1211 return (jdouble)0;
1212 #else
1213 return ((DisplayWidth(awt_display, screen) * 25.4) /
1214 DisplayWidthMM(awt_display, screen));
1215 #endif /* !HEADLESS */
1216 }
1217
1218 /*
1219 * Class: sun_awt_X11GraphicsConfig
1220 * Method: getYResolution
1221 * Signature: ()I
1222 */
1223 JNIEXPORT jdouble JNICALL
1224 Java_sun_awt_X11GraphicsConfig_getYResolution(
1225 JNIEnv *env, jobject this, jint screen)
1226 {
1227 #ifdef HEADLESS
1228 return (jdouble)0;
1229 #else
1230 return ((DisplayHeight(awt_display, screen) * 25.4) /
1231 DisplayHeightMM(awt_display, screen));
1232 #endif /* !HEADLESS */
1233 }
1234
1235
1236 /*
1237 * Class: sun_awt_X11GraphicsConfig
1238 * Method: getNumColors
1239 * Signature: ()I
1240 */
1241 JNIEXPORT jint JNICALL
1242 Java_sun_awt_X11GraphicsConfig_getNumColors(
1243 JNIEnv *env, jobject this)
1244 {
1245 #ifdef HEADLESS
1246 return (jint)0;
1247 #else
1248 AwtGraphicsConfigData *adata;
1249
1250 adata = (AwtGraphicsConfigData *) JNU_GetLongFieldAsPtr(env, this,
1251 x11GraphicsConfigIDs.aData);
1252
1253 return adata->awt_num_colors;
1254 #endif /* !HEADLESS */
1255 }
1256
1257 /*
1258 * Class: sun_awt_X11GraphicsConfig
1259 * Method: init
1260 * Signature: (I)V
1261 */
1262 JNIEXPORT void JNICALL
1263 Java_sun_awt_X11GraphicsConfig_init(
1264 JNIEnv *env, jobject this, jint visualNum, jint screen)
1265 {
1266 #ifndef HEADLESS
1267 AwtGraphicsConfigData *adata = NULL;
1268 AwtScreenData asd = x11Screens[screen];
1269 int i, n;
1270 int depth;
1271 XImage * tempImage;
1272
1273 /* If haven't gotten all of the configs yet, do it now. */
1274 if (asd.numConfigs == 0) {
1275 getAllConfigs (env, screen, &asd);
1276 }
1277
1278 /* Check the graphicsConfig for this visual */
1279 for (i = 0; i < asd.numConfigs; i++) {
1280 AwtGraphicsConfigDataPtr agcPtr = asd.configs[i];
1281 if ((jint)agcPtr->awt_visInfo.visualid == visualNum) {
1282 adata = agcPtr;
1283 break;
1284 }
1285 }
1286
1287 /* If didn't find the visual, throw an exception... */
1288 if (adata == (AwtGraphicsConfigData *) NULL) {
1289 JNU_ThrowIllegalArgumentException(env, "Unknown Visual Specified");
1290 return;
1291 }
1292
1293 /* adata->awt_cmap initialization has been deferred to
1294 * makeColorModel call
1295 */
1296
1297 JNU_SetLongFieldFromPtr(env, this, x11GraphicsConfigIDs.aData, adata);
1298
1299 depth = adata->awt_visInfo.depth;
1300 tempImage = XCreateImage(awt_display,
1301 adata->awt_visInfo.visual,
1302 depth, ZPixmap, 0, NULL, 1, 1, 32, 0);
1303 adata->pixelStride = (tempImage->bits_per_pixel + 7) / 8;
1304 (*env)->SetIntField(env, this, x11GraphicsConfigIDs.bitsPerPixel,
1305 (jint)tempImage->bits_per_pixel);
1306 XDestroyImage(tempImage);
1307 #endif /* !HEADLESS */
1308 }
1309
1310
1311
1312 /*
1313 * Class: sun_awt_X11GraphicsConfig
1314 * Method: makeColorModel
1315 * Signature: ()Ljava/awt/image/ColorModel
1316 */
1317 JNIEXPORT jobject JNICALL
1318 Java_sun_awt_X11GraphicsConfig_makeColorModel(
1319 JNIEnv *env, jobject this)
1320 {
1321 #ifdef HEADLESS
1322 return NULL;
1323 #else
1324 AwtGraphicsConfigData *adata;
1325 jobject colorModel;
1326
1327 /*
1328 * If awt is not locked yet, return null since the toolkit is not
1329 * initialized yet.
1330 */
1331 if (!awtLockInited) {
1332 return NULL;
1333 }
1334
1335 AWT_LOCK ();
1336
1337 adata = (AwtGraphicsConfigData *) JNU_GetLongFieldAsPtr(env, this,
1338 x11GraphicsConfigIDs.aData);
1339
1340 /* If colormap entry of adata is NULL, need to create it now */
1341 if (adata->awt_cmap == (Colormap) NULL) {
1342 awtJNI_CreateColorData (env, adata, 1);
1343 }
1344
1345 /* Make Color Model object for this GraphicsConfiguration */
1346 colorModel = awtJNI_GetColorModel (env, adata);
1347
1348 AWT_UNLOCK ();
1349
1350 return colorModel;
1351 #endif /* !HEADLESS */
1352 }
1353
1354
1355 /*
1356 * Class: sun_awt_X11GraphicsConfig
1357 * Method: getBounds
1358 * Signature: ()Ljava/awt/Rectangle
1359 */
1360 JNIEXPORT jobject JNICALL
1361 Java_sun_awt_X11GraphicsConfig_pGetBounds(JNIEnv *env, jobject this, jint screen)
1362 {
1363 #ifdef HEADLESS
1364 return NULL;
1365 #else
1366 jclass clazz;
1367 jmethodID mid;
1368 jobject bounds = NULL;
1369 AwtGraphicsConfigDataPtr adata;
1370
1371 adata = (AwtGraphicsConfigDataPtr)
1372 JNU_GetLongFieldAsPtr(env, this, x11GraphicsConfigIDs.aData);
1373
1374 clazz = (*env)->FindClass(env, "java/awt/Rectangle");
1375 mid = (*env)->GetMethodID(env, clazz, "<init>", "(IIII)V");
1376 if (mid != NULL) {
1377 if (usingXinerama) {
1378 bounds = (*env)->NewObject(env, clazz, mid, fbrects[screen].x,
1379 fbrects[screen].y,
1380 fbrects[screen].width,
1381 fbrects[screen].height);
1382 }
1383 else {
1384 XWindowAttributes xwa;
1385 memset(&xwa, 0, sizeof(xwa));
1386
1387 AWT_LOCK ();
1388 XGetWindowAttributes(awt_display,
1389 RootWindow(awt_display, adata->awt_visInfo.screen),
1390 &xwa);
1391 AWT_UNLOCK ();
1392
1393 bounds = (*env)->NewObject(env, clazz, mid, 0, 0,
1394 xwa.width, xwa.height);
1395 }
1396
1397 if ((*env)->ExceptionOccurred(env)) {
1398 return NULL;
1399 }
1400 }
1401 return bounds;
1402 #endif /* !HEADLESS */
1403 }
1404
1405 /*
1406 * Class: sun_awt_X11GraphicsConfig
1407 * Method: createBackBuffer
1408 * Signature: (JI)J
1409 */
1410 JNIEXPORT jlong JNICALL
1411 Java_sun_awt_X11GraphicsConfig_createBackBuffer
1412 (JNIEnv *env, jobject this, jlong window, jint swapAction)
1413 {
1414 int32_t v1, v2;
1415 XdbeBackBuffer ret = (unsigned long) 0;
1416 Window w = (Window)window;
1417 AWT_LOCK();
1418 if (!XdbeQueryExtension(awt_display, &v1, &v2)) {
1419 JNU_ThrowByName(env, "java/lang/Exception",
1420 "Could not query double-buffer extension");
1421 AWT_UNLOCK();
1422 return (jlong)0;
1423 }
1424 ret = XdbeAllocateBackBufferName(awt_display, w,
1425 (XdbeSwapAction)swapAction);
1426 AWT_FLUSH_UNLOCK();
1427 return (jlong)ret;
1428 }
1429
1430 /*
1431 * Class: sun_awt_X11GraphicsConfig
1432 * Method: destroyBackBuffer
1433 * Signature: (J)V
1434 */
1435 JNIEXPORT void JNICALL
1436 Java_sun_awt_X11GraphicsConfig_destroyBackBuffer
1437 (JNIEnv *env, jobject this, jlong backBuffer)
1438 {
1439 AWT_LOCK();
1440 XdbeDeallocateBackBufferName(awt_display, (XdbeBackBuffer)backBuffer);
1441 AWT_FLUSH_UNLOCK();
1442 }
1443
1444 /*
1445 * Class: sun_awt_X11GraphicsConfig
1446 * Method: swapBuffers
1447 * Signature: (JI)V
1448 */
1449 JNIEXPORT void JNICALL
1450 Java_sun_awt_X11GraphicsConfig_swapBuffers
1451 (JNIEnv *env, jobject this,
1452 jlong window, jint swapAction)
1453 {
1454 XdbeSwapInfo swapInfo;
1455
1456 AWT_LOCK();
1457
1458 XdbeBeginIdiom(awt_display);
1459 swapInfo.swap_window = (Window)window;
1460 swapInfo.swap_action = (XdbeSwapAction)swapAction;
1461 if (!XdbeSwapBuffers(awt_display, &swapInfo, 1)) {
1462 JNU_ThrowInternalError(env, "Could not swap buffers");
1463 }
1464 XdbeEndIdiom(awt_display);
1465
1466 AWT_FLUSH_UNLOCK();
1467 }
1468
1469 /*
1470 * Class: sun_awt_X11GraphicsConfig
1471 * Method: isTranslucencyCapable
1472 * Signature: (J)V
1473 */
1474 JNIEXPORT jboolean JNICALL
1475 Java_sun_awt_X11GraphicsConfig_isTranslucencyCapable
1476 (JNIEnv *env, jobject this, jlong configData)
1477 {
1478 #ifdef HEADLESS
1479 return JNI_FALSE;
1480 #else
1481 AwtGraphicsConfigDataPtr aData = (AwtGraphicsConfigDataPtr)jlong_to_ptr(configData);
1482 if (aData == NULL) {
1483 return JNI_FALSE;
1484 }
1485 return (jboolean)aData->isTranslucencySupported;
1486 #endif
1487 }
1488
1489 /*
1490 * Class: sun_awt_X11GraphicsDevice
1491 * Method: isDBESupported
1492 * Signature: ()Z
1493 */
1494 JNIEXPORT jboolean JNICALL
1495 Java_sun_awt_X11GraphicsDevice_isDBESupported(JNIEnv *env, jobject this)
1496 {
1497 #ifdef HEADLESS
1498 return JNI_FALSE;
1499 #else
1500 int opcode = 0, firstEvent = 0, firstError = 0;
1501 jboolean ret;
1502
1503 AWT_LOCK();
1504 ret = (jboolean)XQueryExtension(awt_display, "DOUBLE-BUFFER",
1505 &opcode, &firstEvent, &firstError);
1506 AWT_FLUSH_UNLOCK();
1507 return ret;
1508 #endif /* !HEADLESS */
1509 }
1510
1511 /*
1512 * Class: sun_awt_X11GraphicsDevice
1513 * Method: getDoubleBufferVisuals
1514 * Signature: (I)V
1515 */
1516 JNIEXPORT void JNICALL
1517 Java_sun_awt_X11GraphicsDevice_getDoubleBufferVisuals(JNIEnv *env,
1518 jobject this, jint screen)
1519 {
1520 #ifndef HEADLESS
1521 jclass clazz;
1522 jmethodID midAddVisual;
1523 Window rootWindow;
1524 int i, n = 1;
1525 XdbeScreenVisualInfo* visScreenInfo;
1526 int xinawareScreen;
1527
1528 if (usingXinerama) {
1529 xinawareScreen = 0;
1530 }
1531 else {
1532 xinawareScreen = screen;
1533 }
1534
1535 clazz = (*env)->GetObjectClass(env, this);
1536 midAddVisual = (*env)->GetMethodID(env, clazz, "addDoubleBufferVisual",
1537 "(I)V");
1538
1539 AWT_LOCK();
1540 rootWindow = RootWindow(awt_display, xinawareScreen);
1541 visScreenInfo = XdbeGetVisualInfo(awt_display, &rootWindow, &n);
1542 if (visScreenInfo == NULL) {
1543 JNU_ThrowInternalError(env, "Could not get visual info");
1544 AWT_UNLOCK();
1545 return;
1546 }
1547 AWT_FLUSH_UNLOCK();
1548 for (i = 0; i < visScreenInfo->count; i++) {
1549 XdbeVisualInfo* visInfo = visScreenInfo->visinfo;
1550 (*env)->CallVoidMethod(env, this, midAddVisual, (visInfo[i]).visual);
1551 }
1552 #endif /* !HEADLESS */
1553 }
1554
1555 /*
1556 * Class: sun_awt_X11GraphicsEnvironment
1557 * Method: pRunningXinerama
1558 * Signature: ()Z
1559 */
1560 JNIEXPORT jboolean JNICALL
1561 Java_sun_awt_X11GraphicsEnvironment_pRunningXinerama(JNIEnv *env,
1562 jobject this)
1563 {
1564 #ifdef HEADLESS
1565 return false;
1566 #else
1567 return usingXinerama;
1568 #endif /* HEADLESS */
1569 }
1570
1571 /*
1572 * Can return NULL.
1573 *
1574 * Class: sun_awt_X11GraphicsEnvironment
1575 * Method: getXineramaCenterPoint
1576 * Signature: ()Ljava/awt/Point
1577 */
1578 JNIEXPORT jobject JNICALL
1579 Java_sun_awt_X11GraphicsEnvironment_getXineramaCenterPoint(JNIEnv *env,
1580 jobject this)
1581 {
1582 jobject point = NULL;
1583 #ifndef HEADLESS /* return NULL in HEADLESS, Linux */
1584 #if !defined(__linux__) && !defined(MACOSX)
1585 int x,y;
1586
1587 AWT_LOCK();
1588 DASSERT(usingXinerama);
1589 if (XineramaSolarisCenterFunc != NULL) {
1590 (XineramaSolarisCenterFunc)(awt_display, 0, &x, &y);
1591 point = JNU_NewObjectByName(env, "java/awt/Point","(II)V", x, y);
1592 DASSERT(point);
1593 } else {
1594 DTRACE_PRINTLN("unable to call XineramaSolarisCenterFunc: symbol is null");
1595 }
1596 AWT_FLUSH_UNLOCK();
1597 #endif /* __linux __ || MACOSX */
1598 #endif /* HEADLESS */
1599 return point;
1600 }
1601
1602
1603 /**
1604 * Begin DisplayMode/FullScreen support
1605 */
1606
1607 #ifndef HEADLESS
1608
1609 #define BIT_DEPTH_MULTI java_awt_DisplayMode_BIT_DEPTH_MULTI
1610 #define REFRESH_RATE_UNKNOWN java_awt_DisplayMode_REFRESH_RATE_UNKNOWN
1611
1612 typedef Status
1613 (*XRRQueryVersionType) (Display *dpy, int *major_versionp, int *minor_versionp);
1614 typedef XRRScreenConfiguration*
1615 (*XRRGetScreenInfoType)(Display *dpy, Drawable root);
1616 typedef void
1617 (*XRRFreeScreenConfigInfoType)(XRRScreenConfiguration *config);
1618 typedef short*
1619 (*XRRConfigRatesType)(XRRScreenConfiguration *config,
1620 int sizeID, int *nrates);
1621 typedef short
1622 (*XRRConfigCurrentRateType)(XRRScreenConfiguration *config);
1623 typedef XRRScreenSize*
1624 (*XRRConfigSizesType)(XRRScreenConfiguration *config,
1625 int *nsizes);
1626 typedef SizeID
1627 (*XRRConfigCurrentConfigurationType)(XRRScreenConfiguration *config,
1628 Rotation *rotation);
1629 typedef Status
1630 (*XRRSetScreenConfigAndRateType)(Display *dpy,
1631 XRRScreenConfiguration *config,
1632 Drawable draw,
1633 int size_index,
1634 Rotation rotation,
1635 short rate,
1636 Time timestamp);
1637 typedef Rotation
1638 (*XRRConfigRotationsType)(XRRScreenConfiguration *config,
1639 Rotation *current_rotation);
1640
1641 static XRRQueryVersionType awt_XRRQueryVersion;
1642 static XRRGetScreenInfoType awt_XRRGetScreenInfo;
1643 static XRRFreeScreenConfigInfoType awt_XRRFreeScreenConfigInfo;
1644 static XRRConfigRatesType awt_XRRConfigRates;
1645 static XRRConfigCurrentRateType awt_XRRConfigCurrentRate;
1646 static XRRConfigSizesType awt_XRRConfigSizes;
1647 static XRRConfigCurrentConfigurationType awt_XRRConfigCurrentConfiguration;
1648 static XRRSetScreenConfigAndRateType awt_XRRSetScreenConfigAndRate;
1649 static XRRConfigRotationsType awt_XRRConfigRotations;
1650
1651 #define LOAD_XRANDR_FUNC(f) \
1652 do { \
1653 awt_##f = (f##Type)dlsym(pLibRandR, #f); \
1654 if (awt_##f == NULL) { \
1655 J2dRlsTraceLn1(J2D_TRACE_ERROR, \
1656 "X11GD_InitXrandrFuncs: Could not load %s", #f); \
1657 dlclose(pLibRandR); \
1658 return JNI_FALSE; \
1659 } \
1660 } while (0)
1661
1662 static jboolean
1663 X11GD_InitXrandrFuncs(JNIEnv *env)
1664 {
1665 int rr_maj_ver = 0, rr_min_ver = 0;
1666
1667 void *pLibRandR = dlopen(VERSIONED_JNI_LIB_NAME("Xrandr", "2"),
1668 RTLD_LAZY | RTLD_LOCAL);
1669 if (pLibRandR == NULL) {
1670 pLibRandR = dlopen(JNI_LIB_NAME("Xrandr"), RTLD_LAZY | RTLD_LOCAL);
1671 }
1672 if (pLibRandR == NULL) {
1673 J2dRlsTraceLn(J2D_TRACE_ERROR,
1674 "X11GD_InitXrandrFuncs: Could not open libXrandr.so.2");
1675 return JNI_FALSE;
1676 }
1677
1678 LOAD_XRANDR_FUNC(XRRQueryVersion);
1679
1680 if (!(*awt_XRRQueryVersion)(awt_display, &rr_maj_ver, &rr_min_ver)) {
1681 J2dRlsTraceLn(J2D_TRACE_ERROR,
1682 "X11GD_InitXrandrFuncs: XRRQueryVersion returned an error status");
1683 dlclose(pLibRandR);
1684 return JNI_FALSE;
1685 }
1686
1687 if (usingXinerama) {
1688 /*
1689 * We can proceed as long as this is RANDR 1.2 or above.
1690 * As of Xorg server 1.3 onwards the Xinerama backend may actually be
1691 * a fake one provided by RANDR itself. See Java bug 6636469 for info.
1692 */
1693 if (!(rr_maj_ver > 1 || (rr_maj_ver == 1 && rr_min_ver >= 2))) {
1694 J2dRlsTraceLn2(J2D_TRACE_INFO, "X11GD_InitXrandrFuncs: Can't use Xrandr. "
1695 "Xinerama is active and Xrandr version is %d.%d",
1696 rr_maj_ver, rr_min_ver);
1697 dlclose(pLibRandR);
1698 return JNI_FALSE;
1699 }
1700
1701 /*
1702 * REMIND: Fullscreen mode doesn't work quite right with multi-monitor
1703 * setups and RANDR 1.2. So for now we also require a single screen.
1704 */
1705 if (awt_numScreens > 1 ) {
1706 J2dRlsTraceLn(J2D_TRACE_INFO, "X11GD_InitXrandrFuncs: Can't use Xrandr. "
1707 "Multiple screens in use");
1708 dlclose(pLibRandR);
1709 return JNI_FALSE;
1710 }
1711 }
1712
1713 LOAD_XRANDR_FUNC(XRRGetScreenInfo);
1714 LOAD_XRANDR_FUNC(XRRFreeScreenConfigInfo);
1715 LOAD_XRANDR_FUNC(XRRConfigRates);
1716 LOAD_XRANDR_FUNC(XRRConfigCurrentRate);
1717 LOAD_XRANDR_FUNC(XRRConfigSizes);
1718 LOAD_XRANDR_FUNC(XRRConfigCurrentConfiguration);
1719 LOAD_XRANDR_FUNC(XRRSetScreenConfigAndRate);
1720 LOAD_XRANDR_FUNC(XRRConfigRotations);
1721
1722 return JNI_TRUE;
1723 }
1724
1725 static jobject
1726 X11GD_CreateDisplayMode(JNIEnv *env, jint width, jint height,
1727 jint bitDepth, jint refreshRate)
1728 {
1729 jclass displayModeClass;
1730 jmethodID cid;
1731 jint validRefreshRate = refreshRate;
1732
1733 displayModeClass = (*env)->FindClass(env, "java/awt/DisplayMode");
1734 if (JNU_IsNull(env, displayModeClass)) {
1735 JNU_ThrowInternalError(env,
1736 "Could not get display mode class");
1737 return NULL;
1738 }
1739
1740 cid = (*env)->GetMethodID(env, displayModeClass, "<init>", "(IIII)V");
1741 if (cid == NULL) {
1742 JNU_ThrowInternalError(env,
1743 "Could not get display mode constructor");
1744 return NULL;
1745 }
1746
1747 // early versions of xrandr may report "empty" rates (6880694)
1748 if (validRefreshRate <= 0) {
1749 validRefreshRate = REFRESH_RATE_UNKNOWN;
1750 }
1751
1752 return (*env)->NewObject(env, displayModeClass, cid,
1753 width, height, bitDepth, validRefreshRate);
1754 }
1755
1756 static void
1757 X11GD_AddDisplayMode(JNIEnv *env, jobject arrayList,
1758 jint width, jint height,
1759 jint bitDepth, jint refreshRate)
1760 {
1761 jobject displayMode = X11GD_CreateDisplayMode(env, width, height,
1762 bitDepth, refreshRate);
1763 if (!JNU_IsNull(env, displayMode)) {
1764 jclass arrayListClass;
1765 jmethodID mid;
1766 arrayListClass = (*env)->GetObjectClass(env, arrayList);
1767 if (JNU_IsNull(env, arrayListClass)) {
1768 JNU_ThrowInternalError(env,
1769 "Could not get class java.util.ArrayList");
1770 return;
1771 }
1772 mid = (*env)->GetMethodID(env, arrayListClass, "add",
1773 "(Ljava/lang/Object;)Z");
1774 if (mid == NULL) {
1775 JNU_ThrowInternalError(env,
1776 "Could not get method java.util.ArrayList.add()");
1777 return;
1778 }
1779 (*env)->CallObjectMethod(env, arrayList, mid, displayMode);
1780 (*env)->DeleteLocalRef(env, displayMode);
1781 }
1782 }
1783
1784 static void
1785 X11GD_SetFullscreenMode(Window win, jboolean enabled)
1786 {
1787 Atom wmState = XInternAtom(awt_display, "_NET_WM_STATE", False);
1788 Atom wmStateFs = XInternAtom(awt_display,
1789 "_NET_WM_STATE_FULLSCREEN", False);
1790 Window root, parent, *children = NULL;
1791 unsigned int numchildren;
1792 XEvent event;
1793 Status status;
1794
1795 if (wmState == None || wmStateFs == None) {
1796 return;
1797 }
1798
1799 /*
1800 * Note: the Window passed to this method is typically the "content
1801 * window" of the top-level, but we need the actual shell window for
1802 * the purposes of constructing the XEvent. Therefore, we walk up the
1803 * window hierarchy here to find the true top-level.
1804 */
1805 do {
1806 if (!XQueryTree(awt_display, win,
1807 &root, &parent,
1808 &children, &numchildren))
1809 {
1810 return;
1811 }
1812
1813 if (children != NULL) {
1814 XFree(children);
1815 }
1816
1817 if (parent == root) {
1818 break;
1819 }
1820
1821 win = parent;
1822 } while (root != parent);
1823
1824 memset(&event, 0, sizeof(event));
1825 event.xclient.type = ClientMessage;
1826 event.xclient.message_type = wmState;
1827 event.xclient.display = awt_display;
1828 event.xclient.window = win;
1829 event.xclient.format = 32;
1830 event.xclient.data.l[0] = enabled ? 1 : 0; // 1==add, 0==remove
1831 event.xclient.data.l[1] = wmStateFs;
1832
1833 XSendEvent(awt_display, root, False,
1834 SubstructureRedirectMask | SubstructureNotifyMask,
1835 &event);
1836 XSync(awt_display, False);
1837 }
1838 #endif /* !HEADLESS */
1839
1840 /*
1841 * Class: sun_awt_X11GraphicsDevice
1842 * Method: initXrandrExtension
1843 * Signature: ()Z
1844 */
1845 JNIEXPORT jboolean JNICALL
1846 Java_sun_awt_X11GraphicsDevice_initXrandrExtension
1847 (JNIEnv *env, jclass x11gd)
1848 {
1849 #ifdef HEADLESS
1850 return JNI_FALSE;
1851 #else
1852 int opcode = 0, firstEvent = 0, firstError = 0;
1853 jboolean ret;
1854
1855 AWT_LOCK();
1856 ret = (jboolean)XQueryExtension(awt_display, "RANDR",
1857 &opcode, &firstEvent, &firstError);
1858 if (ret) {
1859 ret = X11GD_InitXrandrFuncs(env);
1860 }
1861 AWT_FLUSH_UNLOCK();
1862
1863 return ret;
1864 #endif /* HEADLESS */
1865 }
1866
1867 /*
1868 * Class: sun_awt_X11GraphicsDevice
1869 * Method: getCurrentDisplayMode
1870 * Signature: (I)Ljava/awt/DisplayMode;
1871 */
1872 JNIEXPORT jobject JNICALL
1873 Java_sun_awt_X11GraphicsDevice_getCurrentDisplayMode
1874 (JNIEnv* env, jclass x11gd, jint screen)
1875 {
1876 #ifdef HEADLESS
1877 return NULL;
1878 #else
1879 XRRScreenConfiguration *config;
1880 jobject displayMode = NULL;
1881
1882 AWT_LOCK();
1883
1884 config = awt_XRRGetScreenInfo(awt_display,
1885 RootWindow(awt_display, screen));
1886 if (config != NULL) {
1887 Rotation rotation;
1888 short curRate;
1889 SizeID curSizeIndex;
1890 XRRScreenSize *sizes;
1891 int nsizes;
1892
1893 curSizeIndex = awt_XRRConfigCurrentConfiguration(config, &rotation);
1894 sizes = awt_XRRConfigSizes(config, &nsizes);
1895 curRate = awt_XRRConfigCurrentRate(config);
1896
1897 if ((sizes != NULL) &&
1898 (curSizeIndex < nsizes))
1899 {
1900 XRRScreenSize curSize = sizes[curSizeIndex];
1901 displayMode = X11GD_CreateDisplayMode(env,
1902 curSize.width,
1903 curSize.height,
1904 BIT_DEPTH_MULTI,
1905 curRate);
1906 }
1907
1908 awt_XRRFreeScreenConfigInfo(config);
1909 }
1910
1911 AWT_FLUSH_UNLOCK();
1912
1913 return displayMode;
1914 #endif /* HEADLESS */
1915 }
1916
1917 /*
1918 * Class: sun_awt_X11GraphicsDevice
1919 * Method: enumDisplayModes
1920 * Signature: (ILjava/util/ArrayList;)V
1921 */
1922 JNIEXPORT void JNICALL
1923 Java_sun_awt_X11GraphicsDevice_enumDisplayModes
1924 (JNIEnv* env, jclass x11gd,
1925 jint screen, jobject arrayList)
1926 {
1927 #ifndef HEADLESS
1928 XRRScreenConfiguration *config;
1929
1930 AWT_LOCK();
1931
1932 config = awt_XRRGetScreenInfo(awt_display,
1933 RootWindow(awt_display, screen));
1934 if (config != NULL) {
1935 int nsizes, i, j;
1936 XRRScreenSize *sizes = awt_XRRConfigSizes(config, &nsizes);
1937
1938 if (sizes != NULL) {
1939 for (i = 0; i < nsizes; i++) {
1940 int nrates;
1941 XRRScreenSize size = sizes[i];
1942 short *rates = awt_XRRConfigRates(config, i, &nrates);
1943
1944 for (j = 0; j < nrates; j++) {
1945 X11GD_AddDisplayMode(env, arrayList,
1946 size.width,
1947 size.height,
1948 BIT_DEPTH_MULTI,
1949 rates[j]);
1950 }
1951 }
1952 }
1953
1954 awt_XRRFreeScreenConfigInfo(config);
1955 }
1956
1957 AWT_FLUSH_UNLOCK();
1958 #endif /* !HEADLESS */
1959 }
1960
1961 /*
1962 * Class: sun_awt_X11GraphicsDevice
1963 * Method: configDisplayMode
1964 * Signature: (IIII)V
1965 */
1966 JNIEXPORT void JNICALL
1967 Java_sun_awt_X11GraphicsDevice_configDisplayMode
1968 (JNIEnv* env, jclass x11gd,
1969 jint screen, jint width, jint height, jint refreshRate)
1970 {
1971 #ifndef HEADLESS
1972 jboolean success = JNI_FALSE;
1973 XRRScreenConfiguration *config;
1974 Drawable root;
1975 Rotation currentRotation = RR_Rotate_0;
1976
1977 AWT_LOCK();
1978
1979 root = RootWindow(awt_display, screen);
1980 config = awt_XRRGetScreenInfo(awt_display, root);
1981 if (config != NULL) {
1982 jboolean foundConfig = JNI_FALSE;
1983 int chosenSizeIndex = -1;
1984 short chosenRate = -1;
1985 int nsizes;
1986 XRRScreenSize *sizes = awt_XRRConfigSizes(config, &nsizes);
1987 awt_XRRConfigRotations(config, ¤tRotation);
1988
1989 if (sizes != NULL) {
1990 int i, j;
1991
1992 /* find the size index that matches the requested dimensions */
1993 for (i = 0; i < nsizes; i++) {
1994 XRRScreenSize size = sizes[i];
1995
1996 if ((size.width == width) && (size.height == height)) {
1997 /* we've found our size index... */
1998 int nrates;
1999 short *rates = awt_XRRConfigRates(config, i, &nrates);
2000
2001 /* now find rate that matches requested refresh rate */
2002 for (j = 0; j < nrates; j++) {
2003 if (rates[j] == refreshRate) {
2004 /* we've found our rate; break out of the loop */
2005 chosenSizeIndex = i;
2006 chosenRate = rates[j];
2007 foundConfig = JNI_TRUE;
2008 break;
2009 }
2010 }
2011
2012 break;
2013 }
2014 }
2015 }
2016
2017 if (foundConfig) {
2018 Status status =
2019 awt_XRRSetScreenConfigAndRate(awt_display, config, root,
2020 chosenSizeIndex,
2021 currentRotation,
2022 chosenRate,
2023 CurrentTime);
2024
2025 /* issue XSync to ensure immediate mode change */
2026 XSync(awt_display, False);
2027
2028 if (status == RRSetConfigSuccess) {
2029 success = JNI_TRUE;
2030 }
2031 }
2032
2033 awt_XRRFreeScreenConfigInfo(config);
2034 }
2035
2036 AWT_FLUSH_UNLOCK();
2037
2038 if (!success) {
2039 JNU_ThrowInternalError(env, "Could not set display mode");
2040 }
2041 #endif /* !HEADLESS */
2042 }
2043
2044 /*
2045 * Class: sun_awt_X11GraphicsDevice
2046 * Method: enterFullScreenExclusive
2047 * Signature: (J)V
2048 */
2049 JNIEXPORT void JNICALL
2050 Java_sun_awt_X11GraphicsDevice_enterFullScreenExclusive
2051 (JNIEnv* env, jclass x11gd,
2052 jlong window)
2053 {
2054 #ifndef HEADLESS
2055 Window win = (Window)window;
2056
2057 AWT_LOCK();
2058 XSync(awt_display, False); /* ensures window is visible first */
2059 X11GD_SetFullscreenMode(win, JNI_TRUE);
2060 AWT_UNLOCK();
2061 #endif /* !HEADLESS */
2062 }
2063
2064 /*
2065 * Class: sun_awt_X11GraphicsDevice
2066 * Method: exitFullScreenExclusive
2067 * Signature: (J)V
2068 */
2069 JNIEXPORT void JNICALL
2070 Java_sun_awt_X11GraphicsDevice_exitFullScreenExclusive
2071 (JNIEnv* env, jclass x11gd,
2072 jlong window)
2073 {
2074 #ifndef HEADLESS
2075 Window win = (Window)window;
2076
2077 AWT_LOCK();
2078 X11GD_SetFullscreenMode(win, JNI_FALSE);
2079 AWT_UNLOCK();
2080 #endif /* !HEADLESS */
2081 }
2082
2083 /**
2084 * End DisplayMode/FullScreen support
2085 */