1 /*
2 * Copyright (c) 1997, 2019, 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 package sun.awt;
27
28 import java.awt.AWTPermission;
29 import java.awt.DisplayMode;
30 import java.awt.GraphicsConfiguration;
31 import java.awt.GraphicsDevice;
32 import java.awt.GraphicsEnvironment;
33 import java.awt.Rectangle;
34 import java.awt.Window;
35 import java.security.AccessController;
36 import java.security.PrivilegedAction;
37 import java.util.ArrayList;
38 import java.util.HashMap;
39 import java.util.HashSet;
40
41 import sun.awt.util.ThreadGroupUtils;
42 import sun.java2d.SunGraphicsEnvironment;
43 import sun.java2d.loops.SurfaceType;
44 import sun.java2d.opengl.GLXGraphicsConfig;
45 import sun.java2d.xr.XRGraphicsConfig;
46
47 /**
48 * This is an implementation of a GraphicsDevice object for a single
49 * X11 screen.
50 *
51 * @see GraphicsEnvironment
52 * @see GraphicsConfiguration
53 */
54 public final class X11GraphicsDevice extends GraphicsDevice
55 implements DisplayChangedListener {
56 int screen;
57 HashMap<SurfaceType, Object> x11ProxyKeyMap = new HashMap<>();
58
59 private static AWTPermission fullScreenExclusivePermission;
60 private static Boolean xrandrExtSupported;
61 private final Object configLock = new Object();
62 private SunDisplayChanger topLevels = new SunDisplayChanger();
63 private DisplayMode origDisplayMode;
64 private boolean shutdownHookRegistered;
65 private int scale;
66
67 public X11GraphicsDevice(int screennum) {
68 this.screen = screennum;
69 this.scale = initScaleFactor();
70 }
71
72 /**
73 * Returns the X11 screen of the device.
74 */
75 public int getScreen() {
76 return screen;
77 }
78
79 public Object getProxyKeyFor(SurfaceType st) {
80 synchronized (x11ProxyKeyMap) {
81 Object o = x11ProxyKeyMap.get(st);
82 if (o == null) {
83 o = new Object();
84 x11ProxyKeyMap.put(st, o);
85 }
86 return o;
87 }
88 }
89
90 /**
91 * Returns the X11 Display of this device.
92 * This method is also in MDrawingSurfaceInfo but need it here
93 * to be able to allow a GraphicsConfigTemplate to get the Display.
94 */
95 public native long getDisplay();
96
97 /**
98 * Returns the type of the graphics device.
99 * @see #TYPE_RASTER_SCREEN
100 * @see #TYPE_PRINTER
101 * @see #TYPE_IMAGE_BUFFER
102 */
103 @Override
104 public int getType() {
105 return TYPE_RASTER_SCREEN;
106 }
107
108 /**
109 * Returns the identification string associated with this graphics
110 * device.
111 */
112 @Override
113 public String getIDstring() {
114 return ":0."+screen;
115 }
116
117
118 GraphicsConfiguration[] configs;
119 GraphicsConfiguration defaultConfig;
120 HashSet<Integer> doubleBufferVisuals;
121
122 /**
123 * Returns all of the graphics
124 * configurations associated with this graphics device.
125 */
126 @Override
127 public GraphicsConfiguration[] getConfigurations() {
128 if (configs == null) {
129 synchronized (configLock) {
130 makeConfigurations();
131 }
132 }
133 return configs.clone();
134 }
135
136 private void makeConfigurations() {
137 if (configs == null) {
138 int i = 1; // Index 0 is always the default config
139 int num = getNumConfigs(screen);
140 GraphicsConfiguration[] ret = new GraphicsConfiguration[num];
141 if (defaultConfig == null) {
142 ret [0] = getDefaultConfiguration();
143 }
144 else {
145 ret [0] = defaultConfig;
146 }
147
148 boolean glxSupported = X11GraphicsEnvironment.isGLXAvailable();
149 boolean xrenderSupported = X11GraphicsEnvironment.isXRenderAvailable();
150
151 boolean dbeSupported = isDBESupported();
152 if (dbeSupported && doubleBufferVisuals == null) {
153 doubleBufferVisuals = new HashSet<>();
154 getDoubleBufferVisuals(screen);
155 }
156 for ( ; i < num; i++) {
157 int visNum = getConfigVisualId(i, screen);
158 int depth = getConfigDepth (i, screen);
159 if (glxSupported) {
160 ret[i] = GLXGraphicsConfig.getConfig(this, visNum);
161 }
162 if (ret[i] == null) {
163 boolean doubleBuffer =
164 (dbeSupported &&
165 doubleBufferVisuals.contains(Integer.valueOf(visNum)));
166
167 if (xrenderSupported) {
168 ret[i] = XRGraphicsConfig.getConfig(this, visNum, depth, getConfigColormap(i, screen),
169 doubleBuffer);
170 } else {
171 ret[i] = X11GraphicsConfig.getConfig(this, visNum, depth,
172 getConfigColormap(i, screen),
173 doubleBuffer);
174 }
175 }
176 }
177 configs = ret;
178 }
179 }
180
181 /*
182 * Returns the number of X11 visuals representable as an
183 * X11GraphicsConfig object.
184 */
185 public native int getNumConfigs(int screen);
186
187 /*
188 * Returns the visualid for the given index of graphics configurations.
189 */
190 public native int getConfigVisualId (int index, int screen);
191 /*
192 * Returns the depth for the given index of graphics configurations.
193 */
194 private native int getConfigDepth(int index, int screen);
195
196 /*
197 * Returns the colormap for the given index of graphics configurations.
198 */
199 private native int getConfigColormap(int index, int screen);
200
201 // Whether or not double-buffering extension is supported
202 static native boolean isDBESupported();
203 // Callback for adding a new double buffer visual into our set
204 private void addDoubleBufferVisual(int visNum) {
205 doubleBufferVisuals.add(Integer.valueOf(visNum));
206 }
207 // Enumerates all visuals that support double buffering
208 private native void getDoubleBufferVisuals(int screen);
209
210 /**
211 * Returns the default graphics configuration
212 * associated with this graphics device.
213 */
214 @Override
215 public GraphicsConfiguration getDefaultConfiguration() {
216 if (defaultConfig == null) {
217 synchronized (configLock) {
218 makeDefaultConfiguration();
219 }
220 }
221 return defaultConfig;
222 }
223
224 private void makeDefaultConfiguration() {
225 if (defaultConfig == null) {
226 int visNum = getConfigVisualId(0, screen);
227 if (X11GraphicsEnvironment.isGLXAvailable()) {
228 defaultConfig = GLXGraphicsConfig.getConfig(this, visNum);
229 if (X11GraphicsEnvironment.isGLXVerbose()) {
230 if (defaultConfig != null) {
231 System.out.print("OpenGL pipeline enabled");
232 } else {
233 System.out.print("Could not enable OpenGL pipeline");
234 }
235 System.out.println(" for default config on screen " +
236 screen);
237 }
238 }
239 if (defaultConfig == null) {
240 int depth = getConfigDepth(0, screen);
241 boolean doubleBuffer = false;
242 if (isDBESupported() && doubleBufferVisuals == null) {
243 doubleBufferVisuals = new HashSet<>();
244 getDoubleBufferVisuals(screen);
245 doubleBuffer =
246 doubleBufferVisuals.contains(Integer.valueOf(visNum));
247 }
248
249 if (X11GraphicsEnvironment.isXRenderAvailable()) {
250 if (X11GraphicsEnvironment.isXRenderVerbose()) {
251 System.out.println("XRender pipeline enabled");
252 }
253 defaultConfig = XRGraphicsConfig.getConfig(this, visNum,
254 depth, getConfigColormap(0, screen),
255 doubleBuffer);
256 } else {
257 defaultConfig = X11GraphicsConfig.getConfig(this, visNum,
258 depth, getConfigColormap(0, screen),
259 doubleBuffer);
260 }
261 }
262 }
263 }
264
265 private static native void enterFullScreenExclusive(long window);
266 private static native void exitFullScreenExclusive(long window);
267 private static native boolean initXrandrExtension();
268 private static native DisplayMode getCurrentDisplayMode(int screen);
269 private static native void enumDisplayModes(int screen,
270 ArrayList<DisplayMode> modes);
271 private static native void configDisplayMode(int screen,
272 int width, int height,
273 int displayMode);
274 private static native void resetNativeData(int screen);
275 private static native double getNativeScaleFactor(int screen);
276
277 /**
278 * Returns true only if:
279 * - the Xrandr extension is present
280 * - the necessary Xrandr functions were loaded successfully
281 */
282 private static synchronized boolean isXrandrExtensionSupported() {
283 if (xrandrExtSupported == null) {
284 xrandrExtSupported =
285 Boolean.valueOf(initXrandrExtension());
286 }
287 return xrandrExtSupported.booleanValue();
288 }
289
290 @Override
291 public boolean isFullScreenSupported() {
292 boolean fsAvailable = isXrandrExtensionSupported();
293 if (fsAvailable) {
294 SecurityManager security = System.getSecurityManager();
295 if (security != null) {
296 if (fullScreenExclusivePermission == null) {
297 fullScreenExclusivePermission =
298 new AWTPermission("fullScreenExclusive");
299 }
300 try {
301 security.checkPermission(fullScreenExclusivePermission);
302 } catch (SecurityException e) {
303 return false;
304 }
305 }
306 }
307 return fsAvailable;
308 }
309
310 @Override
311 public boolean isDisplayChangeSupported() {
312 return (isFullScreenSupported()
313 && (getFullScreenWindow() != null)
314 && !((X11GraphicsEnvironment) GraphicsEnvironment
315 .getLocalGraphicsEnvironment()).runningXinerama());
316 }
317
318 private static void enterFullScreenExclusive(Window w) {
319 X11ComponentPeer peer = AWTAccessor.getComponentAccessor().getPeer(w);
320 if (peer != null) {
321 enterFullScreenExclusive(peer.getWindow());
322 peer.setFullScreenExclusiveModeState(true);
323 }
324 }
325
326 private static void exitFullScreenExclusive(Window w) {
327 X11ComponentPeer peer = AWTAccessor.getComponentAccessor().getPeer(w);
328 if (peer != null) {
329 peer.setFullScreenExclusiveModeState(false);
330 exitFullScreenExclusive(peer.getWindow());
331 }
332 }
333
334 @Override
335 public synchronized void setFullScreenWindow(Window w) {
336 Window old = getFullScreenWindow();
337 if (w == old) {
338 return;
339 }
340
341 boolean fsSupported = isFullScreenSupported();
342 if (fsSupported && old != null) {
343 // enter windowed mode (and restore original display mode)
344 exitFullScreenExclusive(old);
345 if (isDisplayChangeSupported()) {
346 setDisplayMode(origDisplayMode);
347 }
348 }
349
350 super.setFullScreenWindow(w);
351
352 if (fsSupported && w != null) {
353 // save original display mode
354 if (origDisplayMode == null) {
355 origDisplayMode = getDisplayMode();
356 }
357
358 // enter fullscreen mode
359 enterFullScreenExclusive(w);
360 }
361 }
362
363 private DisplayMode getDefaultDisplayMode() {
364 GraphicsConfiguration gc = getDefaultConfiguration();
365 Rectangle r = gc.getBounds();
366 return new DisplayMode(r.width, r.height,
367 DisplayMode.BIT_DEPTH_MULTI,
368 DisplayMode.REFRESH_RATE_UNKNOWN);
369 }
370
371 @Override
372 public synchronized DisplayMode getDisplayMode() {
373 if (isFullScreenSupported()) {
374 DisplayMode mode = getCurrentDisplayMode(screen);
375 if (mode == null) {
376 mode = getDefaultDisplayMode();
377 }
378 return mode;
379 } else {
380 if (origDisplayMode == null) {
381 origDisplayMode = getDefaultDisplayMode();
382 }
383 return origDisplayMode;
384 }
385 }
386
387 @Override
388 public synchronized DisplayMode[] getDisplayModes() {
389 if (!isFullScreenSupported()) {
390 return super.getDisplayModes();
391 }
392 ArrayList<DisplayMode> modes = new ArrayList<DisplayMode>();
393 enumDisplayModes(screen, modes);
394 DisplayMode[] retArray = new DisplayMode[modes.size()];
395 return modes.toArray(retArray);
396 }
397
398 @Override
399 public synchronized void setDisplayMode(DisplayMode dm) {
400 if (!isDisplayChangeSupported()) {
401 super.setDisplayMode(dm);
402 return;
403 }
404 Window w = getFullScreenWindow();
405 if (w == null) {
406 throw new IllegalStateException("Must be in fullscreen mode " +
407 "in order to set display mode");
408 }
409 if (getDisplayMode().equals(dm)) {
410 return;
411 }
412 if (dm == null ||
413 (dm = getMatchingDisplayMode(dm)) == null)
414 {
415 throw new IllegalArgumentException("Invalid display mode");
416 }
417
418 if (!shutdownHookRegistered) {
419 // register a shutdown hook so that we return to the
420 // original DisplayMode when the VM exits (if the application
421 // is already in the original DisplayMode at that time, this
422 // hook will have no effect)
423 shutdownHookRegistered = true;
424 PrivilegedAction<Void> a = () -> {
425 Runnable r = () -> {
426 Window old = getFullScreenWindow();
427 if (old != null) {
428 exitFullScreenExclusive(old);
429 if (isDisplayChangeSupported()) {
430 setDisplayMode(origDisplayMode);
431 }
432 }
433 };
434 String name = "Display-Change-Shutdown-Thread-" + screen;
435 Thread t = new Thread(
436 ThreadGroupUtils.getRootThreadGroup(), r, name, 0, false);
437 t.setContextClassLoader(null);
438 Runtime.getRuntime().addShutdownHook(t);
439 return null;
440 };
441 AccessController.doPrivileged(a);
442 }
443
444 // switch to the new DisplayMode
445 configDisplayMode(screen,
446 dm.getWidth(), dm.getHeight(),
447 dm.getRefreshRate());
448
449 // update bounds of the fullscreen window
450 w.setBounds(0, 0, dm.getWidth(), dm.getHeight());
451
452 // configDisplayMode() is synchronous, so the display change will be
453 // complete by the time we get here (and it is therefore safe to call
454 // displayChanged() now)
455 ((X11GraphicsEnvironment)
456 GraphicsEnvironment.getLocalGraphicsEnvironment()).displayChanged();
457 }
458
459 private synchronized DisplayMode getMatchingDisplayMode(DisplayMode dm) {
460 if (!isDisplayChangeSupported()) {
461 return null;
462 }
463 DisplayMode[] modes = getDisplayModes();
464 for (DisplayMode mode : modes) {
465 if (dm.equals(mode) ||
466 (dm.getRefreshRate() == DisplayMode.REFRESH_RATE_UNKNOWN &&
467 dm.getWidth() == mode.getWidth() &&
468 dm.getHeight() == mode.getHeight() &&
469 dm.getBitDepth() == mode.getBitDepth()))
470 {
471 return mode;
472 }
473 }
474 return null;
475 }
476
477 /**
478 * From the DisplayChangedListener interface; called from
479 * X11GraphicsEnvironment when the display mode has been changed.
480 */
481 @Override
482 public synchronized void displayChanged() {
483 scale = initScaleFactor();
484 // On X11 the visuals do not change, and therefore we don't need
485 // to reset the defaultConfig, config, doubleBufferVisuals,
486 // neither do we need to reset the native data.
487
488 // pass on to all top-level windows on this screen
489 topLevels.notifyListeners();
490 }
491
492 /**
493 * From the DisplayChangedListener interface; devices do not need
494 * to react to this event.
495 */
496 @Override
497 public void paletteChanged() {
498 }
499
500 /**
501 * Add a DisplayChangeListener to be notified when the display settings
502 * are changed. Typically, only top-level containers need to be added
503 * to X11GraphicsDevice.
504 */
505 public void addDisplayChangedListener(DisplayChangedListener client) {
506 topLevels.add(client);
507 }
508
509 public int getScaleFactor() {
510 return scale;
511 }
512
513 public int getNativeScale() {
514 isXrandrExtensionSupported();
515 return (int)Math.round(getNativeScaleFactor(screen));
516 }
517
518 private int initScaleFactor() {
519
520 if (SunGraphicsEnvironment.isUIScaleEnabled()) {
521
522 double debugScale = SunGraphicsEnvironment.getDebugScale();
523
524 if (debugScale >= 1) {
525 return (int) debugScale;
526 }
527 int nativeScale = getNativeScale();
528 return nativeScale >= 1 ? nativeScale : 1;
529 }
530
531 return 1;
532 }
533
534 /**
535 * Remove a DisplayChangeListener from this X11GraphicsDevice.
536 */
537 public void removeDisplayChangedListener(DisplayChangedListener client) {
538 topLevels.remove(client);
539 }
540
541 public String toString() {
542 return ("X11GraphicsDevice[screen="+screen+"]");
543 }
544 }