< prev index next >

src/java.desktop/share/classes/java/awt/GraphicsEnvironment.java

Print this page

        

@@ -37,20 +37,20 @@
 import sun.java2d.SunGraphicsEnvironment;
 import sun.security.action.GetPropertyAction;
 
 /**
  *
- * The <code>GraphicsEnvironment</code> class describes the collection
+ * 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</code> might be local
- * or on a remote machine.  <code>GraphicsDevice</code> objects can be
+ * 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</code>
+ * {@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</code> can be used.
+ * {@code GraphicsDevice} can be used.
  * @see GraphicsDevice
  * @see GraphicsConfiguration
  */
 
 public abstract class GraphicsEnvironment {

@@ -72,12 +72,12 @@
      */
     protected GraphicsEnvironment() {
     }
 
     /**
-     * Returns the local <code>GraphicsEnvironment</code>.
-     * @return the local <code>GraphicsEnvironment</code>
+     * Returns the local {@code GraphicsEnvironment}.
+     * @return the local {@code GraphicsEnvironment}
      */
     public static synchronized GraphicsEnvironment getLocalGraphicsEnvironment() {
         if (localEnv == null) {
             localEnv = createGE();
         }

@@ -130,12 +130,12 @@
      * 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>
+     * @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() {

@@ -207,15 +207,15 @@
     }
 
     /**
      * 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
+     * {@code HeadlessException} 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>
+     * @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
      */

@@ -224,80 +224,80 @@
         // headless property.
         return getHeadlessProperty();
     }
 
     /**
-     * Returns an array of all of the screen <code>GraphicsDevice</code>
+     * Returns an array of all of the screen {@code GraphicsDevice}
      * objects.
-     * @return an array containing all the <code>GraphicsDevice</code>
+     * @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</code>.
-     * @return the <code>GraphicsDevice</code> that represents the
+     * 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</code> object for rendering into the
+     * Returns a {@code Graphics2D} 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
+     * @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</code>.  Typical usage
+     * 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</code> method on the chosen instance.
+     * calling the {@code deriveFont} 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
+     * 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</code> is returned in the array, and
+     * 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</code> array.  The other variations
+     * returned in the {@code Font} array.  The other variations
      * must be derived by the application.
      *
-     * @return an array of <code>Font</code> objects
+     * @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</code> localized for the default locale,
-     * as returned by <code>Locale.getDefault()</code>.
+     * {@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</code> containing font family names
+     * @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

@@ -305,63 +305,63 @@
      */
     public abstract String[] getAvailableFontFamilyNames();
 
     /**
      * Returns an array containing the names of all font families in this
-     * <code>GraphicsEnvironment</code> localized for the specified locale.
+     * {@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</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
+     * 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</i> <code>Font</code>in this
-     * <code>GraphicsEnvironment</code>.
+     * Registers a <i>created</i> {@code Font} in this
+     * {@code 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 <code>Font</code>s by name or family name,
+     * be used in constructing new {@code Font}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:
+     * return {@code false} 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
+     * <li>The font is not a <i>created</i> {@code Font}.
+     * <li>The font conflicts with a non-created {@code Font} already
+     * in this {@code 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.
      * <p>Notice that an application can supersede the registration
      * of an earlier created font with a new one.
      * </ul>
      *
      * @param  font the font to be registered
-     * @return true if the <code>font</code> is successfully
-     * registered in this <code>GraphicsEnvironment</code>.
-     * @throws NullPointerException if <code>font</code> is null
+     * @return true if the {@code font} is successfully
+     * registered in this {@code GraphicsEnvironment}.
+     * @throws NullPointerException if {@code font} is null
      * @since 1.6
      */
     public boolean registerFont(Font font) {
         if (font == null) {
             throw new NullPointerException("font cannot be null.");

@@ -442,12 +442,12 @@
      * 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>.
+     * {@code GraphicsConfiguration.getBounds()} and
+     * {@code Toolkit.getScreenInsets()}.
      * @return  the maximum bounds for centered Windows
      *
      * @exception HeadlessException if isHeadless() returns true
      * @see #getCenterPoint
      * @see GraphicsConfiguration#getBounds
< prev index next >