You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
460 lines
18 KiB
460 lines
18 KiB
/*
|
|
* 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());
|
|
}
|
|
}
|