|
Java example source code file (GraphicsEnvironment.java)
The GraphicsEnvironment.java Java example source code/* * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License version 2 only, as * published by the Free Software Foundation. Oracle designates this * particular file as subject to the "Classpath" exception as provided * by Oracle in the LICENSE file that accompanied this code. * * This code is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License * version 2 for more details (a copy is included in the LICENSE file that * accompanied this code). * * You should have received a copy of the GNU General Public License version * 2 along with this work; if not, write to the Free Software Foundation, * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. * * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA * or visit www.oracle.com if you need additional information or have any * questions. */ package java.awt; import java.awt.image.BufferedImage; import java.security.AccessController; 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 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 might be local * or on a remote machine. <code>GraphicsDevice objects can be * screens, printers or image buffers and are the destination of * {@link Graphics2D} drawing methods. Each <code>GraphicsDevice * has a number of {@link GraphicsConfiguration} objects associated with * it. These objects specify the different configurations in which the * <code>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 <code>GraphicsEnvironment. * @return the local <code>GraphicsEnvironment */ 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 if this environment cannot support * a display, keyboard, and mouse; <code>false * 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) { java.security.AccessController.doPrivileged( new java.security.PrivilegedAction<Object>() { 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; } 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 { headless = defaultHeadless = Boolean.valueOf(("Linux".equals(osName) || "SunOS".equals(osName) || "FreeBSD".equals(osName) || "NetBSD".equals(osName) || "OpenBSD".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, * <code>HeadlessException will be thrown from areas of the * graphics environment that are dependent on a display, keyboard, or * mouse. * @return <code>true if a display, keyboard, and mouse * can be supported in this environment; <code>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 <code>GraphicsDevice * objects. * @return an array containing all the <code>GraphicsDevice * 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. * @return the <code>GraphicsDevice that represents the * default screen device * @exception HeadlessException if isHeadless() returns true * @see #isHeadless() */ public abstract GraphicsDevice getDefaultScreenDevice() throws HeadlessException; /** * Returns a <code>Graphics2D object for rendering into the * specified {@link BufferedImage}. * @param img the specified <code>BufferedImage * @return a <code>Graphics2D to be used for rendering into * the specified <code>BufferedImage * @throws NullPointerException if <code>img 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. 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 method on the chosen instance. * <p> * This method provides for the application the most precise control * over which <code>Font instance is used to render text. * If a font in this <code>GraphicsEnvironment has multiple * programmable variations, only one * instance of that <code>Font 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 array. The other variations * must be derived by the application. * * @return an array of <code>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 * <code>GraphicsEnvironment localized for the default locale, * as returned by <code>Locale.getDefault(). * <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 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 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 is equivalent to * specifying <code>Locale.getDefault(). * @return an array of <code>String containing font family names * localized for the specified <code>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 <i>created Other Java examples (source code examples)Here is a short list of links related to this Java GraphicsEnvironment.java source code file: |
... this post is sponsored by my books ... | |
#1 New Release! |
FP Best Seller |
Copyright 1998-2021 Alvin Alexander, alvinalexander.com
All Rights Reserved.
A percentage of advertising revenue from
pages under the /java/jwarehouse
URI on this website is
paid back to open source projects.