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.java2d;
  27 
  28 import java.awt.AWTError;
  29 import java.awt.Color;
  30 import java.awt.Font;
  31 import java.awt.Graphics2D;
  32 import java.awt.GraphicsConfiguration;
  33 import java.awt.GraphicsDevice;
  34 import java.awt.GraphicsEnvironment;
  35 import java.awt.Insets;
  36 import java.awt.Point;
  37 import java.awt.Rectangle;
  38 import java.awt.Toolkit;
  39 import java.awt.geom.AffineTransform;
  40 import java.awt.image.BufferedImage;
  41 import java.awt.peer.ComponentPeer;
  42 import java.security.AccessController;
  43 import java.util.Locale;
  44 import java.util.TreeMap;
  45 
  46 import sun.awt.DisplayChangedListener;
  47 import sun.awt.SunDisplayChanger;
  48 import sun.font.FontManager;
  49 import sun.font.FontManagerFactory;
  50 import sun.font.FontManagerForSGE;
  51 import sun.java2d.pipe.Region;
  52 import sun.security.action.GetPropertyAction;
  53 
  54 /**
  55  * This is an implementation of a GraphicsEnvironment object for the
  56  * default local GraphicsEnvironment.
  57  *
  58  * @see GraphicsDevice
  59  * @see GraphicsConfiguration
  60  */
  61 public abstract class SunGraphicsEnvironment extends GraphicsEnvironment
  62     implements DisplayChangedListener {
  63 
  64     /** Establish the default font to be used by SG2D. */
  65     private final Font defaultFont = new Font(Font.DIALOG, Font.PLAIN, 12);
  66 
  67     private static final boolean uiScaleEnabled;
  68     private static final double debugScale;
  69 
  70     static {
  71         uiScaleEnabled = "true".equals(AccessController.doPrivileged(
  72                 new GetPropertyAction("sun.java2d.uiScale.enabled", "true")));
  73         debugScale = uiScaleEnabled ? getScaleFactor("sun.java2d.uiScale") : -1;
  74     }
  75 
  76     protected GraphicsDevice[] screens;
  77 
  78     /**
  79      * Returns an array of all of the screen devices.
  80      */
  81     public synchronized GraphicsDevice[] getScreenDevices() {
  82         GraphicsDevice[] ret = screens;
  83         if (ret == null) {
  84             int num = getNumScreens();
  85             ret = new GraphicsDevice[num];
  86             for (int i = 0; i < num; i++) {
  87                 ret[i] = makeScreenDevice(i);
  88             }
  89             screens = ret;
  90         }
  91         return ret;
  92     }
  93 
  94     /**
  95      * Returns the number of screen devices of this graphics environment.
  96      *
  97      * @return the number of screen devices of this graphics environment
  98      */
  99     protected abstract int getNumScreens();
 100 
 101     /**
 102      * Create and return the screen device with the specified number. The
 103      * device with number {@code 0} will be the default device (returned
 104      * by {@link #getDefaultScreenDevice()}.
 105      *
 106      * @param screennum the number of the screen to create
 107      *
 108      * @return the created screen device
 109      */
 110     protected abstract GraphicsDevice makeScreenDevice(int screennum);
 111 
 112     /**
 113      * Returns the default screen graphics device.
 114      */
 115     public GraphicsDevice getDefaultScreenDevice() {
 116         GraphicsDevice[] screens = getScreenDevices();
 117         if (screens.length == 0) {
 118             throw new AWTError("no screen devices");
 119         }
 120         return screens[0];
 121     }
 122 
 123     /**
 124      * Returns a Graphics2D object for rendering into the
 125      * given BufferedImage.
 126      * @throws NullPointerException if BufferedImage argument is null
 127      */
 128     public Graphics2D createGraphics(BufferedImage img) {
 129         if (img == null) {
 130             throw new NullPointerException("BufferedImage cannot be null");
 131         }
 132         SurfaceData sd = SurfaceData.getPrimarySurfaceData(img);
 133         return new SunGraphics2D(sd, Color.white, Color.black, defaultFont);
 134     }
 135 
 136     public static FontManagerForSGE getFontManagerForSGE() {
 137         FontManager fm = FontManagerFactory.getInstance();
 138         return (FontManagerForSGE) fm;
 139     }
 140 
 141     /* Modifies the behaviour of a subsequent call to preferLocaleFonts()
 142      * to use Mincho instead of Gothic for dialoginput in JA locales
 143      * on windows. Not needed on other platforms.
 144      *
 145      * @deprecated as of JDK9. To be removed in a future release
 146      */
 147     @Deprecated
 148     public static void useAlternateFontforJALocales() {
 149         getFontManagerForSGE().useAlternateFontforJALocales();
 150     }
 151 
 152      /**
 153      * Returns all fonts available in this environment.
 154      */
 155     public Font[] getAllFonts() {
 156         FontManagerForSGE fm = getFontManagerForSGE();
 157         Font[] installedFonts = fm.getAllInstalledFonts();
 158         Font[] created = fm.getCreatedFonts();
 159         if (created == null || created.length == 0) {
 160             return installedFonts;
 161         } else {
 162             int newlen = installedFonts.length + created.length;
 163             Font [] fonts = java.util.Arrays.copyOf(installedFonts, newlen);
 164             System.arraycopy(created, 0, fonts,
 165                              installedFonts.length, created.length);
 166             return fonts;
 167         }
 168     }
 169 
 170     public String[] getAvailableFontFamilyNames(Locale requestedLocale) {
 171         FontManagerForSGE fm = getFontManagerForSGE();
 172         String[] installed = fm.getInstalledFontFamilyNames(requestedLocale);
 173         /* Use a new TreeMap as used in getInstalledFontFamilyNames
 174          * and insert all the keys in lower case, so that the sort order
 175          * is the same as the installed families. This preserves historical
 176          * behaviour and inserts new families in the right place.
 177          * It would have been marginally more efficient to directly obtain
 178          * the tree map and just insert new entries, but not so much as
 179          * to justify the extra internal interface.
 180          */
 181         TreeMap<String, String> map = fm.getCreatedFontFamilyNames();
 182         if (map == null || map.size() == 0) {
 183             return installed;
 184         } else {
 185             for (int i=0; i<installed.length; i++) {
 186                 map.put(installed[i].toLowerCase(requestedLocale),
 187                         installed[i]);
 188             }
 189             String[] retval =  new String[map.size()];
 190             Object [] keyNames = map.keySet().toArray();
 191             for (int i=0; i < keyNames.length; i++) {
 192                 retval[i] = map.get(keyNames[i]);
 193             }
 194             return retval;
 195         }
 196     }
 197 
 198     public String[] getAvailableFontFamilyNames() {
 199         return getAvailableFontFamilyNames(Locale.getDefault());
 200     }
 201 
 202     /**
 203      * Return the bounds of a GraphicsDevice, less its screen insets.
 204      * See also java.awt.GraphicsEnvironment.getUsableBounds();
 205      */
 206     public static Rectangle getUsableBounds(GraphicsDevice gd) {
 207         GraphicsConfiguration gc = gd.getDefaultConfiguration();
 208         Insets insets = Toolkit.getDefaultToolkit().getScreenInsets(gc);
 209         Rectangle usableBounds = gc.getBounds();
 210 
 211         usableBounds.x += insets.left;
 212         usableBounds.y += insets.top;
 213         usableBounds.width -= (insets.left + insets.right);
 214         usableBounds.height -= (insets.top + insets.bottom);
 215 
 216         return usableBounds;
 217     }
 218 
 219     /**
 220      * From the DisplayChangedListener interface; called
 221      * when the display mode has been changed.
 222      */
 223     public void displayChanged() {
 224         // notify screens in device array to do display update stuff
 225         for (GraphicsDevice gd : getScreenDevices()) {
 226             if (gd instanceof DisplayChangedListener) {
 227                 ((DisplayChangedListener) gd).displayChanged();
 228             }
 229         }
 230 
 231         // notify SunDisplayChanger list (e.g. VolatileSurfaceManagers and
 232         // SurfaceDataProxies) about the display change event
 233         displayChanger.notifyListeners();
 234     }
 235 
 236     /**
 237      * Part of the DisplayChangedListener interface:
 238      * propagate this event to listeners
 239      */
 240     public void paletteChanged() {
 241         displayChanger.notifyPaletteChanged();
 242     }
 243 
 244     /**
 245      * Returns true when the display is local, false for remote displays.
 246      *
 247      * @return true when the display is local, false for remote displays
 248      */
 249     public abstract boolean isDisplayLocal();
 250 
 251     /*
 252      * ----DISPLAY CHANGE SUPPORT----
 253      */
 254 
 255     protected SunDisplayChanger displayChanger = new SunDisplayChanger();
 256 
 257     /**
 258      * Add a DisplayChangeListener to be notified when the display settings
 259      * are changed.
 260      */
 261     public void addDisplayChangedListener(DisplayChangedListener client) {
 262         displayChanger.add(client);
 263     }
 264 
 265     /**
 266      * Remove a DisplayChangeListener from Win32GraphicsEnvironment
 267      */
 268     public void removeDisplayChangedListener(DisplayChangedListener client) {
 269         displayChanger.remove(client);
 270     }
 271 
 272     /*
 273      * ----END DISPLAY CHANGE SUPPORT----
 274      */
 275 
 276     /**
 277      * Returns true if FlipBufferStrategy with COPIED buffer contents
 278      * is preferred for this peer's GraphicsConfiguration over
 279      * BlitBufferStrategy, false otherwise.
 280      *
 281      * The reason FlipBS could be preferred is that in some configurations
 282      * an accelerated copy to the screen is supported (like Direct3D 9)
 283      *
 284      * @return true if flip strategy should be used, false otherwise
 285      */
 286     public boolean isFlipStrategyPreferred(ComponentPeer peer) {
 287         return false;
 288     }
 289 
 290     public static boolean isUIScaleEnabled() {
 291         return uiScaleEnabled;
 292     }
 293 
 294     public static double getDebugScale() {
 295         return debugScale;
 296     }
 297 
 298     public static double getScaleFactor(String propertyName) {
 299 
 300         String scaleFactor = AccessController.doPrivileged(
 301                 new GetPropertyAction(propertyName, "-1"));
 302 
 303         if (scaleFactor == null || scaleFactor.equals("-1")) {
 304             return -1;
 305         }
 306 
 307         try {
 308             double units = 1.0;
 309 
 310             if (scaleFactor.endsWith("x")) {
 311                 scaleFactor = scaleFactor.substring(0, scaleFactor.length() - 1);
 312             } else if (scaleFactor.endsWith("dpi")) {
 313                 units = 96;
 314                 scaleFactor = scaleFactor.substring(0, scaleFactor.length() - 3);
 315             } else if (scaleFactor.endsWith("%")) {
 316                 units = 100;
 317                 scaleFactor = scaleFactor.substring(0, scaleFactor.length() - 1);
 318             }
 319 
 320             double scale = Double.parseDouble(scaleFactor);
 321             return scale <= 0 ? -1 : scale / units;
 322         } catch (NumberFormatException ignored) {
 323             return -1;
 324         }
 325     }
 326 
 327     /**
 328      * Returns the graphics configuration which bounds contain the given point.
 329      *
 330      * @param  current the default configuration which is checked in the first
 331      *         place
 332      * @param  x the x coordinate of the given point
 333      * @param  y the y coordinate of the given point
 334      * @return the graphics configuration
 335      */
 336     public static GraphicsConfiguration getGraphicsConfigurationAtPoint(
 337             GraphicsConfiguration current, double x, double y) {
 338         if (current.getBounds().contains(x, y)) {
 339             return current;
 340         }
 341         GraphicsEnvironment env = getLocalGraphicsEnvironment();
 342         for (GraphicsDevice device : env.getScreenDevices()) {
 343             GraphicsConfiguration config = device.getDefaultConfiguration();
 344             if (config.getBounds().contains(x, y)) {
 345                 return config;
 346             }
 347         }
 348         return current;
 349     }
 350 
 351     /**
 352      * Converts coordinates from the user's space to the device space using
 353      * appropriate device transformation.
 354      *
 355      * @param  x coordinate in the user space
 356      * @param  y coordinate in the user space
 357      * @return the point which uses device space(pixels)
 358      */
 359     public static Point convertToDeviceSpace(double x, double y) {
 360         GraphicsConfiguration gc = getLocalGraphicsEnvironment()
 361                         .getDefaultScreenDevice().getDefaultConfiguration();
 362         gc = getGraphicsConfigurationAtPoint(gc, x, y);
 363 
 364         AffineTransform tx = gc.getDefaultTransform();
 365         x = Region.clipRound(x * tx.getScaleX());
 366         y = Region.clipRound(y * tx.getScaleY());
 367 
 368         return new Point((int) x, (int) y);
 369     }
 370 }