1 /*
   2  * Copyright (c) 1996, 2005, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 
  26 package java.awt;
  27 
  28 import java.awt.RenderingHints.Key;
  29 import java.awt.geom.AffineTransform;
  30 import java.awt.image.ImageObserver;
  31 import java.awt.image.BufferedImageOp;
  32 import java.awt.image.BufferedImage;
  33 import java.awt.image.RenderedImage;
  34 import java.awt.image.renderable.RenderableImage;
  35 import java.awt.font.GlyphVector;
  36 import java.awt.font.FontRenderContext;
  37 import java.awt.font.TextAttribute;
  38 import java.text.AttributedCharacterIterator;
  39 import java.util.Map;
  40 
  41 /**
  42  * This <code>Graphics2D</code> class extends the
  43  * {@link Graphics} class to provide more sophisticated
  44  * control over geometry, coordinate transformations, color management,
  45  * and text layout.  This is the fundamental class for rendering
  46  * 2-dimensional shapes, text and images on the  Java(tm) platform.
  47  * <p>
  48  * <h2>Coordinate Spaces</h2>
  49  * All coordinates passed to a <code>Graphics2D</code> object are specified
  50  * in a device-independent coordinate system called User Space, which is
  51  * used by applications.  The <code>Graphics2D</code> object contains
  52  * an {@link AffineTransform} object as part of its rendering state
  53  * that defines how to convert coordinates from user space to
  54  * device-dependent coordinates in Device Space.
  55  * <p>
  56  * Coordinates in device space usually refer to individual device pixels
  57  * and are aligned on the infinitely thin gaps between these pixels.
  58  * Some <code>Graphics2D</code> objects can be used to capture rendering
  59  * operations for storage into a graphics metafile for playback on a
  60  * concrete device of unknown physical resolution at a later time.  Since
  61  * the resolution might not be known when the rendering operations are
  62  * captured, the <code>Graphics2D</code> <code>Transform</code> is set up
  63  * to transform user coordinates to a virtual device space that
  64  * approximates the expected resolution of the target device. Further
  65  * transformations might need to be applied at playback time if the
  66  * estimate is incorrect.
  67  * <p>
  68  * Some of the operations performed by the rendering attribute objects
  69  * occur in the device space, but all <code>Graphics2D</code> methods take
  70  * user space coordinates.
  71  * <p>
  72  * Every <code>Graphics2D</code> object is associated with a target that
  73  * defines where rendering takes place. A
  74  * {@link GraphicsConfiguration} object defines the characteristics
  75  * of the rendering target, such as pixel format and resolution.
  76  * The same rendering target is used throughout the life of a
  77  * <code>Graphics2D</code> object.
  78  * <p>
  79  * When creating a <code>Graphics2D</code> object,  the
  80  * <code>GraphicsConfiguration</code>
  81  * specifies the <a name="deftransform">default transform</a> for
  82  * the target of the <code>Graphics2D</code> (a
  83  * {@link Component} or {@link Image}).  This default transform maps the
  84  * user space coordinate system to screen and printer device coordinates
  85  * such that the origin maps to the upper left hand corner of the
  86  * target region of the device with increasing X coordinates extending
  87  * to the right and increasing Y coordinates extending downward.
  88  * The scaling of the default transform is set to identity for those devices
  89  * that are close to 72 dpi, such as screen devices.
  90  * The scaling of the default transform is set to approximately 72 user
  91  * space coordinates per square inch for high resolution devices, such as
  92  * printers.  For image buffers, the default transform is the
  93  * <code>Identity</code> transform.
  94  *
  95  * <h2>Rendering Process</h2>
  96  * The Rendering Process can be broken down into four phases that are
  97  * controlled by the <code>Graphics2D</code> rendering attributes.
  98  * The renderer can optimize many of these steps, either by caching the
  99  * results for future calls, by collapsing multiple virtual steps into
 100  * a single operation, or by recognizing various attributes as common
 101  * simple cases that can be eliminated by modifying other parts of the
 102  * operation.
 103  * <p>
 104  * The steps in the rendering process are:
 105  * <ol>
 106  * <li>
 107  * Determine what to render.
 108  * <li>
 109  * Constrain the rendering operation to the current <code>Clip</code>.
 110  * The <code>Clip</code> is specified by a {@link Shape} in user
 111  * space and is controlled by the program using the various clip
 112  * manipulation methods of <code>Graphics</code> and
 113  * <code>Graphics2D</code>.  This <i>user clip</i>
 114  * is transformed into device space by the current
 115  * <code>Transform</code> and combined with the
 116  * <i>device clip</i>, which is defined by the visibility of windows and
 117  * device extents.  The combination of the user clip and device clip
 118  * defines the <i>composite clip</i>, which determines the final clipping
 119  * region.  The user clip is not modified by the rendering
 120  * system to reflect the resulting composite clip.
 121  * <li>
 122  * Determine what colors to render.
 123  * <li>
 124  * Apply the colors to the destination drawing surface using the current
 125  * {@link Composite} attribute in the <code>Graphics2D</code> context.
 126  * </ol>
 127  * <br>
 128  * The three types of rendering operations, along with details of each
 129  * of their particular rendering processes are:
 130  * <ol>
 131  * <li>
 132  * <b><a name="rendershape"><code>Shape</code> operations</a></b>
 133  * <ol>
 134  * <li>
 135  * If the operation is a <code>draw(Shape)</code> operation, then
 136  * the  {@link Stroke#createStrokedShape(Shape) createStrokedShape}
 137  * method on the current {@link Stroke} attribute in the
 138  * <code>Graphics2D</code> context is used to construct a new
 139  * <code>Shape</code> object that contains the outline of the specified
 140  * <code>Shape</code>.
 141  * <li>
 142  * The <code>Shape</code> is transformed from user space to device space
 143  * using the current <code>Transform</code>
 144  * in the <code>Graphics2D</code> context.
 145  * <li>
 146  * The outline of the <code>Shape</code> is extracted using the
 147  * {@link Shape#getPathIterator(AffineTransform) getPathIterator} method of
 148  * <code>Shape</code>, which returns a
 149  * {@link java.awt.geom.PathIterator PathIterator}
 150  * object that iterates along the boundary of the <code>Shape</code>.
 151  * <li>
 152  * If the <code>Graphics2D</code> object cannot handle the curved segments
 153  * that the <code>PathIterator</code> object returns then it can call the
 154  * alternate
 155  * {@link Shape#getPathIterator(AffineTransform, double) getPathIterator}
 156  * method of <code>Shape</code>, which flattens the <code>Shape</code>.
 157  * <li>
 158  * The current {@link Paint} in the <code>Graphics2D</code> context
 159  * is queried for a {@link PaintContext}, which specifies the
 160  * colors to render in device space.
 161  * </ol>
 162  * <li>
 163  * <b><a name=rendertext>Text operations</a></b>
 164  * <ol>
 165  * <li>
 166  * The following steps are used to determine the set of glyphs required
 167  * to render the indicated <code>String</code>:
 168  * <ol>
 169  * <li>
 170  * If the argument is a <code>String</code>, then the current
 171  * <code>Font</code> in the <code>Graphics2D</code> context is asked to
 172  * convert the Unicode characters in the <code>String</code> into a set of
 173  * glyphs for presentation with whatever basic layout and shaping
 174  * algorithms the font implements.
 175  * <li>
 176  * If the argument is an
 177  * {@link AttributedCharacterIterator},
 178  * the iterator is asked to convert itself to a
 179  * {@link java.awt.font.TextLayout TextLayout}
 180  * using its embedded font attributes. The <code>TextLayout</code>
 181  * implements more sophisticated glyph layout algorithms that
 182  * perform Unicode bi-directional layout adjustments automatically
 183  * for multiple fonts of differing writing directions.
 184   * <li>
 185  * If the argument is a
 186  * {@link GlyphVector}, then the
 187  * <code>GlyphVector</code> object already contains the appropriate
 188  * font-specific glyph codes with explicit coordinates for the position of
 189  * each glyph.
 190  * </ol>
 191  * <li>
 192  * The current <code>Font</code> is queried to obtain outlines for the
 193  * indicated glyphs.  These outlines are treated as shapes in user space
 194  * relative to the position of each glyph that was determined in step 1.
 195  * <li>
 196  * The character outlines are filled as indicated above
 197  * under <a href="#rendershape"><code>Shape</code> operations</a>.
 198  * <li>
 199  * The current <code>Paint</code> is queried for a
 200  * <code>PaintContext</code>, which specifies
 201  * the colors to render in device space.
 202  * </ol>
 203  * <li>
 204  * <b><a name= renderingimage><code>Image</code> Operations</a></b>
 205  * <ol>
 206  * <li>
 207  * The region of interest is defined by the bounding box of the source
 208  * <code>Image</code>.
 209  * This bounding box is specified in Image Space, which is the
 210  * <code>Image</code> object's local coordinate system.
 211  * <li>
 212  * If an <code>AffineTransform</code> is passed to
 213  * {@link #drawImage(java.awt.Image, java.awt.geom.AffineTransform, java.awt.image.ImageObserver) drawImage(Image, AffineTransform, ImageObserver)},
 214  * the <code>AffineTransform</code> is used to transform the bounding
 215  * box from image space to user space. If no <code>AffineTransform</code>
 216  * is supplied, the bounding box is treated as if it is already in user space.
 217  * <li>
 218  * The bounding box of the source <code>Image</code> is transformed from user
 219  * space into device space using the current <code>Transform</code>.
 220  * Note that the result of transforming the bounding box does not
 221  * necessarily result in a rectangular region in device space.
 222  * <li>
 223  * The <code>Image</code> object determines what colors to render,
 224  * sampled according to the source to destination
 225  * coordinate mapping specified by the current <code>Transform</code> and the
 226  * optional image transform.
 227  * </ol>
 228  * </ol>
 229  *
 230  * <h2>Default Rendering Attributes</h2>
 231  * The default values for the <code>Graphics2D</code> rendering attributes are:
 232  * <dl compact>
 233  * <dt><i><code>Paint</code></i>
 234  * <dd>The color of the <code>Component</code>.
 235  * <dt><i><code>Font</code></i>
 236  * <dd>The <code>Font</code> of the <code>Component</code>.
 237  * <dt><i><code>Stroke</code></i>
 238  * <dd>A square pen with a linewidth of 1, no dashing, miter segment joins
 239  * and square end caps.
 240  * <dt><i><code>Transform</code></i>
 241  * <dd>The
 242  * {@link GraphicsConfiguration#getDefaultTransform() getDefaultTransform}
 243  * for the <code>GraphicsConfiguration</code> of the <code>Component</code>.
 244  * <dt><i><code>Composite</code></i>
 245  * <dd>The {@link AlphaComposite#SRC_OVER} rule.
 246  * <dt><i><code>Clip</code></i>
 247  * <dd>No rendering <code>Clip</code>, the output is clipped to the
 248  * <code>Component</code>.
 249  * </dl>
 250  *
 251  * <h2>Rendering Compatibility Issues</h2>
 252  * The JDK(tm) 1.1 rendering model is based on a pixelization model
 253  * that specifies that coordinates
 254  * are infinitely thin, lying between the pixels.  Drawing operations are
 255  * performed using a one-pixel wide pen that fills the
 256  * pixel below and to the right of the anchor point on the path.
 257  * The JDK 1.1 rendering model is consistent with the
 258  * capabilities of most of the existing class of platform
 259  * renderers that need  to resolve integer coordinates to a
 260  * discrete pen that must fall completely on a specified number of pixels.
 261  * <p>
 262  * The Java 2D(tm) (Java(tm) 2 platform) API supports antialiasing renderers.
 263  * A pen with a width of one pixel does not need to fall
 264  * completely on pixel N as opposed to pixel N+1.  The pen can fall
 265  * partially on both pixels. It is not necessary to choose a bias
 266  * direction for a wide pen since the blending that occurs along the
 267  * pen traversal edges makes the sub-pixel position of the pen
 268  * visible to the user.  On the other hand, when antialiasing is
 269  * turned off by setting the
 270  * {@link RenderingHints#KEY_ANTIALIASING KEY_ANTIALIASING} hint key
 271  * to the
 272  * {@link RenderingHints#VALUE_ANTIALIAS_OFF VALUE_ANTIALIAS_OFF}
 273  * hint value, the renderer might need
 274  * to apply a bias to determine which pixel to modify when the pen
 275  * is straddling a pixel boundary, such as when it is drawn
 276  * along an integer coordinate in device space.  While the capabilities
 277  * of an antialiasing renderer make it no longer necessary for the
 278  * rendering model to specify a bias for the pen, it is desirable for the
 279  * antialiasing and non-antialiasing renderers to perform similarly for
 280  * the common cases of drawing one-pixel wide horizontal and vertical
 281  * lines on the screen.  To ensure that turning on antialiasing by
 282  * setting the
 283  * {@link RenderingHints#KEY_ANTIALIASING KEY_ANTIALIASING} hint
 284  * key to
 285  * {@link RenderingHints#VALUE_ANTIALIAS_ON VALUE_ANTIALIAS_ON}
 286  * does not cause such lines to suddenly become twice as wide and half
 287  * as opaque, it is desirable to have the model specify a path for such
 288  * lines so that they completely cover a particular set of pixels to help
 289  * increase their crispness.
 290  * <p>
 291  * Java 2D API maintains compatibility with JDK 1.1 rendering
 292  * behavior, such that legacy operations and existing renderer
 293  * behavior is unchanged under Java 2D API.  Legacy
 294  * methods that map onto general <code>draw</code> and
 295  * <code>fill</code> methods are defined, which clearly indicates
 296  * how <code>Graphics2D</code> extends <code>Graphics</code> based
 297  * on settings of <code>Stroke</code> and <code>Transform</code>
 298  * attributes and rendering hints.  The definition
 299  * performs identically under default attribute settings.
 300  * For example, the default <code>Stroke</code> is a
 301  * <code>BasicStroke</code> with a width of 1 and no dashing and the
 302  * default Transform for screen drawing is an Identity transform.
 303  * <p>
 304  * The following two rules provide predictable rendering behavior whether
 305  * aliasing or antialiasing is being used.
 306  * <ul>
 307  * <li> Device coordinates are defined to be between device pixels which
 308  * avoids any inconsistent results between aliased and antialiased
 309  * rendering.  If coordinates were defined to be at a pixel's center, some
 310  * of the pixels covered by a shape, such as a rectangle, would only be
 311  * half covered.
 312  * With aliased rendering, the half covered pixels would either be
 313  * rendered inside the shape or outside the shape.  With anti-aliased
 314  * rendering, the pixels on the entire edge of the shape would be half
 315  * covered.  On the other hand, since coordinates are defined to be
 316  * between pixels, a shape like a rectangle would have no half covered
 317  * pixels, whether or not it is rendered using antialiasing.
 318  * <li> Lines and paths stroked using the <code>BasicStroke</code>
 319  * object may be "normalized" to provide consistent rendering of the
 320  * outlines when positioned at various points on the drawable and
 321  * whether drawn with aliased or antialiased rendering.  This
 322  * normalization process is controlled by the
 323  * {@link RenderingHints#KEY_STROKE_CONTROL KEY_STROKE_CONTROL} hint.
 324  * The exact normalization algorithm is not specified, but the goals
 325  * of this normalization are to ensure that lines are rendered with
 326  * consistent visual appearance regardless of how they fall on the
 327  * pixel grid and to promote more solid horizontal and vertical
 328  * lines in antialiased mode so that they resemble their non-antialiased
 329  * counterparts more closely.  A typical normalization step might
 330  * promote antialiased line endpoints to pixel centers to reduce the
 331  * amount of blending or adjust the subpixel positioning of
 332  * non-antialiased lines so that the floating point line widths
 333  * round to even or odd pixel counts with equal likelihood.  This
 334  * process can move endpoints by up to half a pixel (usually towards
 335  * positive infinity along both axes) to promote these consistent
 336  * results.
 337  * </ul>
 338  * <p>
 339  * The following definitions of general legacy methods
 340  * perform identically to previously specified behavior under default
 341  * attribute settings:
 342  * <ul>
 343  * <li>
 344  * For <code>fill</code> operations, including <code>fillRect</code>,
 345  * <code>fillRoundRect</code>, <code>fillOval</code>,
 346  * <code>fillArc</code>, <code>fillPolygon</code>, and
 347  * <code>clearRect</code>, {@link #fill(Shape) fill} can now be called
 348  * with the desired <code>Shape</code>.  For example, when filling a
 349  * rectangle:
 350  * <pre>
 351  * fill(new Rectangle(x, y, w, h));
 352  * </pre>
 353  * is called.
 354  * <p>
 355  * <li>
 356  * Similarly, for draw operations, including <code>drawLine</code>,
 357  * <code>drawRect</code>, <code>drawRoundRect</code>,
 358  * <code>drawOval</code>, <code>drawArc</code>, <code>drawPolyline</code>,
 359  * and <code>drawPolygon</code>, {@link #draw(Shape) draw} can now be
 360  * called with the desired <code>Shape</code>.  For example, when drawing a
 361  * rectangle:
 362  * <pre>
 363  * draw(new Rectangle(x, y, w, h));
 364  * </pre>
 365  * is called.
 366  * <p>
 367  * <li>
 368  * The <code>draw3DRect</code> and <code>fill3DRect</code> methods were
 369  * implemented in terms of the <code>drawLine</code> and
 370  * <code>fillRect</code> methods in the <code>Graphics</code> class which
 371  * would predicate their behavior upon the current <code>Stroke</code>
 372  * and <code>Paint</code> objects in a <code>Graphics2D</code> context.
 373  * This class overrides those implementations with versions that use
 374  * the current <code>Color</code> exclusively, overriding the current
 375  * <code>Paint</code> and which uses <code>fillRect</code> to describe
 376  * the exact same behavior as the preexisting methods regardless of the
 377  * setting of the current <code>Stroke</code>.
 378  * </ul>
 379  * The <code>Graphics</code> class defines only the <code>setColor</code>
 380  * method to control the color to be painted.  Since the Java 2D API extends
 381  * the <code>Color</code> object to implement the new <code>Paint</code>
 382  * interface, the existing
 383  * <code>setColor</code> method is now a convenience method for setting the
 384  * current <code>Paint</code> attribute to a <code>Color</code> object.
 385  * <code>setColor(c)</code> is equivalent to <code>setPaint(c)</code>.
 386  * <p>
 387  * The <code>Graphics</code> class defines two methods for controlling
 388  * how colors are applied to the destination.
 389  * <ol>
 390  * <li>
 391  * The <code>setPaintMode</code> method is implemented as a convenience
 392  * method to set the default <code>Composite</code>, equivalent to
 393  * <code>setComposite(new AlphaComposite.SrcOver)</code>.
 394  * <li>
 395  * The <code>setXORMode(Color xorcolor)</code> method is implemented
 396  * as a convenience method to set a special <code>Composite</code> object that
 397  * ignores the <code>Alpha</code> components of source colors and sets the
 398  * destination color to the value:
 399  * <pre>
 400  * dstpixel = (PixelOf(srccolor) ^ PixelOf(xorcolor) ^ dstpixel);
 401  * </pre>
 402  * </ol>
 403  *
 404  * @author Jim Graham
 405  * @see java.awt.RenderingHints
 406  */
 407 public abstract class Graphics2D extends Graphics {
 408 
 409     /**
 410      * Constructs a new <code>Graphics2D</code> object.  Since
 411      * <code>Graphics2D</code> is an abstract class, and since it must be
 412      * customized by subclasses for different output devices,
 413      * <code>Graphics2D</code> objects cannot be created directly.
 414      * Instead, <code>Graphics2D</code> objects must be obtained from another
 415      * <code>Graphics2D</code> object, created by a
 416      * <code>Component</code>, or obtained from images such as
 417      * {@link BufferedImage} objects.
 418      * @see java.awt.Component#getGraphics
 419      * @see java.awt.Graphics#create
 420      */
 421     protected Graphics2D() {
 422     }
 423 
 424     /**
 425      * Draws a 3-D highlighted outline of the specified rectangle.
 426      * The edges of the rectangle are highlighted so that they
 427      * appear to be beveled and lit from the upper left corner.
 428      * <p>
 429      * The colors used for the highlighting effect are determined
 430      * based on the current color.
 431      * The resulting rectangle covers an area that is
 432      * <code>width&nbsp;+&nbsp;1</code> pixels wide
 433      * by <code>height&nbsp;+&nbsp;1</code> pixels tall.  This method
 434      * uses the current <code>Color</code> exclusively and ignores
 435      * the current <code>Paint</code>.
 436      * @param x the x coordinate of the rectangle to be drawn.
 437      * @param y the y coordinate of the rectangle to be drawn.
 438      * @param width the width of the rectangle to be drawn.
 439      * @param height the height of the rectangle to be drawn.
 440      * @param raised a boolean that determines whether the rectangle
 441      *                      appears to be raised above the surface
 442      *                      or sunk into the surface.
 443      * @see         java.awt.Graphics#fill3DRect
 444      */
 445     public void draw3DRect(int x, int y, int width, int height,
 446                            boolean raised) {
 447         Paint p = getPaint();
 448         Color c = getColor();
 449         Color brighter = c.brighter();
 450         Color darker = c.darker();
 451 
 452         setColor(raised ? brighter : darker);
 453         //drawLine(x, y, x, y + height);
 454         fillRect(x, y, 1, height + 1);
 455         //drawLine(x + 1, y, x + width - 1, y);
 456         fillRect(x + 1, y, width - 1, 1);
 457         setColor(raised ? darker : brighter);
 458         //drawLine(x + 1, y + height, x + width, y + height);
 459         fillRect(x + 1, y + height, width, 1);
 460         //drawLine(x + width, y, x + width, y + height - 1);
 461         fillRect(x + width, y, 1, height);
 462         setPaint(p);
 463     }
 464 
 465     /**
 466      * Paints a 3-D highlighted rectangle filled with the current color.
 467      * The edges of the rectangle are highlighted so that it appears
 468      * as if the edges were beveled and lit from the upper left corner.
 469      * The colors used for the highlighting effect and for filling are
 470      * determined from the current <code>Color</code>.  This method uses
 471      * the current <code>Color</code> exclusively and ignores the current
 472      * <code>Paint</code>.
 473      * @param x the x coordinate of the rectangle to be filled.
 474      * @param y the y coordinate of the rectangle to be filled.
 475      * @param       width the width of the rectangle to be filled.
 476      * @param       height the height of the rectangle to be filled.
 477      * @param       raised a boolean value that determines whether the
 478      *                      rectangle appears to be raised above the surface
 479      *                      or etched into the surface.
 480      * @see         java.awt.Graphics#draw3DRect
 481      */
 482     public void fill3DRect(int x, int y, int width, int height,
 483                            boolean raised) {
 484         Paint p = getPaint();
 485         Color c = getColor();
 486         Color brighter = c.brighter();
 487         Color darker = c.darker();
 488 
 489         if (!raised) {
 490             setColor(darker);
 491         } else if (p != c) {
 492             setColor(c);
 493         }
 494         fillRect(x+1, y+1, width-2, height-2);
 495         setColor(raised ? brighter : darker);
 496         //drawLine(x, y, x, y + height - 1);
 497         fillRect(x, y, 1, height);
 498         //drawLine(x + 1, y, x + width - 2, y);
 499         fillRect(x + 1, y, width - 2, 1);
 500         setColor(raised ? darker : brighter);
 501         //drawLine(x + 1, y + height - 1, x + width - 1, y + height - 1);
 502         fillRect(x + 1, y + height - 1, width - 1, 1);
 503         //drawLine(x + width - 1, y, x + width - 1, y + height - 2);
 504         fillRect(x + width - 1, y, 1, height - 1);
 505         setPaint(p);
 506     }
 507 
 508     /**
 509      * Strokes the outline of a <code>Shape</code> using the settings of the
 510      * current <code>Graphics2D</code> context.  The rendering attributes
 511      * applied include the <code>Clip</code>, <code>Transform</code>,
 512      * <code>Paint</code>, <code>Composite</code> and
 513      * <code>Stroke</code> attributes.
 514      * @param s the <code>Shape</code> to be rendered
 515      * @see #setStroke
 516      * @see #setPaint
 517      * @see java.awt.Graphics#setColor
 518      * @see #transform
 519      * @see #setTransform
 520      * @see #clip
 521      * @see #setClip
 522      * @see #setComposite
 523      */
 524     public abstract void draw(Shape s);
 525 
 526     /**
 527      * Renders an image, applying a transform from image space into user space
 528      * before drawing.
 529      * The transformation from user space into device space is done with
 530      * the current <code>Transform</code> in the <code>Graphics2D</code>.
 531      * The specified transformation is applied to the image before the
 532      * transform attribute in the <code>Graphics2D</code> context is applied.
 533      * The rendering attributes applied include the <code>Clip</code>,
 534      * <code>Transform</code>, and <code>Composite</code> attributes.
 535      * Note that no rendering is done if the specified transform is
 536      * noninvertible.
 537      * @param img the specified image to be rendered.
 538      *            This method does nothing if <code>img</code> is null.
 539      * @param xform the transformation from image space into user space
 540      * @param obs the {@link ImageObserver}
 541      * to be notified as more of the <code>Image</code>
 542      * is converted
 543      * @return <code>true</code> if the <code>Image</code> is
 544      * fully loaded and completely rendered, or if it's null;
 545      * <code>false</code> if the <code>Image</code> is still being loaded.
 546      * @see #transform
 547      * @see #setTransform
 548      * @see #setComposite
 549      * @see #clip
 550      * @see #setClip
 551      */
 552     public abstract boolean drawImage(Image img,
 553                                       AffineTransform xform,
 554                                       ImageObserver obs);
 555 
 556     /**
 557      * Renders a <code>BufferedImage</code> that is
 558      * filtered with a
 559      * {@link BufferedImageOp}.
 560      * The rendering attributes applied include the <code>Clip</code>,
 561      * <code>Transform</code>
 562      * and <code>Composite</code> attributes.  This is equivalent to:
 563      * <pre>
 564      * img1 = op.filter(img, null);
 565      * drawImage(img1, new AffineTransform(1f,0f,0f,1f,x,y), null);
 566      * </pre>
 567      * @param op the filter to be applied to the image before rendering
 568      * @param img the specified <code>BufferedImage</code> to be rendered.
 569      *            This method does nothing if <code>img</code> is null.
 570      * @param x the x coordinate of the location in user space where
 571      * the upper left corner of the image is rendered
 572      * @param y the y coordinate of the location in user space where
 573      * the upper left corner of the image is rendered
 574      *
 575      * @see #transform
 576      * @see #setTransform
 577      * @see #setComposite
 578      * @see #clip
 579      * @see #setClip
 580      */
 581     public abstract void drawImage(BufferedImage img,
 582                                    BufferedImageOp op,
 583                                    int x,
 584                                    int y);
 585 
 586     /**
 587      * Renders a {@link RenderedImage},
 588      * applying a transform from image
 589      * space into user space before drawing.
 590      * The transformation from user space into device space is done with
 591      * the current <code>Transform</code> in the <code>Graphics2D</code>.
 592      * The specified transformation is applied to the image before the
 593      * transform attribute in the <code>Graphics2D</code> context is applied.
 594      * The rendering attributes applied include the <code>Clip</code>,
 595      * <code>Transform</code>, and <code>Composite</code> attributes. Note
 596      * that no rendering is done if the specified transform is
 597      * noninvertible.
 598      * @param img the image to be rendered. This method does
 599      *            nothing if <code>img</code> is null.
 600      * @param xform the transformation from image space into user space
 601      * @see #transform
 602      * @see #setTransform
 603      * @see #setComposite
 604      * @see #clip
 605      * @see #setClip
 606      */
 607     public abstract void drawRenderedImage(RenderedImage img,
 608                                            AffineTransform xform);
 609 
 610     /**
 611      * Renders a
 612      * {@link RenderableImage},
 613      * applying a transform from image space into user space before drawing.
 614      * The transformation from user space into device space is done with
 615      * the current <code>Transform</code> in the <code>Graphics2D</code>.
 616      * The specified transformation is applied to the image before the
 617      * transform attribute in the <code>Graphics2D</code> context is applied.
 618      * The rendering attributes applied include the <code>Clip</code>,
 619      * <code>Transform</code>, and <code>Composite</code> attributes. Note
 620      * that no rendering is done if the specified transform is
 621      * noninvertible.
 622      *<p>
 623      * Rendering hints set on the <code>Graphics2D</code> object might
 624      * be used in rendering the <code>RenderableImage</code>.
 625      * If explicit control is required over specific hints recognized by a
 626      * specific <code>RenderableImage</code>, or if knowledge of which hints
 627      * are used is required, then a <code>RenderedImage</code> should be
 628      * obtained directly from the <code>RenderableImage</code>
 629      * and rendered using
 630      *{@link #drawRenderedImage(RenderedImage, AffineTransform) drawRenderedImage}.
 631      * @param img the image to be rendered. This method does
 632      *            nothing if <code>img</code> is null.
 633      * @param xform the transformation from image space into user space
 634      * @see #transform
 635      * @see #setTransform
 636      * @see #setComposite
 637      * @see #clip
 638      * @see #setClip
 639      * @see #drawRenderedImage
 640      */
 641     public abstract void drawRenderableImage(RenderableImage img,
 642                                              AffineTransform xform);
 643 
 644     /**
 645      * Renders the text of the specified <code>String</code>, using the
 646      * current text attribute state in the <code>Graphics2D</code> context.
 647      * The baseline of the
 648      * first character is at position (<i>x</i>,&nbsp;<i>y</i>) in
 649      * the User Space.
 650      * The rendering attributes applied include the <code>Clip</code>,
 651      * <code>Transform</code>, <code>Paint</code>, <code>Font</code> and
 652      * <code>Composite</code> attributes.  For characters in script
 653      * systems such as Hebrew and Arabic, the glyphs can be rendered from
 654      * right to left, in which case the coordinate supplied is the
 655      * location of the leftmost character on the baseline.
 656      * @param str the string to be rendered
 657      * @param x the x coordinate of the location where the
 658      * <code>String</code> should be rendered
 659      * @param y the y coordinate of the location where the
 660      * <code>String</code> should be rendered
 661      * @throws NullPointerException if <code>str</code> is
 662      *         <code>null</code>
 663      * @see         java.awt.Graphics#drawBytes
 664      * @see         java.awt.Graphics#drawChars
 665      * @since       JDK1.0
 666      */
 667     public abstract void drawString(String str, int x, int y);
 668 
 669     /**
 670      * Renders the text specified by the specified <code>String</code>,
 671      * using the current text attribute state in the <code>Graphics2D</code> context.
 672      * The baseline of the first character is at position
 673      * (<i>x</i>,&nbsp;<i>y</i>) in the User Space.
 674      * The rendering attributes applied include the <code>Clip</code>,
 675      * <code>Transform</code>, <code>Paint</code>, <code>Font</code> and
 676      * <code>Composite</code> attributes. For characters in script systems
 677      * such as Hebrew and Arabic, the glyphs can be rendered from right to
 678      * left, in which case the coordinate supplied is the location of the
 679      * leftmost character on the baseline.
 680      * @param str the <code>String</code> to be rendered
 681      * @param x the x coordinate of the location where the
 682      * <code>String</code> should be rendered
 683      * @param y the y coordinate of the location where the
 684      * <code>String</code> should be rendered
 685      * @throws NullPointerException if <code>str</code> is
 686      *         <code>null</code>
 687      * @see #setPaint
 688      * @see java.awt.Graphics#setColor
 689      * @see java.awt.Graphics#setFont
 690      * @see #setTransform
 691      * @see #setComposite
 692      * @see #setClip
 693      */
 694     public abstract void drawString(String str, float x, float y);
 695 
 696     /**
 697      * Renders the text of the specified iterator applying its attributes
 698      * in accordance with the specification of the {@link TextAttribute} class.
 699      * <p>
 700      * The baseline of the first character is at position
 701      * (<i>x</i>,&nbsp;<i>y</i>) in User Space.
 702      * For characters in script systems such as Hebrew and Arabic,
 703      * the glyphs can be rendered from right to left, in which case the
 704      * coordinate supplied is the location of the leftmost character
 705      * on the baseline.
 706      * @param iterator the iterator whose text is to be rendered
 707      * @param x the x coordinate where the iterator's text is to be
 708      * rendered
 709      * @param y the y coordinate where the iterator's text is to be
 710      * rendered
 711      * @throws NullPointerException if <code>iterator</code> is
 712      *         <code>null</code>
 713      * @see #setPaint
 714      * @see java.awt.Graphics#setColor
 715      * @see #setTransform
 716      * @see #setComposite
 717      * @see #setClip
 718      */
 719     public abstract void drawString(AttributedCharacterIterator iterator,
 720                                     int x, int y);
 721 
 722     /**
 723      * Renders the text of the specified iterator applying its attributes
 724      * in accordance with the specification of the {@link TextAttribute} class.
 725      * <p>
 726      * The baseline of the first character is at position
 727      * (<i>x</i>,&nbsp;<i>y</i>) in User Space.
 728      * For characters in script systems such as Hebrew and Arabic,
 729      * the glyphs can be rendered from right to left, in which case the
 730      * coordinate supplied is the location of the leftmost character
 731      * on the baseline.
 732      * @param iterator the iterator whose text is to be rendered
 733      * @param x the x coordinate where the iterator's text is to be
 734      * rendered
 735      * @param y the y coordinate where the iterator's text is to be
 736      * rendered
 737      * @throws NullPointerException if <code>iterator</code> is
 738      *         <code>null</code>
 739      * @see #setPaint
 740      * @see java.awt.Graphics#setColor
 741      * @see #setTransform
 742      * @see #setComposite
 743      * @see #setClip
 744      */
 745     public abstract void drawString(AttributedCharacterIterator iterator,
 746                                     float x, float y);
 747 
 748     /**
 749      * Renders the text of the specified
 750      * {@link GlyphVector} using
 751      * the <code>Graphics2D</code> context's rendering attributes.
 752      * The rendering attributes applied include the <code>Clip</code>,
 753      * <code>Transform</code>, <code>Paint</code>, and
 754      * <code>Composite</code> attributes.  The <code>GlyphVector</code>
 755      * specifies individual glyphs from a {@link Font}.
 756      * The <code>GlyphVector</code> can also contain the glyph positions.
 757      * This is the fastest way to render a set of characters to the
 758      * screen.
 759      * @param g the <code>GlyphVector</code> to be rendered
 760      * @param x the x position in User Space where the glyphs should
 761      * be rendered
 762      * @param y the y position in User Space where the glyphs should
 763      * be rendered
 764      * @throws NullPointerException if <code>g</code> is <code>null</code>.
 765      *
 766      * @see java.awt.Font#createGlyphVector
 767      * @see java.awt.font.GlyphVector
 768      * @see #setPaint
 769      * @see java.awt.Graphics#setColor
 770      * @see #setTransform
 771      * @see #setComposite
 772      * @see #setClip
 773      */
 774     public abstract void drawGlyphVector(GlyphVector g, float x, float y);
 775 
 776     /**
 777      * Fills the interior of a <code>Shape</code> using the settings of the
 778      * <code>Graphics2D</code> context. The rendering attributes applied
 779      * include the <code>Clip</code>, <code>Transform</code>,
 780      * <code>Paint</code>, and <code>Composite</code>.
 781      * @param s the <code>Shape</code> to be filled
 782      * @see #setPaint
 783      * @see java.awt.Graphics#setColor
 784      * @see #transform
 785      * @see #setTransform
 786      * @see #setComposite
 787      * @see #clip
 788      * @see #setClip
 789      */
 790     public abstract void fill(Shape s);
 791 
 792     /**
 793      * Checks whether or not the specified <code>Shape</code> intersects
 794      * the specified {@link Rectangle}, which is in device
 795      * space. If <code>onStroke</code> is false, this method checks
 796      * whether or not the interior of the specified <code>Shape</code>
 797      * intersects the specified <code>Rectangle</code>.  If
 798      * <code>onStroke</code> is <code>true</code>, this method checks
 799      * whether or not the <code>Stroke</code> of the specified
 800      * <code>Shape</code> outline intersects the specified
 801      * <code>Rectangle</code>.
 802      * The rendering attributes taken into account include the
 803      * <code>Clip</code>, <code>Transform</code>, and <code>Stroke</code>
 804      * attributes.
 805      * @param rect the area in device space to check for a hit
 806      * @param s the <code>Shape</code> to check for a hit
 807      * @param onStroke flag used to choose between testing the
 808      * stroked or the filled shape.  If the flag is <code>true</code>, the
 809      * <code>Stroke</code> outline is tested.  If the flag is
 810      * <code>false</code>, the filled <code>Shape</code> is tested.
 811      * @return <code>true</code> if there is a hit; <code>false</code>
 812      * otherwise.
 813      * @see #setStroke
 814      * @see #fill
 815      * @see #draw
 816      * @see #transform
 817      * @see #setTransform
 818      * @see #clip
 819      * @see #setClip
 820      */
 821     public abstract boolean hit(Rectangle rect,
 822                                 Shape s,
 823                                 boolean onStroke);
 824 
 825     /**
 826      * Returns the device configuration associated with this
 827      * <code>Graphics2D</code>.
 828      * @return the device configuration of this <code>Graphics2D</code>.
 829      */
 830     public abstract GraphicsConfiguration getDeviceConfiguration();
 831 
 832     /**
 833      * Sets the <code>Composite</code> for the <code>Graphics2D</code> context.
 834      * The <code>Composite</code> is used in all drawing methods such as
 835      * <code>drawImage</code>, <code>drawString</code>, <code>draw</code>,
 836      * and <code>fill</code>.  It specifies how new pixels are to be combined
 837      * with the existing pixels on the graphics device during the rendering
 838      * process.
 839      * <p>If this <code>Graphics2D</code> context is drawing to a
 840      * <code>Component</code> on the display screen and the
 841      * <code>Composite</code> is a custom object rather than an
 842      * instance of the <code>AlphaComposite</code> class, and if
 843      * there is a security manager, its <code>checkPermission</code>
 844      * method is called with an <code>AWTPermission("readDisplayPixels")</code>
 845      * permission.
 846      * @throws SecurityException
 847      *         if a custom <code>Composite</code> object is being
 848      *         used to render to the screen and a security manager
 849      *         is set and its <code>checkPermission</code> method
 850      *         does not allow the operation.
 851      * @param comp the <code>Composite</code> object to be used for rendering
 852      * @see java.awt.Graphics#setXORMode
 853      * @see java.awt.Graphics#setPaintMode
 854      * @see #getComposite
 855      * @see AlphaComposite
 856      * @see SecurityManager#checkPermission
 857      * @see java.awt.AWTPermission
 858      */
 859     public abstract void setComposite(Composite comp);
 860 
 861     /**
 862      * Sets the <code>Paint</code> attribute for the
 863      * <code>Graphics2D</code> context.  Calling this method
 864      * with a <code>null</code> <code>Paint</code> object does
 865      * not have any effect on the current <code>Paint</code> attribute
 866      * of this <code>Graphics2D</code>.
 867      * @param paint the <code>Paint</code> object to be used to generate
 868      * color during the rendering process, or <code>null</code>
 869      * @see java.awt.Graphics#setColor
 870      * @see #getPaint
 871      * @see GradientPaint
 872      * @see TexturePaint
 873      */
 874     public abstract void setPaint( Paint paint );
 875 
 876     /**
 877      * Sets the <code>Stroke</code> for the <code>Graphics2D</code> context.
 878      * @param s the <code>Stroke</code> object to be used to stroke a
 879      * <code>Shape</code> during the rendering process
 880      * @see BasicStroke
 881      * @see #getStroke
 882      */
 883     public abstract void setStroke(Stroke s);
 884 
 885     /**
 886      * Sets the value of a single preference for the rendering algorithms.
 887      * Hint categories include controls for rendering quality and overall
 888      * time/quality trade-off in the rendering process.  Refer to the
 889      * <code>RenderingHints</code> class for definitions of some common
 890      * keys and values.
 891      * @param hintKey the key of the hint to be set.
 892      * @param hintValue the value indicating preferences for the specified
 893      * hint category.
 894      * @see #getRenderingHint(RenderingHints.Key)
 895      * @see RenderingHints
 896      */
 897     public abstract void setRenderingHint(Key hintKey, Object hintValue);
 898 
 899     /**
 900      * Returns the value of a single preference for the rendering algorithms.
 901      * Hint categories include controls for rendering quality and overall
 902      * time/quality trade-off in the rendering process.  Refer to the
 903      * <code>RenderingHints</code> class for definitions of some common
 904      * keys and values.
 905      * @param hintKey the key corresponding to the hint to get.
 906      * @return an object representing the value for the specified hint key.
 907      * Some of the keys and their associated values are defined in the
 908      * <code>RenderingHints</code> class.
 909      * @see RenderingHints
 910      * @see #setRenderingHint(RenderingHints.Key, Object)
 911      */
 912     public abstract Object getRenderingHint(Key hintKey);
 913 
 914     /**
 915      * Replaces the values of all preferences for the rendering
 916      * algorithms with the specified <code>hints</code>.
 917      * The existing values for all rendering hints are discarded and
 918      * the new set of known hints and values are initialized from the
 919      * specified {@link Map} object.
 920      * Hint categories include controls for rendering quality and
 921      * overall time/quality trade-off in the rendering process.
 922      * Refer to the <code>RenderingHints</code> class for definitions of
 923      * some common keys and values.
 924      * @param hints the rendering hints to be set
 925      * @see #getRenderingHints
 926      * @see RenderingHints
 927      */
 928     public abstract void setRenderingHints(Map<?,?> hints);
 929 
 930     /**
 931      * Sets the values of an arbitrary number of preferences for the
 932      * rendering algorithms.
 933      * Only values for the rendering hints that are present in the
 934      * specified <code>Map</code> object are modified.
 935      * All other preferences not present in the specified
 936      * object are left unmodified.
 937      * Hint categories include controls for rendering quality and
 938      * overall time/quality trade-off in the rendering process.
 939      * Refer to the <code>RenderingHints</code> class for definitions of
 940      * some common keys and values.
 941      * @param hints the rendering hints to be set
 942      * @see RenderingHints
 943      */
 944     public abstract void addRenderingHints(Map<?,?> hints);
 945 
 946     /**
 947      * Gets the preferences for the rendering algorithms.  Hint categories
 948      * include controls for rendering quality and overall time/quality
 949      * trade-off in the rendering process.
 950      * Returns all of the hint key/value pairs that were ever specified in
 951      * one operation.  Refer to the
 952      * <code>RenderingHints</code> class for definitions of some common
 953      * keys and values.
 954      * @return a reference to an instance of <code>RenderingHints</code>
 955      * that contains the current preferences.
 956      * @see RenderingHints
 957      * @see #setRenderingHints(Map)
 958      */
 959     public abstract RenderingHints getRenderingHints();
 960 
 961     /**
 962      * Translates the origin of the <code>Graphics2D</code> context to the
 963      * point (<i>x</i>,&nbsp;<i>y</i>) in the current coordinate system.
 964      * Modifies the <code>Graphics2D</code> context so that its new origin
 965      * corresponds to the point (<i>x</i>,&nbsp;<i>y</i>) in the
 966      * <code>Graphics2D</code> context's former coordinate system.  All
 967      * coordinates used in subsequent rendering operations on this graphics
 968      * context are relative to this new origin.
 969      * @param  x the specified x coordinate
 970      * @param  y the specified y coordinate
 971      * @since   JDK1.0
 972      */
 973     public abstract void translate(int x, int y);
 974 
 975     /**
 976      * Concatenates the current
 977      * <code>Graphics2D</code> <code>Transform</code>
 978      * with a translation transform.
 979      * Subsequent rendering is translated by the specified
 980      * distance relative to the previous position.
 981      * This is equivalent to calling transform(T), where T is an
 982      * <code>AffineTransform</code> represented by the following matrix:
 983      * <pre>
 984      *          [   1    0    tx  ]
 985      *          [   0    1    ty  ]
 986      *          [   0    0    1   ]
 987      * </pre>
 988      * @param tx the distance to translate along the x-axis
 989      * @param ty the distance to translate along the y-axis
 990      */
 991     public abstract void translate(double tx, double ty);
 992 
 993     /**
 994      * Concatenates the current <code>Graphics2D</code>
 995      * <code>Transform</code> with a rotation transform.
 996      * Subsequent rendering is rotated by the specified radians relative
 997      * to the previous origin.
 998      * This is equivalent to calling <code>transform(R)</code>, where R is an
 999      * <code>AffineTransform</code> represented by the following matrix:
1000      * <pre>
1001      *          [   cos(theta)    -sin(theta)    0   ]
1002      *          [   sin(theta)     cos(theta)    0   ]
1003      *          [       0              0         1   ]
1004      * </pre>
1005      * Rotating with a positive angle theta rotates points on the positive
1006      * x axis toward the positive y axis.
1007      * @param theta the angle of rotation in radians
1008      */
1009     public abstract void rotate(double theta);
1010 
1011     /**
1012      * Concatenates the current <code>Graphics2D</code>
1013      * <code>Transform</code> with a translated rotation
1014      * transform.  Subsequent rendering is transformed by a transform
1015      * which is constructed by translating to the specified location,
1016      * rotating by the specified radians, and translating back by the same
1017      * amount as the original translation.  This is equivalent to the
1018      * following sequence of calls:
1019      * <pre>
1020      *          translate(x, y);
1021      *          rotate(theta);
1022      *          translate(-x, -y);
1023      * </pre>
1024      * Rotating with a positive angle theta rotates points on the positive
1025      * x axis toward the positive y axis.
1026      * @param theta the angle of rotation in radians
1027      * @param x the x coordinate of the origin of the rotation
1028      * @param y the y coordinate of the origin of the rotation
1029      */
1030     public abstract void rotate(double theta, double x, double y);
1031 
1032     /**
1033      * Concatenates the current <code>Graphics2D</code>
1034      * <code>Transform</code> with a scaling transformation
1035      * Subsequent rendering is resized according to the specified scaling
1036      * factors relative to the previous scaling.
1037      * This is equivalent to calling <code>transform(S)</code>, where S is an
1038      * <code>AffineTransform</code> represented by the following matrix:
1039      * <pre>
1040      *          [   sx   0    0   ]
1041      *          [   0    sy   0   ]
1042      *          [   0    0    1   ]
1043      * </pre>
1044      * @param sx the amount by which X coordinates in subsequent
1045      * rendering operations are multiplied relative to previous
1046      * rendering operations.
1047      * @param sy the amount by which Y coordinates in subsequent
1048      * rendering operations are multiplied relative to previous
1049      * rendering operations.
1050      */
1051     public abstract void scale(double sx, double sy);
1052 
1053     /**
1054      * Concatenates the current <code>Graphics2D</code>
1055      * <code>Transform</code> with a shearing transform.
1056      * Subsequent renderings are sheared by the specified
1057      * multiplier relative to the previous position.
1058      * This is equivalent to calling <code>transform(SH)</code>, where SH
1059      * is an <code>AffineTransform</code> represented by the following
1060      * matrix:
1061      * <pre>
1062      *          [   1   shx   0   ]
1063      *          [  shy   1    0   ]
1064      *          [   0    0    1   ]
1065      * </pre>
1066      * @param shx the multiplier by which coordinates are shifted in
1067      * the positive X axis direction as a function of their Y coordinate
1068      * @param shy the multiplier by which coordinates are shifted in
1069      * the positive Y axis direction as a function of their X coordinate
1070      */
1071     public abstract void shear(double shx, double shy);
1072 
1073     /**
1074      * Composes an <code>AffineTransform</code> object with the
1075      * <code>Transform</code> in this <code>Graphics2D</code> according
1076      * to the rule last-specified-first-applied.  If the current
1077      * <code>Transform</code> is Cx, the result of composition
1078      * with Tx is a new <code>Transform</code> Cx'.  Cx' becomes the
1079      * current <code>Transform</code> for this <code>Graphics2D</code>.
1080      * Transforming a point p by the updated <code>Transform</code> Cx' is
1081      * equivalent to first transforming p by Tx and then transforming
1082      * the result by the original <code>Transform</code> Cx.  In other
1083      * words, Cx'(p) = Cx(Tx(p)).  A copy of the Tx is made, if necessary,
1084      * so further modifications to Tx do not affect rendering.
1085      * @param Tx the <code>AffineTransform</code> object to be composed with
1086      * the current <code>Transform</code>
1087      * @see #setTransform
1088      * @see AffineTransform
1089      */
1090     public abstract void transform(AffineTransform Tx);
1091 
1092     /**
1093      * Overwrites the Transform in the <code>Graphics2D</code> context.
1094      * WARNING: This method should <b>never</b> be used to apply a new
1095      * coordinate transform on top of an existing transform because the
1096      * <code>Graphics2D</code> might already have a transform that is
1097      * needed for other purposes, such as rendering Swing
1098      * components or applying a scaling transformation to adjust for the
1099      * resolution of a printer.
1100      * <p>To add a coordinate transform, use the
1101      * <code>transform</code>, <code>rotate</code>, <code>scale</code>,
1102      * or <code>shear</code> methods.  The <code>setTransform</code>
1103      * method is intended only for restoring the original
1104      * <code>Graphics2D</code> transform after rendering, as shown in this
1105      * example:
1106      * <pre>
1107      * // Get the current transform
1108      * AffineTransform saveAT = g2.getTransform();
1109      * // Perform transformation
1110      * g2d.transform(...);
1111      * // Render
1112      * g2d.draw(...);
1113      * // Restore original transform
1114      * g2d.setTransform(saveAT);
1115      * </pre>
1116      *
1117      * @param Tx the <code>AffineTransform</code> that was retrieved
1118      *           from the <code>getTransform</code> method
1119      * @see #transform
1120      * @see #getTransform
1121      * @see AffineTransform
1122      */
1123     public abstract void setTransform(AffineTransform Tx);
1124 
1125     /**
1126      * Returns a copy of the current <code>Transform</code> in the
1127      * <code>Graphics2D</code> context.
1128      * @return the current <code>AffineTransform</code> in the
1129      *             <code>Graphics2D</code> context.
1130      * @see #transform
1131      * @see #setTransform
1132      */
1133     public abstract AffineTransform getTransform();
1134 
1135     /**
1136      * Returns the current <code>Paint</code> of the
1137      * <code>Graphics2D</code> context.
1138      * @return the current <code>Graphics2D</code> <code>Paint</code>,
1139      * which defines a color or pattern.
1140      * @see #setPaint
1141      * @see java.awt.Graphics#setColor
1142      */
1143     public abstract Paint getPaint();
1144 
1145     /**
1146      * Returns the current <code>Composite</code> in the
1147      * <code>Graphics2D</code> context.
1148      * @return the current <code>Graphics2D</code> <code>Composite</code>,
1149      *              which defines a compositing style.
1150      * @see #setComposite
1151      */
1152     public abstract Composite getComposite();
1153 
1154     /**
1155      * Sets the background color for the <code>Graphics2D</code> context.
1156      * The background color is used for clearing a region.
1157      * When a <code>Graphics2D</code> is constructed for a
1158      * <code>Component</code>, the background color is
1159      * inherited from the <code>Component</code>. Setting the background color
1160      * in the <code>Graphics2D</code> context only affects the subsequent
1161      * <code>clearRect</code> calls and not the background color of the
1162      * <code>Component</code>.  To change the background
1163      * of the <code>Component</code>, use appropriate methods of
1164      * the <code>Component</code>.
1165      * @param color the background color that is used in
1166      * subsequent calls to <code>clearRect</code>
1167      * @see #getBackground
1168      * @see java.awt.Graphics#clearRect
1169      */
1170     public abstract void setBackground(Color color);
1171 
1172     /**
1173      * Returns the background color used for clearing a region.
1174      * @return the current <code>Graphics2D</code> <code>Color</code>,
1175      * which defines the background color.
1176      * @see #setBackground
1177      */
1178     public abstract Color getBackground();
1179 
1180     /**
1181      * Returns the current <code>Stroke</code> in the
1182      * <code>Graphics2D</code> context.
1183      * @return the current <code>Graphics2D</code> <code>Stroke</code>,
1184      *                 which defines the line style.
1185      * @see #setStroke
1186      */
1187     public abstract Stroke getStroke();
1188 
1189     /**
1190      * Intersects the current <code>Clip</code> with the interior of the
1191      * specified <code>Shape</code> and sets the <code>Clip</code> to the
1192      * resulting intersection.  The specified <code>Shape</code> is
1193      * transformed with the current <code>Graphics2D</code>
1194      * <code>Transform</code> before being intersected with the current
1195      * <code>Clip</code>.  This method is used to make the current
1196      * <code>Clip</code> smaller.
1197      * To make the <code>Clip</code> larger, use <code>setClip</code>.
1198      * The <i>user clip</i> modified by this method is independent of the
1199      * clipping associated with device bounds and visibility.  If no clip has
1200      * previously been set, or if the clip has been cleared using
1201      * {@link Graphics#setClip(Shape) setClip} with a <code>null</code>
1202      * argument, the specified <code>Shape</code> becomes the new
1203      * user clip.
1204      * @param s the <code>Shape</code> to be intersected with the current
1205      *          <code>Clip</code>.  If <code>s</code> is <code>null</code>,
1206      *          this method clears the current <code>Clip</code>.
1207      */
1208      public abstract void clip(Shape s);
1209 
1210      /**
1211      * Get the rendering context of the <code>Font</code> within this
1212      * <code>Graphics2D</code> context.
1213      * The {@link FontRenderContext}
1214      * encapsulates application hints such as anti-aliasing and
1215      * fractional metrics, as well as target device specific information
1216      * such as dots-per-inch.  This information should be provided by the
1217      * application when using objects that perform typographical
1218      * formatting, such as <code>Font</code> and
1219      * <code>TextLayout</code>.  This information should also be provided
1220      * by applications that perform their own layout and need accurate
1221      * measurements of various characteristics of glyphs such as advance
1222      * and line height when various rendering hints have been applied to
1223      * the text rendering.
1224      *
1225      * @return a reference to an instance of FontRenderContext.
1226      * @see java.awt.font.FontRenderContext
1227      * @see java.awt.Font#createGlyphVector
1228      * @see java.awt.font.TextLayout
1229      * @since     1.2
1230      */
1231 
1232     public abstract FontRenderContext getFontRenderContext();
1233 
1234 }