/*
 * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
 * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 */


package java.awt;

import java.awt.image.BufferedImage;
import java.security.AccessController;
import java.security.PrivilegedAction;
import java.util.Locale;

import sun.font.FontManager;
import sun.font.FontManagerFactory;
import sun.java2d.HeadlessGraphicsEnvironment;
import sun.java2d.SunGraphicsEnvironment;
import sun.security.action.GetPropertyAction;

/**
 *
 * The <code>GraphicsEnvironment</code> class describes the collection
 * of {@link GraphicsDevice} objects and {@link java.awt.Font} objects
 * available to a Java(tm) application on a particular platform.
 * The resources in this <code>GraphicsEnvironment</code> might be local
 * or on a remote machine. <code>GraphicsDevice</code> objects can be
 * screens, printers or image buffers and are the destination of
 * {@link Graphics2D} drawing methods. Each <code>GraphicsDevice</code>
 * has a number of {@link GraphicsConfiguration} objects associated with
 * it. These objects specify the different configurations in which the
 * <code>GraphicsDevice</code> can be used.
 * @see GraphicsDevice
 * @see GraphicsConfiguration
 */

public abstract class GraphicsEnvironment {
 private static GraphicsEnvironment localEnv;

 /**
 * The headless state of the Toolkit and GraphicsEnvironment
 */
 private static Boolean headless;

 /**
 * The headless state assumed by default
 */
 private static Boolean defaultHeadless;

 /**
 * This is an abstract class and cannot be instantiated directly.
 * Instances must be obtained from a suitable factory or query method.
 */
 protected GraphicsEnvironment() {
 }

 /**
 * Returns the local <code>GraphicsEnvironment</code>.
 * @return the local <code>GraphicsEnvironment</code>
 */
 public static synchronized GraphicsEnvironment getLocalGraphicsEnvironment() {
 if (localEnv == null) {
 localEnv = createGE();
 }

 return localEnv;
 }

 /**
 * Creates and returns the GraphicsEnvironment, according to the
 * system property 'java.awt.graphicsenv'.
 *
 * @return the graphics environment
 */
 private static GraphicsEnvironment createGE() {
 GraphicsEnvironment ge;
 String nm = AccessController.doPrivileged(new GetPropertyAction("java.awt.graphicsenv", null));
 try {
// long t0 = System.currentTimeMillis();
 Class<GraphicsEnvironment> geCls;
 try {
 // First we try if the bootclassloader finds the requested
 // class. This way we can avoid to run in a privileged block.
 geCls = (Class<GraphicsEnvironment>)Class.forName(nm);
 } catch (ClassNotFoundException ex) {
 // If the bootclassloader fails, we try again with the
 // application classloader.
 ClassLoader cl = ClassLoader.getSystemClassLoader();
 geCls = (Class<GraphicsEnvironment>)Class.forName(nm, true, cl);
 }
 ge = geCls.newInstance();
// long t1 = System.currentTimeMillis();
// System.out.println("GE creation took " + (t1-t0)+ "ms.");
 if (isHeadless()) {
 ge = new HeadlessGraphicsEnvironment(ge);
 }
 } catch (ClassNotFoundException e) {
 throw new Error("Could not find class: "+nm);
 } catch (InstantiationException e) {
 throw new Error("Could not instantiate Graphics Environment: "
 + nm);
 } catch (IllegalAccessException e) {
 throw new Error ("Could not access Graphics Environment: "
 + nm);
 }
 return ge;
 }

 /**
 * Tests whether or not a display, keyboard, and mouse can be
 * supported in this environment. If this method returns true,
 * a HeadlessException is thrown from areas of the Toolkit
 * and GraphicsEnvironment that are dependent on a display,
 * keyboard, or mouse.
 * @return <code>true</code> if this environment cannot support
 * a display, keyboard, and mouse; <code>false</code>
 * otherwise
 * @see java.awt.HeadlessException
 * @since 1.4
 */
 public static boolean isHeadless() {
 return getHeadlessProperty();
 }

 /**
 * @return warning message if headless state is assumed by default;
 * null otherwise
 * @since 1.5
 */
 static String getHeadlessMessage() {
 if (headless == null) {
 getHeadlessProperty(); // initialize the values
 }
 return defaultHeadless != Boolean.TRUE ? null :
 "\nNo X11 DISPLAY variable was set, " +
 "but this program performed an operation which requires it.";
 }

 /**
 * @return the value of the property "java.awt.headless"
 * @since 1.4
 */
 private static boolean getHeadlessProperty() {
 if (headless == null) {
 AccessController.doPrivileged((PrivilegedAction<Void>) () -> {
 String nm = System.getProperty("java.awt.headless");

 if (nm == null) {
 /* No need to ask for DISPLAY when run in a browser */
 if (System.getProperty("javaplugin.version") != null) {
 headless = defaultHeadless = Boolean.FALSE;
 } else {
 String osName = System.getProperty("os.name");
 if (osName.contains("OS X") && "sun.awt.HToolkit".equals(
 System.getProperty("awt.toolkit")))
 {
 headless = defaultHeadless = Boolean.TRUE;
 } else {
 final String display = System.getenv("DISPLAY");
 headless = defaultHeadless =
 ("Linux".equals(osName) ||
 "SunOS".equals(osName) ||
 "FreeBSD".equals(osName) ||
 "NetBSD".equals(osName) ||
 "OpenBSD".equals(osName) ||
 "AIX".equals(osName)) &&
 (display == null || display.trim().isEmpty());
 }
 }
 } else {
 headless = Boolean.valueOf(nm);
 }
 return null;
 });
 }
 return headless;
 }

 /**
 * Check for headless state and throw HeadlessException if headless
 * @since 1.4
 */
 static void checkHeadless() throws HeadlessException {
 if (isHeadless()) {
 throw new HeadlessException();
 }
 }

 /**
 * Returns whether or not a display, keyboard, and mouse can be
 * supported in this graphics environment. If this returns true,
 * <code>HeadlessException</code> will be thrown from areas of the
 * graphics environment that are dependent on a display, keyboard, or
 * mouse.
 * @return <code>true</code> if a display, keyboard, and mouse
 * can be supported in this environment; <code>false</code>
 * otherwise
 * @see java.awt.HeadlessException
 * @see #isHeadless
 * @since 1.4
 */
 public boolean isHeadlessInstance() {
 // By default (local graphics environment), simply check the
 // headless property.
 return getHeadlessProperty();
 }

 /**
 * Returns an array of all of the screen <code>GraphicsDevice</code>
 * objects.
 * @return an array containing all the <code>GraphicsDevice</code>
 * objects that represent screen devices
 * @exception HeadlessException if isHeadless() returns true
 * @see #isHeadless()
 */
 public abstract GraphicsDevice[] getScreenDevices()
 throws HeadlessException;

 /**
 * Returns the default screen <code>GraphicsDevice</code>.
 * @return the <code>GraphicsDevice</code> that represents the
 * default screen device
 * @exception HeadlessException if isHeadless() returns true
 * @see #isHeadless()
 */
 public abstract GraphicsDevice getDefaultScreenDevice()
 throws HeadlessException;

 /**
 * Returns a <code>Graphics2D</code> object for rendering into the
 * specified {@link BufferedImage}.
 * @param img the specified <code>BufferedImage</code>
 * @return a <code>Graphics2D</code> to be used for rendering into
 * the specified <code>BufferedImage</code>
 * @throws NullPointerException if <code>img</code> is null
 */
 public abstract Graphics2D createGraphics(BufferedImage img);

 /**
 * Returns an array containing a one-point size instance of all fonts
 * available in this <code>GraphicsEnvironment</code>. Typical usage
 * would be to allow a user to select a particular font. Then, the
 * application can size the font and set various font attributes by
 * calling the <code>deriveFont</code> method on the chosen instance.
 * <p>
 * This method provides for the application the most precise control
 * over which <code>Font</code> instance is used to render text.
 * If a font in this <code>GraphicsEnvironment</code> has multiple
 * programmable variations, only one
 * instance of that <code>Font</code> is returned in the array, and
 * other variations must be derived by the application.
 * <p>
 * If a font in this environment has multiple programmable variations,
 * such as Multiple-Master fonts, only one instance of that font is
 * returned in the <code>Font</code> array. The other variations
 * must be derived by the application.
 *
 * @return an array of <code>Font</code> objects
 * @see #getAvailableFontFamilyNames
 * @see java.awt.Font
 * @see java.awt.Font#deriveFont
 * @see java.awt.Font#getFontName
 * @since 1.2
 */
 public abstract Font[] getAllFonts();

 /**
 * Returns an array containing the names of all font families in this
 * <code>GraphicsEnvironment</code> localized for the default locale,
 * as returned by <code>Locale.getDefault()</code>.
 * <p>
 * Typical usage would be for presentation to a user for selection of
 * a particular family name. An application can then specify this name
 * when creating a font, in conjunction with a style, such as bold or
 * italic, giving the font system flexibility in choosing its own best
 * match among multiple fonts in the same font family.
 *
 * @return an array of <code>String</code> containing font family names
 * localized for the default locale, or a suitable alternative
 * name if no name exists for this locale.
 * @see #getAllFonts
 * @see java.awt.Font
 * @see java.awt.Font#getFamily
 * @since 1.2
 */
 public abstract String[] getAvailableFontFamilyNames();

 /**
 * Returns an array containing the names of all font families in this
 * <code>GraphicsEnvironment</code> localized for the specified locale.
 * <p>
 * Typical usage would be for presentation to a user for selection of
 * a particular family name. An application can then specify this name
 * when creating a font, in conjunction with a style, such as bold or
 * italic, giving the font system flexibility in choosing its own best
 * match among multiple fonts in the same font family.
 *
 * @param l a {@link Locale} object that represents a
 * particular geographical, political, or cultural region.
 * Specifying <code>null</code> is equivalent to
 * specifying <code>Locale.getDefault()</code>.
 * @return an array of <code>String</code> containing font family names
 * localized for the specified <code>Locale</code>, or a
 * suitable alternative name if no name exists for the specified locale.
 * @see #getAllFonts
 * @see java.awt.Font
 * @see java.awt.Font#getFamily
 * @since 1.2
 */
 public abstract String[] getAvailableFontFamilyNames(Locale l);

 /**
 * Registers a <i>created</i> <code>Font</code>in this
 * <code>GraphicsEnvironment</code>.
 * A created font is one that was returned from calling
 * {@link Font#createFont}, or derived from a created font by
 * calling {@link Font#deriveFont}.
 * After calling this method for such a font, it is available to
 * be used in constructing new <code>Font</code>s by name or family name,
 * and is enumerated by {@link #getAvailableFontFamilyNames} and
 * {@link #getAllFonts} within the execution context of this
 * application or applet. This means applets cannot register fonts in
 * a way that they are visible to other applets.
 * <p>
 * Reasons that this method might not register the font and therefore
 * return <code>false</code> are:
 * <ul>
 * <li>The font is not a <i>created</i> <code>Font</code>.
 * <li>The font conflicts with a non-created <code>Font</code> already
 * in this <code>GraphicsEnvironment</code>. For example if the name
 * is that of a system font, or a logical font as described in the
 * documentation of the {@link Font} class. It is implementation dependent
 * whether a font may also conflict if it has the same family name
 * as a system font.
 * <p>Notice that an application can supersede the registration
 * of an earlier created font with a new one.
 * </ul>
 * @return true if the <code>font</code> is successfully
 * registered in this <code>GraphicsEnvironment</code>.
 * @throws NullPointerException if <code>font</code> is null
 * @since 1.6
 */
 public boolean registerFont(Font font) {
 if (font == null) {
 throw new NullPointerException("font cannot be null.");
 }
 FontManager fm = FontManagerFactory.getInstance();
 return fm.registerFont(font);
 }

 /**
 * Indicates a preference for locale-specific fonts in the mapping of
 * logical fonts to physical fonts. Calling this method indicates that font
 * rendering should primarily use fonts specific to the primary writing
 * system (the one indicated by the default encoding and the initial
 * default locale). For example, if the primary writing system is
 * Japanese, then characters should be rendered using a Japanese font
 * if possible, and other fonts should only be used for characters for
 * which the Japanese font doesn't have glyphs.
 * <p>
 * The actual change in font rendering behavior resulting from a call
 * to this method is implementation dependent; it may have no effect at
 * all, or the requested behavior may already match the default behavior.
 * The behavior may differ between font rendering in lightweight
 * and peered components. Since calling this method requests a
 * different font, clients should expect different metrics, and may need
 * to recalculate window sizes and layout. Therefore this method should
 * be called before user interface initialisation.
 * @since 1.5
 */
 public void preferLocaleFonts() {
 FontManager fm = FontManagerFactory.getInstance();
 fm.preferLocaleFonts();
 }

 /**
 * Indicates a preference for proportional over non-proportional (e.g.
 * dual-spaced CJK fonts) fonts in the mapping of logical fonts to
 * physical fonts. If the default mapping contains fonts for which
 * proportional and non-proportional variants exist, then calling
 * this method indicates the mapping should use a proportional variant.
 * <p>
 * The actual change in font rendering behavior resulting from a call to
 * this method is implementation dependent; it may have no effect at all.
 * The behavior may differ between font rendering in lightweight and
 * peered components. Since calling this method requests a
 * different font, clients should expect different metrics, and may need
 * to recalculate window sizes and layout. Therefore this method should
 * be called before user interface initialisation.
 * @since 1.5
 */
 public void preferProportionalFonts() {
 FontManager fm = FontManagerFactory.getInstance();
 fm.preferProportionalFonts();
 }

 /**
 * Returns the Point where Windows should be centered.
 * It is recommended that centered Windows be checked to ensure they fit
 * within the available display area using getMaximumWindowBounds().
 * @return the point where Windows should be centered
 *
 * @exception HeadlessException if isHeadless() returns true
 * @see #getMaximumWindowBounds
 * @since 1.4
 */
 public Point getCenterPoint() throws HeadlessException {
 // Default implementation: return the center of the usable bounds of the
 // default screen device.
 Rectangle usableBounds =
 SunGraphicsEnvironment.getUsableBounds(getDefaultScreenDevice());
 return new Point((usableBounds.width / 2) + usableBounds.x,
 (usableBounds.height / 2) + usableBounds.y);
 }

 /**
 * Returns the maximum bounds for centered Windows.
 * These bounds account for objects in the native windowing system such as
 * task bars and menu bars. The returned bounds will reside on a single
 * display with one exception: on multi-screen systems where Windows should
 * be centered across all displays, this method returns the bounds of the
 * entire display area.
 * <p>
 * To get the usable bounds of a single display, use
 * <code>GraphicsConfiguration.getBounds()</code> and
 * <code>Toolkit.getScreenInsets()</code>.
 * @return the maximum bounds for centered Windows
 *
 * @exception HeadlessException if isHeadless() returns true
 * @see #getCenterPoint
 * @see GraphicsConfiguration#getBounds
 * @see Toolkit#getScreenInsets
 * @since 1.4
 */
 public Rectangle getMaximumWindowBounds() throws HeadlessException {
 // Default implementation: return the usable bounds of the default screen
 // device. This is correct for Microsoft Windows and non-Xinerama X11.
 return SunGraphicsEnvironment.getUsableBounds(getDefaultScreenDevice());
 }
}