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