1. /*

  2.  * @(#)GraphicsEnvironment.java	1.37 01/11/29

  3.  *

  4.  * Copyright 2002 Sun Microsystems, Inc. All rights reserved.

  5.  * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.

  6.  */

  7. 

  8. 

  9. package java.awt;

  10. 

  11. import java.awt.image.BufferedImage;

  12. import java.util.Hashtable;

  13. import java.util.Locale;

  14. import java.util.Map;

  15. import java.io.InputStream;

  16. 

  17. /**

  18.  *

  19.  * The <code>GraphicsEnvironment</code> class describes the collection

  20.  * of {@link GraphicsDevice} objects and {@link java.awt.Font} objects

  21.  * available to a Java(tm) application on a particular platform.

  22.  * The resources in this <code>GraphicsEnvironment</code> might be local

  23.  * or on a remote machine.  <code>GraphicsDevice</code> objects can be

  24.  * screens, printers or image buffers and are the destination of

  25.  * {@link Graphics2D} drawing methods.  Each <code>GraphicsDevice</code>

  26.  * has a number of {@link GraphicsConfiguration} objects associated with

  27.  * it.  These objects specify the different configurations in which the

  28.  * <code>GraphicsDevice</code> can be used.  

  29.  * @see GraphicsDevice

  30.  * @see GraphicsConfiguration

  31.  * @version 10 Feb 1997

  32.  */

  33. 

  34. public abstract class GraphicsEnvironment {

  35.     private static GraphicsEnvironment localEnv;

  36. 

  37.     /**

  38.      * This is an abstract class and cannot be instantiated directly.

  39.      * Instances must be obtained from a suitable factory or query method.

  40.      */

  41.     protected GraphicsEnvironment() {

  42.     }

  43. 

  44.     /**

  45.      * Returns the local <code>GraphicsEnvironment</code>.

  46.      * @return this <code>GraphicsEnvironment</code>.

  47.      */

  48.     public static GraphicsEnvironment getLocalGraphicsEnvironment() {

  49. 	if (localEnv == null) {

  50. 	    String nm = (String) java.security.AccessController.doPrivileged

  51. 		(new sun.security.action.GetPropertyAction

  52. 		 ("java.awt.graphicsenv", null));

  53. 

  54. 	    try {

  55. 		localEnv =

  56. 		    (GraphicsEnvironment) Class.forName(nm).newInstance();

  57. 	    } catch (ClassNotFoundException e) {

  58.                 throw new Error("Could not find class: "+nm);

  59.             } catch (InstantiationException e) {

  60.                 throw new Error("Could not instantiate Graphics Environment: "

  61. 				+ nm);

  62.             } catch (IllegalAccessException e) {

  63.                 throw new Error ("Could not access Graphics Environment: "

  64. 				 + nm);

  65.             }

  66.         }

  67. 

  68. 	return localEnv;

  69.     }

  70. 

  71.     /**

  72.      * Returns an array of all of the screen <code>GraphicsDevice</code>

  73.      * objects.

  74.      * @return an array containing all the <code>GraphicsDevice</code>

  75.      * objects that represent screen devices.

  76.      */

  77.     public abstract GraphicsDevice[] getScreenDevices();

  78. 

  79.     /**

  80.      * Returns the default screen <code>GraphicsDevice</code>.

  81.      * @return the <code>GraphicsDevice</code> that represents the

  82.      * default screen device.

  83.      */

  84.     public abstract GraphicsDevice getDefaultScreenDevice();

  85. 

  86.     /**

  87.      * Returns a <code>Graphics2D</code> object for rendering into the

  88.      * specified {@link BufferedImage}.

  89.      * @param img the specified <code>BufferedImage</code>

  90.      * @return a <code>Graphics2D</code> to be used for rendering into

  91.      * the specified <code>BufferedImage</code>.

  92.      */

  93.     public abstract Graphics2D createGraphics(BufferedImage img);

  94. 

  95.     /**

  96.      * Returns an array containing a one-point size instance of all fonts

  97.      * available in this <code>GraphicsEnvironment</code>.  Typical usage

  98.      * would be to allow a user to select a particular font.  Then, the

  99.      * application can size the font and set various font attributes by

  100.      * calling the <code>deriveFont</code> method on the choosen instance.

  101.      * <p>

  102.      * This method provides for the application the most precise control

  103.      * over which <code>Font</code> instance is used to render text.

  104.      * If a font in this <code>GraphicsEnvironment</code> has multiple

  105.      * programmable variations, only one

  106.      * instance of that <code>Font</code> is returned in the array, and

  107.      * other variations must be derived by the application.

  108.      * <p>

  109.      * If a font in this environment has multiple programmable variations,

  110.      * such as Multiple-Master fonts, only one instance of that font is

  111.      * returned in the <code>Font</code> array.  The other variations

  112.      * must be derived by the application.

  113.      * @return an array of <code>Font</code> objects.

  114.      * @see #getAvailableFontFamilyNames

  115.      * @see java.awt.Font

  116.      * @see java.awt.Font#deriveFont

  117.      * @see java.awt.Font#getFontName

  118.      * @since JDK 1.2

  119.      */

  120.     public abstract Font[] getAllFonts();

  121. 

  122.     /**

  123.      * Returns an array containing the names of all font families available

  124.      * in this <code>GraphicsEnvironment</code>.

  125.      * Typical usage would be to allow a user to select a particular family

  126.      * name and allow the application to choose related variants of the

  127.      * same family when the user specifies style attributes such

  128.      * as Bold or Italic.

  129.      * <p>

  130.      * This method provides for the application some control over which

  131.      * <code>Font</code> instance is used to render text, but allows the 

  132.      * <code>Font</code> object more flexibility in choosing its own best

  133.      * match among multiple fonts in the same font family.

  134.      * @return an array of <code>String</code> containing names of font

  135.      * families.

  136.      * @see #getAllFonts

  137.      * @see java.awt.Font

  138.      * @see java.awt.Font#getFamily

  139.      * @since JDK 1.2

  140.      */

  141.     public abstract String[] getAvailableFontFamilyNames();

  142. 

  143.     /**

  144.      * Returns an array containing the localized names of all font families

  145.      * available in this <code>GraphicsEnvironment</code>.

  146.      * Typical usage would be to allow a user to select a particular family

  147.      * name and allow the application to choose related variants of the

  148.      * same family when the user specifies style attributes such

  149.      * as Bold or Italic.

  150.      * <p>

  151.      * This method provides for the application some control over which

  152.      * <code>Font</code> instance used to render text, but allows the 

  153.      * <code>Font</code> object more flexibility in choosing its own best

  154.      * match among multiple fonts in the same font family.

  155.      * If <code>l</code> is <code>null</code>, this method returns an 

  156.      * array containing all font family names available in this

  157.      * <code>GraphicsEnvironment</code>.

  158.      * @param l a {@link Locale} object that represents a

  159.      * particular geographical, political, or cultural region

  160.      * @return an array of <code>String</code> objects containing names of

  161.      * font families specific to the specified <code>Locale</code>.

  162.      * @see #getAllFonts

  163.      * @see java.awt.Font

  164.      * @see java.awt.Font#getFamily

  165.      * @since JDK 1.2

  166.      */

  167.     public abstract String[] getAvailableFontFamilyNames(Locale l);

  168. 

  169. }