GraphicsEnvironment 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 GraphicsEnvironment might be local
* or on a remote machine. GraphicsDevice objects can be
* screens, printers or image buffers and are the destination of
* {@link Graphics2D} drawing methods. Each GraphicsDevice
* has a number of {@link GraphicsConfiguration} objects associated with
* it. These objects specify the different configurations in which the
* GraphicsDevice 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 GraphicsEnvironment.
* @return the local GraphicsEnvironment
*/
public static synchronized GraphicsEnvironment getLocalGraphicsEnvironment() {
if (localEnv == null) {
localEnv = (GraphicsEnvironment) JSToolkit.getInstance("swingjs.JSGraphicsEnvironment");
// String nm = null;
//// final String def = null;
//// String nm = (String) jsjava.security.AccessController.doPrivileged
//// (new jssun.security.action.GetPropertyAction
//// ("java.awt.graphicsenv", def));
////
// 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;
}
/**
* 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 true if this environment cannot support
* a display, keyboard, and mouse; false
* otherwise
* @see java.awt.HeadlessException
* @since 1.4
*/
public static boolean isHeadless() {
return false;//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() {
return false;
// if (headless == null) {
// jsjava.security.AccessController.doPrivileged(
// new jsjava.security.PrivilegedAction() {
// public Object run() {
// 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;retrr
// } else {
// String osName = System.getProperty("os.name");
// headless = defaultHeadless =
// Boolean.valueOf(("Linux".equals(osName) || "SunOS".equals(osName)) &&
// (System.getenv("DISPLAY") == null));
// }
// } else if (nm.equals("true")) {
// headless = Boolean.TRUE;
// } else {
// headless = Boolean.FALSE;
// }
// return null;
// }
// }
// );
// }
// return headless.booleanValue();
}
/**
* 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,
* HeadlessException will be thrown from areas of the
* graphics environment that are dependent on a display, keyboard, or
* mouse.
* @return true if a display, keyboard, and mouse
* can be supported in this environment; false
* 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 GraphicsDevice
// * objects.
// * @return an array containing all the GraphicsDevice
// * objects that represent screen devices
// * @exception HeadlessException if isHeadless() returns true
// * @see #isHeadless()
// */
// public abstract GraphicsDevice[] getScreenDevices()
// throws HeadlessException;
/**
* Returns the default screen GraphicsDevice.
* @return the GraphicsDevice that represents the
* default screen device
* @exception HeadlessException if isHeadless() returns true
* @see #isHeadless()
*/
public abstract GraphicsDevice getDefaultScreenDevice();
// throws HeadlessException;
/**
* Returns a Graphics2D object for rendering into the
* specified {@link BufferedImage}.
* @param img the specified BufferedImage
* @return a Graphics2D to be used for rendering into
* the specified BufferedImage
* @throws NullPointerException if img is null
*/
public abstract Graphics2D createGraphics(BufferedImage img);
/**
* 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.
*
* @return an array of Font 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
* 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.
*
* @return an array of String 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
* 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.
*
* @param l a {@link Locale} object that represents a
* particular geographical, political, or cultural region.
* Specifying null is equivalent to
* specifying Locale.getDefault().
* @return an array of String containing font family names
* localized for the specified Locale, 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 created Fontin this
* GraphicsEnvironment.
* 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 Fonts 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.
*
* Reasons that this method might not register the font and therefore
* return false are:
*
Font.
* 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 {@link 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. *
font is successfully
* registered in this GraphicsEnvironment.
* @since 1.6
*/
public boolean registerFont(Font font) {
// if (font == null) {
// throw new NullPointerException("font cannot be null.");
// }
// return sun.font.FontManager.registerFont(font);
return true;
}
/**
* 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. * @since 1.5 */ public void preferLocaleFonts() { // SwingJS ?? sun.font.FontManager.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. *
* 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() { //sun.font.FontManager.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() { return null; // TODO // // 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. // *
// * To get the usable bounds of a single display, use
// * GraphicsConfiguration.getBounds() and
// * Toolkit.getScreenInsets().
// * @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() {
// return null; // toDO?
//// // 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());
// }
}