protected GraphicsEnvironment() 
{

}

This is an abstract class and cannot be instantiated directly. Instances must be obtained from a suitable factory or query method.

 static  void checkHeadless() throws HeadlessException 
{
        if (isHeadless()) {
            throw new HeadlessException();
        }
}

Check for headless state and throw HeadlessException if headless

 abstract public Graphics2D createGraphics(BufferedImage img)
Returns a Graphics2D object for rendering into the
specified BufferedImage .

 abstract public Font[] getAllFonts()
Returns an array containing a one-point size instance of all fonts
available in this GraphicsEnvironment. 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 deriveFont method on the choosen instance.

This method provides for the application the most precise control
over which Font instance is used to render text.
If a font in this GraphicsEnvironment has multiple
programmable variations, only one
instance of that Font is returned in the array, and
other variations must be derived by the application.

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 Font array. The other variations
must be derived by the application.

 abstract public String[] getAvailableFontFamilyNames()
Returns an array containing the names of all font families in this
GraphicsEnvironment localized for the default locale,
as returned by Locale.getDefault().

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.

 abstract public String[] getAvailableFontFamilyNames(Locale l)
Returns an array containing the names of all font families in this
GraphicsEnvironment localized for the specified locale.

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.

 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 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().

 abstract public GraphicsDevice getDefaultScreenDevice() throws HeadlessException
Returns the default screen GraphicsDevice.

 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.";
}

 public static synchronized GraphicsEnvironment getLocalGraphicsEnvironment() 
{
        if (localEnv == null) {
            String nm = (String) java.security.AccessController.doPrivileged
                (new sun.security.action.GetPropertyAction
                 ("java.awt.graphicsenv", null));
            try {
//                      long t0 = System.currentTimeMillis();
                localEnv =
                    (GraphicsEnvironment) Class.forName(nm).newInstance();
//              long t1 = System.currentTimeMillis();
//              System.out.println("GE creation took " + (t1-t0)+ "ms.");
                if (isHeadless()) {
                    localEnv = new HeadlessGraphicsEnvironment(localEnv);
                }
            } 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 localEnv;
}

Returns the local GraphicsEnvironment.

 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());
}

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.

To get the usable bounds of a single display, use GraphicsConfiguration.getBounds() and Toolkit.getScreenInsets().

 abstract public GraphicsDevice[] getScreenDevices() throws HeadlessException
Returns an array of all of the screen GraphicsDevice
objects.

 public static boolean isHeadless() 
{
        return getHeadlessProperty();
}

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.

 public boolean isHeadlessInstance() 
{
        // By default (local graphics environment), simply check the
        // headless property.
        return getHeadlessProperty();
}

Returns whether or not a display, keyboard, and mouse can be supported in this graphics environment. If this returns true, HeadlessException will be thrown from areas of the graphics environment that are dependent on a display, keyboard, or mouse.

 public  void preferLocaleFonts() 
{
        sun.font.FontManager.preferLocaleFonts();
}

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.

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.

 public  void preferProportionalFonts() 
{
        sun.font.FontManager.preferProportionalFonts();
}

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.

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.

 public boolean registerFont(Font font) 
{
        if (font == null) {
            throw new NullPointerException("font cannot be null.");
        }
        return sun.font.FontManager.registerFont(font);
}

Registers a created Fontin this GraphicsEnvironment. A created font is one that was returned from calling Font#createFont , or derived from a created font by calling Font#deriveFont . After calling this method for such a font, it is available to be used in constructing new Fonts by name or family name, and is enumerated by #getAvailableFontFamilyNames and #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.

Reasons that this method might not register the font and therefore return false are:

• The font is not a created Font.
• The font conflicts with a non-created Font already in this GraphicsEnvironment. For example if the name is that of a system font, or a logical font as described in the documentation of the Font class. It is implementation dependent whether a font may also conflict if it has the same family name as a system font.

  Notice that an application can supersede the registration of an earlier created font with a new one.