0001 /*
0002 * Copyright 1996-2005 Sun Microsystems, Inc. All Rights Reserved.
0003 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
0004 *
0005 * This code is free software; you can redistribute it and/or modify it
0006 * under the terms of the GNU General Public License version 2 only, as
0007 * published by the Free Software Foundation. Sun designates this
0008 * particular file as subject to the "Classpath" exception as provided
0009 * by Sun in the LICENSE file that accompanied this code.
0010 *
0011 * This code is distributed in the hope that it will be useful, but WITHOUT
0012 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
0013 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
0014 * version 2 for more details (a copy is included in the LICENSE file that
0015 * accompanied this code).
0016 *
0017 * You should have received a copy of the GNU General Public License version
0018 * 2 along with this work; if not, write to the Free Software Foundation,
0019 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
0020 *
0021 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
0022 * CA 95054 USA or visit www.sun.com if you need additional information or
0023 * have any questions.
0024 */
0025
0026 package java.awt;
0027
0028 import java.awt.RenderingHints.Key;
0029 import java.awt.geom.AffineTransform;
0030 import java.awt.image.ImageObserver;
0031 import java.awt.image.BufferedImageOp;
0032 import java.awt.image.BufferedImage;
0033 import java.awt.image.RenderedImage;
0034 import java.awt.image.renderable.RenderableImage;
0035 import java.awt.font.GlyphVector;
0036 import java.awt.font.FontRenderContext;
0037 import java.awt.font.TextAttribute;
0038 import java.text.AttributedCharacterIterator;
0039 import java.util.Map;
0040
0041 /**
0042 * This <code>Graphics2D</code> class extends the
0043 * {@link Graphics} class to provide more sophisticated
0044 * control over geometry, coordinate transformations, color management,
0045 * and text layout. This is the fundamental class for rendering
0046 * 2-dimensional shapes, text and images on the Java(tm) platform.
0047 * <p>
0048 * <h2>Coordinate Spaces</h2>
0049 * All coordinates passed to a <code>Graphics2D</code> object are specified
0050 * in a device-independent coordinate system called User Space, which is
0051 * used by applications. The <code>Graphics2D</code> object contains
0052 * an {@link AffineTransform} object as part of its rendering state
0053 * that defines how to convert coordinates from user space to
0054 * device-dependent coordinates in Device Space.
0055 * <p>
0056 * Coordinates in device space usually refer to individual device pixels
0057 * and are aligned on the infinitely thin gaps between these pixels.
0058 * Some <code>Graphics2D</code> objects can be used to capture rendering
0059 * operations for storage into a graphics metafile for playback on a
0060 * concrete device of unknown physical resolution at a later time. Since
0061 * the resolution might not be known when the rendering operations are
0062 * captured, the <code>Graphics2D</code> <code>Transform</code> is set up
0063 * to transform user coordinates to a virtual device space that
0064 * approximates the expected resolution of the target device. Further
0065 * transformations might need to be applied at playback time if the
0066 * estimate is incorrect.
0067 * <p>
0068 * Some of the operations performed by the rendering attribute objects
0069 * occur in the device space, but all <code>Graphics2D</code> methods take
0070 * user space coordinates.
0071 * <p>
0072 * Every <code>Graphics2D</code> object is associated with a target that
0073 * defines where rendering takes place. A
0074 * {@link GraphicsConfiguration} object defines the characteristics
0075 * of the rendering target, such as pixel format and resolution.
0076 * The same rendering target is used throughout the life of a
0077 * <code>Graphics2D</code> object.
0078 * <p>
0079 * When creating a <code>Graphics2D</code> object, the
0080 * <code>GraphicsConfiguration</code>
0081 * specifies the <a name="#deftransform">default transform</a> for
0082 * the target of the <code>Graphics2D</code> (a
0083 * {@link Component} or {@link Image}). This default transform maps the
0084 * user space coordinate system to screen and printer device coordinates
0085 * such that the origin maps to the upper left hand corner of the
0086 * target region of the device with increasing X coordinates extending
0087 * to the right and increasing Y coordinates extending downward.
0088 * The scaling of the default transform is set to identity for those devices
0089 * that are close to 72 dpi, such as screen devices.
0090 * The scaling of the default transform is set to approximately 72 user
0091 * space coordinates per square inch for high resolution devices, such as
0092 * printers. For image buffers, the default transform is the
0093 * <code>Identity</code> transform.
0094 *
0095 * <h2>Rendering Process</h2>
0096 * The Rendering Process can be broken down into four phases that are
0097 * controlled by the <code>Graphics2D</code> rendering attributes.
0098 * The renderer can optimize many of these steps, either by caching the
0099 * results for future calls, by collapsing multiple virtual steps into
0100 * a single operation, or by recognizing various attributes as common
0101 * simple cases that can be eliminated by modifying other parts of the
0102 * operation.
0103 * <p>
0104 * The steps in the rendering process are:
0105 * <ol>
0106 * <li>
0107 * Determine what to render.
0108 * <li>
0109 * Constrain the rendering operation to the current <code>Clip</code>.
0110 * The <code>Clip</code> is specified by a {@link Shape} in user
0111 * space and is controlled by the program using the various clip
0112 * manipulation methods of <code>Graphics</code> and
0113 * <code>Graphics2D</code>. This <i>user clip</i>
0114 * is transformed into device space by the current
0115 * <code>Transform</code> and combined with the
0116 * <i>device clip</i>, which is defined by the visibility of windows and
0117 * device extents. The combination of the user clip and device clip
0118 * defines the <i>composite clip</i>, which determines the final clipping
0119 * region. The user clip is not modified by the rendering
0120 * system to reflect the resulting composite clip.
0121 * <li>
0122 * Determine what colors to render.
0123 * <li>
0124 * Apply the colors to the destination drawing surface using the current
0125 * {@link Composite} attribute in the <code>Graphics2D</code> context.
0126 * </ol>
0127 * <br>
0128 * The three types of rendering operations, along with details of each
0129 * of their particular rendering processes are:
0130 * <ol>
0131 * <li>
0132 * <b><a name="rendershape"><code>Shape</code> operations</a></b>
0133 * <ol>
0134 * <li>
0135 * If the operation is a <code>draw(Shape)</code> operation, then
0136 * the {@link Stroke#createStrokedShape(Shape) createStrokedShape}
0137 * method on the current {@link Stroke} attribute in the
0138 * <code>Graphics2D</code> context is used to construct a new
0139 * <code>Shape</code> object that contains the outline of the specified
0140 * <code>Shape</code>.
0141 * <li>
0142 * The <code>Shape</code> is transformed from user space to device space
0143 * using the current <code>Transform</code>
0144 * in the <code>Graphics2D</code> context.
0145 * <li>
0146 * The outline of the <code>Shape</code> is extracted using the
0147 * {@link Shape#getPathIterator(AffineTransform) getPathIterator} method of
0148 * <code>Shape</code>, which returns a
0149 * {@link java.awt.geom.PathIterator PathIterator}
0150 * object that iterates along the boundary of the <code>Shape</code>.
0151 * <li>
0152 * If the <code>Graphics2D</code> object cannot handle the curved segments
0153 * that the <code>PathIterator</code> object returns then it can call the
0154 * alternate
0155 * {@link Shape#getPathIterator(AffineTransform, double) getPathIterator}
0156 * method of <code>Shape</code>, which flattens the <code>Shape</code>.
0157 * <li>
0158 * The current {@link Paint} in the <code>Graphics2D</code> context
0159 * is queried for a {@link PaintContext}, which specifies the
0160 * colors to render in device space.
0161 * </ol>
0162 * <li>
0163 * <b><a name=rendertext>Text operations</a></b>
0164 * <ol>
0165 * <li>
0166 * The following steps are used to determine the set of glyphs required
0167 * to render the indicated <code>String</code>:
0168 * <ol>
0169 * <li>
0170 * If the argument is a <code>String</code>, then the current
0171 * <code>Font</code> in the <code>Graphics2D</code> context is asked to
0172 * convert the Unicode characters in the <code>String</code> into a set of
0173 * glyphs for presentation with whatever basic layout and shaping
0174 * algorithms the font implements.
0175 * <li>
0176 * If the argument is an
0177 * {@link AttributedCharacterIterator},
0178 * the iterator is asked to convert itself to a
0179 * {@link java.awt.font.TextLayout TextLayout}
0180 * using its embedded font attributes. The <code>TextLayout</code>
0181 * implements more sophisticated glyph layout algorithms that
0182 * perform Unicode bi-directional layout adjustments automatically
0183 * for multiple fonts of differing writing directions.
0184 * <li>
0185 * If the argument is a
0186 * {@link GlyphVector}, then the
0187 * <code>GlyphVector</code> object already contains the appropriate
0188 * font-specific glyph codes with explicit coordinates for the position of
0189 * each glyph.
0190 * </ol>
0191 * <li>
0192 * The current <code>Font</code> is queried to obtain outlines for the
0193 * indicated glyphs. These outlines are treated as shapes in user space
0194 * relative to the position of each glyph that was determined in step 1.
0195 * <li>
0196 * The character outlines are filled as indicated above
0197 * under <a href="#rendershape"><code>Shape</code> operations</a>.
0198 * <li>
0199 * The current <code>Paint</code> is queried for a
0200 * <code>PaintContext</code>, which specifies
0201 * the colors to render in device space.
0202 * </ol>
0203 * <li>
0204 * <b><a name= renderingimage><code>Image</code> Operations</a></b>
0205 * <ol>
0206 * <li>
0207 * The region of interest is defined by the bounding box of the source
0208 * <code>Image</code>.
0209 * This bounding box is specified in Image Space, which is the
0210 * <code>Image</code> object's local coordinate system.
0211 * <li>
0212 * If an <code>AffineTransform</code> is passed to
0213 * {@link #drawImage(java.awt.Image, java.awt.geom.AffineTransform, java.awt.image.ImageObserver) drawImage(Image, AffineTransform, ImageObserver)},
0214 * the <code>AffineTransform</code> is used to transform the bounding
0215 * box from image space to user space. If no <code>AffineTransform</code>
0216 * is supplied, the bounding box is treated as if it is already in user space.
0217 * <li>
0218 * The bounding box of the source <code>Image</code> is transformed from user
0219 * space into device space using the current <code>Transform</code>.
0220 * Note that the result of transforming the bounding box does not
0221 * necessarily result in a rectangular region in device space.
0222 * <li>
0223 * The <code>Image</code> object determines what colors to render,
0224 * sampled according to the source to destination
0225 * coordinate mapping specified by the current <code>Transform</code> and the
0226 * optional image transform.
0227 * </ol>
0228 * </ol>
0229 *
0230 * <h2>Default Rendering Attributes</h2>
0231 * The default values for the <code>Graphics2D</code> rendering attributes are:
0232 * <dl compact>
0233 * <dt><i><code>Paint</code></i>
0234 * <dd>The color of the <code>Component</code>.
0235 * <dt><i><code>Font</code></i>
0236 * <dd>The <code>Font</code> of the <code>Component</code>.
0237 * <dt><i><code>Stroke</code></i>
0238 * <dd>A square pen with a linewidth of 1, no dashing, miter segment joins
0239 * and square end caps.
0240 * <dt><i><code>Transform</code></i>
0241 * <dd>The
0242 * {@link GraphicsConfiguration#getDefaultTransform() getDefaultTransform}
0243 * for the <code>GraphicsConfiguration</code> of the <code>Component</code>.
0244 * <dt><i><code>Composite</code></i>
0245 * <dd>The {@link AlphaComposite#SRC_OVER} rule.
0246 * <dt><i><code>Clip</code></i>
0247 * <dd>No rendering <code>Clip</code>, the output is clipped to the
0248 * <code>Component</code>.
0249 * </dl>
0250 *
0251 * <h2>Rendering Compatibility Issues</h2>
0252 * The JDK(tm) 1.1 rendering model is based on a pixelization model
0253 * that specifies that coordinates
0254 * are infinitely thin, lying between the pixels. Drawing operations are
0255 * performed using a one-pixel wide pen that fills the
0256 * pixel below and to the right of the anchor point on the path.
0257 * The JDK 1.1 rendering model is consistent with the
0258 * capabilities of most of the existing class of platform
0259 * renderers that need to resolve integer coordinates to a
0260 * discrete pen that must fall completely on a specified number of pixels.
0261 * <p>
0262 * The Java 2D(tm) (Java(tm) 2 platform) API supports antialiasing renderers.
0263 * A pen with a width of one pixel does not need to fall
0264 * completely on pixel N as opposed to pixel N+1. The pen can fall
0265 * partially on both pixels. It is not necessary to choose a bias
0266 * direction for a wide pen since the blending that occurs along the
0267 * pen traversal edges makes the sub-pixel position of the pen
0268 * visible to the user. On the other hand, when antialiasing is
0269 * turned off by setting the
0270 * {@link RenderingHints#KEY_ANTIALIASING KEY_ANTIALIASING} hint key
0271 * to the
0272 * {@link RenderingHints#VALUE_ANTIALIAS_OFF VALUE_ANTIALIAS_OFF}
0273 * hint value, the renderer might need
0274 * to apply a bias to determine which pixel to modify when the pen
0275 * is straddling a pixel boundary, such as when it is drawn
0276 * along an integer coordinate in device space. While the capabilities
0277 * of an antialiasing renderer make it no longer necessary for the
0278 * rendering model to specify a bias for the pen, it is desirable for the
0279 * antialiasing and non-antialiasing renderers to perform similarly for
0280 * the common cases of drawing one-pixel wide horizontal and vertical
0281 * lines on the screen. To ensure that turning on antialiasing by
0282 * setting the
0283 * {@link RenderingHints#KEY_ANTIALIASING KEY_ANTIALIASING} hint
0284 * key to
0285 * {@link RenderingHints#VALUE_ANTIALIAS_ON VALUE_ANTIALIAS_ON}
0286 * does not cause such lines to suddenly become twice as wide and half
0287 * as opaque, it is desirable to have the model specify a path for such
0288 * lines so that they completely cover a particular set of pixels to help
0289 * increase their crispness.
0290 * <p>
0291 * Java 2D API maintains compatibility with JDK 1.1 rendering
0292 * behavior, such that legacy operations and existing renderer
0293 * behavior is unchanged under Java 2D API. Legacy
0294 * methods that map onto general <code>draw</code> and
0295 * <code>fill</code> methods are defined, which clearly indicates
0296 * how <code>Graphics2D</code> extends <code>Graphics</code> based
0297 * on settings of <code>Stroke</code> and <code>Transform</code>
0298 * attributes and rendering hints. The definition
0299 * performs identically under default attribute settings.
0300 * For example, the default <code>Stroke</code> is a
0301 * <code>BasicStroke</code> with a width of 1 and no dashing and the
0302 * default Transform for screen drawing is an Identity transform.
0303 * <p>
0304 * The following two rules provide predictable rendering behavior whether
0305 * aliasing or antialiasing is being used.
0306 * <ul>
0307 * <li> Device coordinates are defined to be between device pixels which
0308 * avoids any inconsistent results between aliased and antaliased
0309 * rendering. If coordinates were defined to be at a pixel's center, some
0310 * of the pixels covered by a shape, such as a rectangle, would only be
0311 * half covered.
0312 * With aliased rendering, the half covered pixels would either be
0313 * rendered inside the shape or outside the shape. With anti-aliased
0314 * rendering, the pixels on the entire edge of the shape would be half
0315 * covered. On the other hand, since coordinates are defined to be
0316 * between pixels, a shape like a rectangle would have no half covered
0317 * pixels, whether or not it is rendered using antialiasing.
0318 * <li> Lines and paths stroked using the <code>BasicStroke</code>
0319 * object may be "normalized" to provide consistent rendering of the
0320 * outlines when positioned at various points on the drawable and
0321 * whether drawn with aliased or antialiased rendering. This
0322 * normalization process is controlled by the
0323 * {@link RenderingHints#KEY_STROKE_CONTROL KEY_STROKE_CONTROL} hint.
0324 * The exact normalization algorithm is not specified, but the goals
0325 * of this normalization are to ensure that lines are rendered with
0326 * consistent visual appearance regardless of how they fall on the
0327 * pixel grid and to promote more solid horizontal and vertical
0328 * lines in antialiased mode so that they resemble their non-antialiased
0329 * counterparts more closely. A typical normalization step might
0330 * promote antialiased line endpoints to pixel centers to reduce the
0331 * amount of blending or adjust the subpixel positioning of
0332 * non-antialiased lines so that the floating point line widths
0333 * round to even or odd pixel counts with equal likelihood. This
0334 * process can move endpoints by up to half a pixel (usually towards
0335 * positive infinity along both axes) to promote these consistent
0336 * results.
0337 * </ul>
0338 * <p>
0339 * The following definitions of general legacy methods
0340 * perform identically to previously specified behavior under default
0341 * attribute settings:
0342 * <ul>
0343 * <li>
0344 * For <code>fill</code> operations, including <code>fillRect</code>,
0345 * <code>fillRoundRect</code>, <code>fillOval</code>,
0346 * <code>fillArc</code>, <code>fillPolygon</code>, and
0347 * <code>clearRect</code>, {@link #fill(Shape) fill} can now be called
0348 * with the desired <code>Shape</code>. For example, when filling a
0349 * rectangle:
0350 * <pre>
0351 * fill(new Rectangle(x, y, w, h));
0352 * </pre>
0353 * is called.
0354 * <p>
0355 * <li>
0356 * Similarly, for draw operations, including <code>drawLine</code>,
0357 * <code>drawRect</code>, <code>drawRoundRect</code>,
0358 * <code>drawOval</code>, <code>drawArc</code>, <code>drawPolyline</code>,
0359 * and <code>drawPolygon</code>, {@link #draw(Shape) draw} can now be
0360 * called with the desired <code>Shape</code>. For example, when drawing a
0361 * rectangle:
0362 * <pre>
0363 * draw(new Rectangle(x, y, w, h));
0364 * </pre>
0365 * is called.
0366 * <p>
0367 * <li>
0368 * The <code>draw3DRect</code> and <code>fill3DRect</code> methods were
0369 * implemented in terms of the <code>drawLine</code> and
0370 * <code>fillRect</code> methods in the <code>Graphics</code> class which
0371 * would predicate their behavior upon the current <code>Stroke</code>
0372 * and <code>Paint</code> objects in a <code>Graphics2D</code> context.
0373 * This class overrides those implementations with versions that use
0374 * the current <code>Color</code> exclusively, overriding the current
0375 * <code>Paint</code> and which uses <code>fillRect</code> to describe
0376 * the exact same behavior as the preexisting methods regardless of the
0377 * setting of the current <code>Stroke</code>.
0378 * </ul>
0379 * The <code>Graphics</code> class defines only the <code>setColor</code>
0380 * method to control the color to be painted. Since the Java 2D API extends
0381 * the <code>Color</code> object to implement the new <code>Paint</code>
0382 * interface, the existing
0383 * <code>setColor</code> method is now a convenience method for setting the
0384 * current <code>Paint</code> attribute to a <code>Color</code> object.
0385 * <code>setColor(c)</code> is equivalent to <code>setPaint(c)</code>.
0386 * <p>
0387 * The <code>Graphics</code> class defines two methods for controlling
0388 * how colors are applied to the destination.
0389 * <ol>
0390 * <li>
0391 * The <code>setPaintMode</code> method is implemented as a convenience
0392 * method to set the default <code>Composite</code>, equivalent to
0393 * <code>setComposite(new AlphaComposite.SrcOver)</code>.
0394 * <li>
0395 * The <code>setXORMode(Color xorcolor)</code> method is implemented
0396 * as a convenience method to set a special <code>Composite</code> object that
0397 * ignores the <code>Alpha</code> components of source colors and sets the
0398 * destination color to the value:
0399 * <pre>
0400 * dstpixel = (PixelOf(srccolor) ^ PixelOf(xorcolor) ^ dstpixel);
0401 * </pre>
0402 * </ol>
0403 *
0404 * @version 1.90, 05/05/07
0405 * @author Jim Graham
0406 * @see java.awt.RenderingHints
0407 */
0408 public abstract class Graphics2D extends Graphics {
0409
0410 /**
0411 * Constructs a new <code>Graphics2D</code> object. Since
0412 * <code>Graphics2D</code> is an abstract class, and since it must be
0413 * customized by subclasses for different output devices,
0414 * <code>Graphics2D</code> objects cannot be created directly.
0415 * Instead, <code>Graphics2D</code> objects must be obtained from another
0416 * <code>Graphics2D</code> object, created by a
0417 * <code>Component</code>, or obtained from images such as
0418 * {@link BufferedImage} objects.
0419 * @see java.awt.Component#getGraphics
0420 * @see java.awt.Graphics#create
0421 */
0422 protected Graphics2D() {
0423 }
0424
0425 /**
0426 * Draws a 3-D highlighted outline of the specified rectangle.
0427 * The edges of the rectangle are highlighted so that they
0428 * appear to be beveled and lit from the upper left corner.
0429 * <p>
0430 * The colors used for the highlighting effect are determined
0431 * based on the current color.
0432 * The resulting rectangle covers an area that is
0433 * <code>width + 1</code> pixels wide
0434 * by <code>height + 1</code> pixels tall. This method
0435 * uses the current <code>Color</code> exclusively and ignores
0436 * the current <code>Paint</code>.
0437 * @param x the x coordinate of the rectangle to be drawn.
0438 * @param y the y coordinate of the rectangle to be drawn.
0439 * @param width the width of the rectangle to be drawn.
0440 * @param height the height of the rectangle to be drawn.
0441 * @param raised a boolean that determines whether the rectangle
0442 * appears to be raised above the surface
0443 * or sunk into the surface.
0444 * @see java.awt.Graphics#fill3DRect
0445 */
0446 public void draw3DRect(int x, int y, int width, int height,
0447 boolean raised) {
0448 Paint p = getPaint();
0449 Color c = getColor();
0450 Color brighter = c.brighter();
0451 Color darker = c.darker();
0452
0453 setColor(raised ? brighter : darker);
0454 //drawLine(x, y, x, y + height);
0455 fillRect(x, y, 1, height + 1);
0456 //drawLine(x + 1, y, x + width - 1, y);
0457 fillRect(x + 1, y, width - 1, 1);
0458 setColor(raised ? darker : brighter);
0459 //drawLine(x + 1, y + height, x + width, y + height);
0460 fillRect(x + 1, y + height, width, 1);
0461 //drawLine(x + width, y, x + width, y + height - 1);
0462 fillRect(x + width, y, 1, height);
0463 setPaint(p);
0464 }
0465
0466 /**
0467 * Paints a 3-D highlighted rectangle filled with the current color.
0468 * The edges of the rectangle are highlighted so that it appears
0469 * as if the edges were beveled and lit from the upper left corner.
0470 * The colors used for the highlighting effect and for filling are
0471 * determined from the current <code>Color</code>. This method uses
0472 * the current <code>Color</code> exclusively and ignores the current
0473 * <code>Paint</code>.
0474 * @param x the x coordinate of the rectangle to be filled.
0475 * @param y the y coordinate of the rectangle to be filled.
0476 * @param width the width of the rectangle to be filled.
0477 * @param height the height of the rectangle to be filled.
0478 * @param raised a boolean value that determines whether the
0479 * rectangle appears to be raised above the surface
0480 * or etched into the surface.
0481 * @see java.awt.Graphics#draw3DRect
0482 */
0483 public void fill3DRect(int x, int y, int width, int height,
0484 boolean raised) {
0485 Paint p = getPaint();
0486 Color c = getColor();
0487 Color brighter = c.brighter();
0488 Color darker = c.darker();
0489
0490 if (!raised) {
0491 setColor(darker);
0492 } else if (p != c) {
0493 setColor(c);
0494 }
0495 fillRect(x + 1, y + 1, width - 2, height - 2);
0496 setColor(raised ? brighter : darker);
0497 //drawLine(x, y, x, y + height - 1);
0498 fillRect(x, y, 1, height);
0499 //drawLine(x + 1, y, x + width - 2, y);
0500 fillRect(x + 1, y, width - 2, 1);
0501 setColor(raised ? darker : brighter);
0502 //drawLine(x + 1, y + height - 1, x + width - 1, y + height - 1);
0503 fillRect(x + 1, y + height - 1, width - 1, 1);
0504 //drawLine(x + width - 1, y, x + width - 1, y + height - 2);
0505 fillRect(x + width - 1, y, 1, height - 1);
0506 setPaint(p);
0507 }
0508
0509 /**
0510 * Strokes the outline of a <code>Shape</code> using the settings of the
0511 * current <code>Graphics2D</code> context. The rendering attributes
0512 * applied include the <code>Clip</code>, <code>Transform</code>,
0513 * <code>Paint</code>, <code>Composite</code> and
0514 * <code>Stroke</code> attributes.
0515 * @param s the <code>Shape</code> to be rendered
0516 * @see #setStroke
0517 * @see #setPaint
0518 * @see java.awt.Graphics#setColor
0519 * @see #transform
0520 * @see #setTransform
0521 * @see #clip
0522 * @see #setClip
0523 * @see #setComposite
0524 */
0525 public abstract void draw(Shape s);
0526
0527 /**
0528 * Renders an image, applying a transform from image space into user space
0529 * before drawing.
0530 * The transformation from user space into device space is done with
0531 * the current <code>Transform</code> in the <code>Graphics2D</code>.
0532 * The specified transformation is applied to the image before the
0533 * transform attribute in the <code>Graphics2D</code> context is applied.
0534 * The rendering attributes applied include the <code>Clip</code>,
0535 * <code>Transform</code>, and <code>Composite</code> attributes.
0536 * Note that no rendering is done if the specified transform is
0537 * noninvertible.
0538 * @param img the specified image to be rendered.
0539 * This method does nothing if <code>img</code> is null.
0540 * @param xform the transformation from image space into user space
0541 * @param obs the {@link ImageObserver}
0542 * to be notified as more of the <code>Image</code>
0543 * is converted
0544 * @return <code>true</code> if the <code>Image</code> is
0545 * fully loaded and completely rendered, or if it's null;
0546 * <code>false</code> if the <code>Image</code> is still being loaded.
0547 * @see #transform
0548 * @see #setTransform
0549 * @see #setComposite
0550 * @see #clip
0551 * @see #setClip
0552 */
0553 public abstract boolean drawImage(Image img, AffineTransform xform,
0554 ImageObserver obs);
0555
0556 /**
0557 * Renders a <code>BufferedImage</code> that is
0558 * filtered with a
0559 * {@link BufferedImageOp}.
0560 * The rendering attributes applied include the <code>Clip</code>,
0561 * <code>Transform</code>
0562 * and <code>Composite</code> attributes. This is equivalent to:
0563 * <pre>
0564 * img1 = op.filter(img, null);
0565 * drawImage(img1, new AffineTransform(1f,0f,0f,1f,x,y), null);
0566 * </pre>
0567 * @param op the filter to be applied to the image before rendering
0568 * @param img the specified <code>BufferedImage</code> to be rendered.
0569 * This method does nothing if <code>img</code> is null.
0570 * @param x the x coordinate of the location in user space where
0571 * the upper left corner of the image is rendered
0572 * @param y the y coordinate of the location in user space where
0573 * the upper left corner of the image is rendered
0574 *
0575 * @see #transform
0576 * @see #setTransform
0577 * @see #setComposite
0578 * @see #clip
0579 * @see #setClip
0580 */
0581 public abstract void drawImage(BufferedImage img,
0582 BufferedImageOp op, int x, int y);
0583
0584 /**
0585 * Renders a {@link RenderedImage},
0586 * applying a transform from image
0587 * space into user space before drawing.
0588 * The transformation from user space into device space is done with
0589 * the current <code>Transform</code> in the <code>Graphics2D</code>.
0590 * The specified transformation is applied to the image before the
0591 * transform attribute in the <code>Graphics2D</code> context is applied.
0592 * The rendering attributes applied include the <code>Clip</code>,
0593 * <code>Transform</code>, and <code>Composite</code> attributes. Note
0594 * that no rendering is done if the specified transform is
0595 * noninvertible.
0596 * @param img the image to be rendered. This method does
0597 * nothing if <code>img</code> is null.
0598 * @param xform the transformation from image space into user space
0599 * @see #transform
0600 * @see #setTransform
0601 * @see #setComposite
0602 * @see #clip
0603 * @see #setClip
0604 */
0605 public abstract void drawRenderedImage(RenderedImage img,
0606 AffineTransform xform);
0607
0608 /**
0609 * Renders a
0610 * {@link RenderableImage},
0611 * applying a transform from image space into user space before drawing.
0612 * The transformation from user space into device space is done with
0613 * the current <code>Transform</code> in the <code>Graphics2D</code>.
0614 * The specified transformation is applied to the image before the
0615 * transform attribute in the <code>Graphics2D</code> context is applied.
0616 * The rendering attributes applied include the <code>Clip</code>,
0617 * <code>Transform</code>, and <code>Composite</code> attributes. Note
0618 * that no rendering is done if the specified transform is
0619 * noninvertible.
0620 *<p>
0621 * Rendering hints set on the <code>Graphics2D</code> object might
0622 * be used in rendering the <code>RenderableImage</code>.
0623 * If explicit control is required over specific hints recognized by a
0624 * specific <code>RenderableImage</code>, or if knowledge of which hints
0625 * are used is required, then a <code>RenderedImage</code> should be
0626 * obtained directly from the <code>RenderableImage</code>
0627 * and rendered using
0628 *{@link #drawRenderedImage(RenderedImage, AffineTransform) drawRenderedImage}.
0629 * @param img the image to be rendered. This method does
0630 * nothing if <code>img</code> is null.
0631 * @param xform the transformation from image space into user space
0632 * @see #transform
0633 * @see #setTransform
0634 * @see #setComposite
0635 * @see #clip
0636 * @see #setClip
0637 * @see #drawRenderedImage
0638 */
0639 public abstract void drawRenderableImage(RenderableImage img,
0640 AffineTransform xform);
0641
0642 /**
0643 * Renders the text of the specified <code>String</code>, using the
0644 * current text attribute state in the <code>Graphics2D</code> context.
0645 * The baseline of the
0646 * first character is at position (<i>x</i>, <i>y</i>) in
0647 * the User Space.
0648 * The rendering attributes applied include the <code>Clip</code>,
0649 * <code>Transform</code>, <code>Paint</code>, <code>Font</code> and
0650 * <code>Composite</code> attributes. For characters in script
0651 * systems such as Hebrew and Arabic, the glyphs can be rendered from
0652 * right to left, in which case the coordinate supplied is the
0653 * location of the leftmost character on the baseline.
0654 * @param str the string to be rendered
0655 * @param x the x coordinate of the location where the
0656 * <code>String</code> should be rendered
0657 * @param y the y coordinate of the location where the
0658 * <code>String</code> should be rendered
0659 * @throws NullPointerException if <code>str</code> is
0660 * <code>null</code>
0661 * @see java.awt.Graphics#drawBytes
0662 * @see java.awt.Graphics#drawChars
0663 * @since JDK1.0
0664 */
0665 public abstract void drawString(String str, int x, int y);
0666
0667 /**
0668 * Renders the text specified by the specified <code>String</code>,
0669 * using the current text attribute state in the <code>Graphics2D</code> context.
0670 * The baseline of the first character is at position
0671 * (<i>x</i>, <i>y</i>) in the User Space.
0672 * The rendering attributes applied include the <code>Clip</code>,
0673 * <code>Transform</code>, <code>Paint</code>, <code>Font</code> and
0674 * <code>Composite</code> attributes. For characters in script systems
0675 * such as Hebrew and Arabic, the glyphs can be rendered from right to
0676 * left, in which case the coordinate supplied is the location of the
0677 * leftmost character on the baseline.
0678 * @param str the <code>String</code> to be rendered
0679 * @param x the x coordinate of the location where the
0680 * <code>String</code> should be rendered
0681 * @param y the y coordinate of the location where the
0682 * <code>String</code> should be rendered
0683 * @throws NullPointerException if <code>str</code> is
0684 * <code>null</code>
0685 * @see #setPaint
0686 * @see java.awt.Graphics#setColor
0687 * @see java.awt.Graphics#setFont
0688 * @see #setTransform
0689 * @see #setComposite
0690 * @see #setClip
0691 */
0692 public abstract void drawString(String str, float x, float y);
0693
0694 /**
0695 * Renders the text of the specified iterator applying its attributes
0696 * in accordance with the specification of the {@link TextAttribute} class.
0697 * <p>
0698 * The baseline of the first character is at position
0699 * (<i>x</i>, <i>y</i>) in User Space.
0700 * For characters in script systems such as Hebrew and Arabic,
0701 * the glyphs can be rendered from right to left, in which case the
0702 * coordinate supplied is the location of the leftmost character
0703 * on the baseline.
0704 * @param iterator the iterator whose text is to be rendered
0705 * @param x the x coordinate where the iterator's text is to be
0706 * rendered
0707 * @param y the y coordinate where the iterator's text is to be
0708 * rendered
0709 * @throws NullPointerException if <code>iterator</code> is
0710 * <code>null</code>
0711 * @see #setPaint
0712 * @see java.awt.Graphics#setColor
0713 * @see #setTransform
0714 * @see #setComposite
0715 * @see #setClip
0716 */
0717 public abstract void drawString(
0718 AttributedCharacterIterator iterator, int x, int y);
0719
0720 /**
0721 * Renders the text of the specified iterator applying its attributes
0722 * in accordance with the specification of the {@link TextAttribute} class.
0723 * <p>
0724 * The baseline of the first character is at position
0725 * (<i>x</i>, <i>y</i>) in User Space.
0726 * For characters in script systems such as Hebrew and Arabic,
0727 * the glyphs can be rendered from right to left, in which case the
0728 * coordinate supplied is the location of the leftmost character
0729 * on the baseline.
0730 * @param iterator the iterator whose text is to be rendered
0731 * @param x the x coordinate where the iterator's text is to be
0732 * rendered
0733 * @param y the y coordinate where the iterator's text is to be
0734 * rendered
0735 * @throws NullPointerException if <code>iterator</code> is
0736 * <code>null</code>
0737 * @see #setPaint
0738 * @see java.awt.Graphics#setColor
0739 * @see #setTransform
0740 * @see #setComposite
0741 * @see #setClip
0742 */
0743 public abstract void drawString(
0744 AttributedCharacterIterator iterator, float x, float y);
0745
0746 /**
0747 * Renders the text of the specified
0748 * {@link GlyphVector} using
0749 * the <code>Graphics2D</code> context's rendering attributes.
0750 * The rendering attributes applied include the <code>Clip</code>,
0751 * <code>Transform</code>, <code>Paint</code>, and
0752 * <code>Composite</code> attributes. The <code>GlyphVector</code>
0753 * specifies individual glyphs from a {@link Font}.
0754 * The <code>GlyphVector</code> can also contain the glyph positions.
0755 * This is the fastest way to render a set of characters to the
0756 * screen.
0757 * @param g the <code>GlyphVector</code> to be rendered
0758 * @param x the x position in User Space where the glyphs should
0759 * be rendered
0760 * @param y the y position in User Space where the glyphs should
0761 * be rendered
0762 * @throws NullPointerException if <code>g</code> is <code>null</code>.
0763 *
0764 * @see java.awt.Font#createGlyphVector
0765 * @see java.awt.font.GlyphVector
0766 * @see #setPaint
0767 * @see java.awt.Graphics#setColor
0768 * @see #setTransform
0769 * @see #setComposite
0770 * @see #setClip
0771 */
0772 public abstract void drawGlyphVector(GlyphVector g, float x, float y);
0773
0774 /**
0775 * Fills the interior of a <code>Shape</code> using the settings of the
0776 * <code>Graphics2D</code> context. The rendering attributes applied
0777 * include the <code>Clip</code>, <code>Transform</code>,
0778 * <code>Paint</code>, and <code>Composite</code>.
0779 * @param s the <code>Shape</code> to be filled
0780 * @see #setPaint
0781 * @see java.awt.Graphics#setColor
0782 * @see #transform
0783 * @see #setTransform
0784 * @see #setComposite
0785 * @see #clip
0786 * @see #setClip
0787 */
0788 public abstract void fill(Shape s);
0789
0790 /**
0791 * Checks whether or not the specified <code>Shape</code> intersects
0792 * the specified {@link Rectangle}, which is in device
0793 * space. If <code>onStroke</code> is false, this method checks
0794 * whether or not the interior of the specified <code>Shape</code>
0795 * intersects the specified <code>Rectangle</code>. If
0796 * <code>onStroke</code> is <code>true</code>, this method checks
0797 * whether or not the <code>Stroke</code> of the specified
0798 * <code>Shape</code> outline intersects the specified
0799 * <code>Rectangle</code>.
0800 * The rendering attributes taken into account include the
0801 * <code>Clip</code>, <code>Transform</code>, and <code>Stroke</code>
0802 * attributes.
0803 * @param rect the area in device space to check for a hit
0804 * @param s the <code>Shape</code> to check for a hit
0805 * @param onStroke flag used to choose between testing the
0806 * stroked or the filled shape. If the flag is <code>true</code>, the
0807 * <code>Stroke</code> oultine is tested. If the flag is
0808 * <code>false</code>, the filled <code>Shape</code> is tested.
0809 * @return <code>true</code> if there is a hit; <code>false</code>
0810 * otherwise.
0811 * @see #setStroke
0812 * @see #fill
0813 * @see #draw
0814 * @see #transform
0815 * @see #setTransform
0816 * @see #clip
0817 * @see #setClip
0818 */
0819 public abstract boolean hit(Rectangle rect, Shape s,
0820 boolean onStroke);
0821
0822 /**
0823 * Returns the device configuration associated with this
0824 * <code>Graphics2D</code>.
0825 * @return the device configuration of this <code>Graphics2D</code>.
0826 */
0827 public abstract GraphicsConfiguration getDeviceConfiguration();
0828
0829 /**
0830 * Sets the <code>Composite</code> for the <code>Graphics2D</code> context.
0831 * The <code>Composite</code> is used in all drawing methods such as
0832 * <code>drawImage</code>, <code>drawString</code>, <code>draw</code>,
0833 * and <code>fill</code>. It specifies how new pixels are to be combined
0834 * with the existing pixels on the graphics device during the rendering
0835 * process.
0836 * <p>If this <code>Graphics2D</code> context is drawing to a
0837 * <code>Component</code> on the display screen and the
0838 * <code>Composite</code> is a custom object rather than an
0839 * instance of the <code>AlphaComposite</code> class, and if
0840 * there is a security manager, its <code>checkPermission</code>
0841 * method is called with an <code>AWTPermission("readDisplayPixels")</code>
0842 * permission.
0843 * @throws SecurityException
0844 * if a custom <code>Composite</code> object is being
0845 * used to render to the screen and a security manager
0846 * is set and its <code>checkPermission</code> method
0847 * does not allow the operation.
0848 * @param comp the <code>Composite</code> object to be used for rendering
0849 * @see java.awt.Graphics#setXORMode
0850 * @see java.awt.Graphics#setPaintMode
0851 * @see #getComposite
0852 * @see AlphaComposite
0853 * @see SecurityManager#checkPermission
0854 * @see java.awt.AWTPermission
0855 */
0856 public abstract void setComposite(Composite comp);
0857
0858 /**
0859 * Sets the <code>Paint</code> attribute for the
0860 * <code>Graphics2D</code> context. Calling this method
0861 * with a <code>null</code> <code>Paint</code> object does
0862 * not have any effect on the current <code>Paint</code> attribute
0863 * of this <code>Graphics2D</code>.
0864 * @param paint the <code>Paint</code> object to be used to generate
0865 * color during the rendering process, or <code>null</code>
0866 * @see java.awt.Graphics#setColor
0867 * @see #getPaint
0868 * @see GradientPaint
0869 * @see TexturePaint
0870 */
0871 public abstract void setPaint(Paint paint);
0872
0873 /**
0874 * Sets the <code>Stroke</code> for the <code>Graphics2D</code> context.
0875 * @param s the <code>Stroke</code> object to be used to stroke a
0876 * <code>Shape</code> during the rendering process
0877 * @see BasicStroke
0878 * @see #getStroke
0879 */
0880 public abstract void setStroke(Stroke s);
0881
0882 /**
0883 * Sets the value of a single preference for the rendering algorithms.
0884 * Hint categories include controls for rendering quality and overall
0885 * time/quality trade-off in the rendering process. Refer to the
0886 * <code>RenderingHints</code> class for definitions of some common
0887 * keys and values.
0888 * @param hintKey the key of the hint to be set.
0889 * @param hintValue the value indicating preferences for the specified
0890 * hint category.
0891 * @see #getRenderingHint(RenderingHints.Key)
0892 * @see RenderingHints
0893 */
0894 public abstract void setRenderingHint(Key hintKey, Object hintValue);
0895
0896 /**
0897 * Returns the value of a single preference for the rendering algorithms.
0898 * Hint categories include controls for rendering quality and overall
0899 * time/quality trade-off in the rendering process. Refer to the
0900 * <code>RenderingHints</code> class for definitions of some common
0901 * keys and values.
0902 * @param hintKey the key corresponding to the hint to get.
0903 * @return an object representing the value for the specified hint key.
0904 * Some of the keys and their associated values are defined in the
0905 * <code>RenderingHints</code> class.
0906 * @see RenderingHints
0907 * @see #setRenderingHint(RenderingHints.Key, Object)
0908 */
0909 public abstract Object getRenderingHint(Key hintKey);
0910
0911 /**
0912 * Replaces the values of all preferences for the rendering
0913 * algorithms with the specified <code>hints</code>.
0914 * The existing values for all rendering hints are discarded and
0915 * the new set of known hints and values are initialized from the
0916 * specified {@link Map} object.
0917 * Hint categories include controls for rendering quality and
0918 * overall time/quality trade-off in the rendering process.
0919 * Refer to the <code>RenderingHints</code> class for definitions of
0920 * some common keys and values.
0921 * @param hints the rendering hints to be set
0922 * @see #getRenderingHints
0923 * @see RenderingHints
0924 */
0925 public abstract void setRenderingHints(Map<?, ?> hints);
0926
0927 /**
0928 * Sets the values of an arbitrary number of preferences for the
0929 * rendering algorithms.
0930 * Only values for the rendering hints that are present in the
0931 * specified <code>Map</code> object are modified.
0932 * All other preferences not present in the specified
0933 * object are left unmodified.
0934 * Hint categories include controls for rendering quality and
0935 * overall time/quality trade-off in the rendering process.
0936 * Refer to the <code>RenderingHints</code> class for definitions of
0937 * some common keys and values.
0938 * @param hints the rendering hints to be set
0939 * @see RenderingHints
0940 */
0941 public abstract void addRenderingHints(Map<?, ?> hints);
0942
0943 /**
0944 * Gets the preferences for the rendering algorithms. Hint categories
0945 * include controls for rendering quality and overall time/quality
0946 * trade-off in the rendering process.
0947 * Returns all of the hint key/value pairs that were ever specified in
0948 * one operation. Refer to the
0949 * <code>RenderingHints</code> class for definitions of some common
0950 * keys and values.
0951 * @return a reference to an instance of <code>RenderingHints</code>
0952 * that contains the current preferences.
0953 * @see RenderingHints
0954 * @see #setRenderingHints(Map)
0955 */
0956 public abstract RenderingHints getRenderingHints();
0957
0958 /**
0959 * Translates the origin of the <code>Graphics2D</code> context to the
0960 * point (<i>x</i>, <i>y</i>) in the current coordinate system.
0961 * Modifies the <code>Graphics2D</code> context so that its new origin
0962 * corresponds to the point (<i>x</i>, <i>y</i>) in the
0963 * <code>Graphics2D</code> context's former coordinate system. All
0964 * coordinates used in subsequent rendering operations on this graphics
0965 * context are relative to this new origin.
0966 * @param x the specified x coordinate
0967 * @param y the specified y coordinate
0968 * @since JDK1.0
0969 */
0970 public abstract void translate(int x, int y);
0971
0972 /**
0973 * Concatenates the current
0974 * <code>Graphics2D</code> <code>Transform</code>
0975 * with a translation transform.
0976 * Subsequent rendering is translated by the specified
0977 * distance relative to the previous position.
0978 * This is equivalent to calling transform(T), where T is an
0979 * <code>AffineTransform</code> represented by the following matrix:
0980 * <pre>
0981 * [ 1 0 tx ]
0982 * [ 0 1 ty ]
0983 * [ 0 0 1 ]
0984 * </pre>
0985 * @param tx the distance to translate along the x-axis
0986 * @param ty the distance to translate along the y-axis
0987 */
0988 public abstract void translate(double tx, double ty);
0989
0990 /**
0991 * Concatenates the current <code>Graphics2D</code>
0992 * <code>Transform</code> with a rotation transform.
0993 * Subsequent rendering is rotated by the specified radians relative
0994 * to the previous origin.
0995 * This is equivalent to calling <code>transform(R)</code>, where R is an
0996 * <code>AffineTransform</code> represented by the following matrix:
0997 * <pre>
0998 * [ cos(theta) -sin(theta) 0 ]
0999 * [ sin(theta) cos(theta) 0 ]
1000 * [ 0 0 1 ]
1001 * </pre>
1002 * Rotating with a positive angle theta rotates points on the positive
1003 * x axis toward the positive y axis.
1004 * @param theta the angle of rotation in radians
1005 */
1006 public abstract void rotate(double theta);
1007
1008 /**
1009 * Concatenates the current <code>Graphics2D</code>
1010 * <code>Transform</code> with a translated rotation
1011 * transform. Subsequent rendering is transformed by a transform
1012 * which is constructed by translating to the specified location,
1013 * rotating by the specified radians, and translating back by the same
1014 * amount as the original translation. This is equivalent to the
1015 * following sequence of calls:
1016 * <pre>
1017 * translate(x, y);
1018 * rotate(theta);
1019 * translate(-x, -y);
1020 * </pre>
1021 * Rotating with a positive angle theta rotates points on the positive
1022 * x axis toward the positive y axis.
1023 * @param theta the angle of rotation in radians
1024 * @param x the x coordinate of the origin of the rotation
1025 * @param y the y coordinate of the origin of the rotation
1026 */
1027 public abstract void rotate(double theta, double x, double y);
1028
1029 /**
1030 * Concatenates the current <code>Graphics2D</code>
1031 * <code>Transform</code> with a scaling transformation
1032 * Subsequent rendering is resized according to the specified scaling
1033 * factors relative to the previous scaling.
1034 * This is equivalent to calling <code>transform(S)</code>, where S is an
1035 * <code>AffineTransform</code> represented by the following matrix:
1036 * <pre>
1037 * [ sx 0 0 ]
1038 * [ 0 sy 0 ]
1039 * [ 0 0 1 ]
1040 * </pre>
1041 * @param sx the amount by which X coordinates in subsequent
1042 * rendering operations are multiplied relative to previous
1043 * rendering operations.
1044 * @param sy the amount by which Y coordinates in subsequent
1045 * rendering operations are multiplied relative to previous
1046 * rendering operations.
1047 */
1048 public abstract void scale(double sx, double sy);
1049
1050 /**
1051 * Concatenates the current <code>Graphics2D</code>
1052 * <code>Transform</code> with a shearing transform.
1053 * Subsequent renderings are sheared by the specified
1054 * multiplier relative to the previous position.
1055 * This is equivalent to calling <code>transform(SH)</code>, where SH
1056 * is an <code>AffineTransform</code> represented by the following
1057 * matrix:
1058 * <pre>
1059 * [ 1 shx 0 ]
1060 * [ shy 1 0 ]
1061 * [ 0 0 1 ]
1062 * </pre>
1063 * @param shx the multiplier by which coordinates are shifted in
1064 * the positive X axis direction as a function of their Y coordinate
1065 * @param shy the multiplier by which coordinates are shifted in
1066 * the positive Y axis direction as a function of their X coordinate
1067 */
1068 public abstract void shear(double shx, double shy);
1069
1070 /**
1071 * Composes an <code>AffineTransform</code> object with the
1072 * <code>Transform</code> in this <code>Graphics2D</code> according
1073 * to the rule last-specified-first-applied. If the current
1074 * <code>Transform</code> is Cx, the result of composition
1075 * with Tx is a new <code>Transform</code> Cx'. Cx' becomes the
1076 * current <code>Transform</code> for this <code>Graphics2D</code>.
1077 * Transforming a point p by the updated <code>Transform</code> Cx' is
1078 * equivalent to first transforming p by Tx and then transforming
1079 * the result by the original <code>Transform</code> Cx. In other
1080 * words, Cx'(p) = Cx(Tx(p)). A copy of the Tx is made, if necessary,
1081 * so further modifications to Tx do not affect rendering.
1082 * @param Tx the <code>AffineTransform</code> object to be composed with
1083 * the current <code>Transform</code>
1084 * @see #setTransform
1085 * @see AffineTransform
1086 */
1087 public abstract void transform(AffineTransform Tx);
1088
1089 /**
1090 * Overwrites the Transform in the <code>Graphics2D</code> context.
1091 * WARNING: This method should <b>never</b> be used to apply a new
1092 * coordinate transform on top of an existing transform because the
1093 * <code>Graphics2D</code> might already have a transform that is
1094 * needed for other purposes, such as rendering Swing
1095 * components or applying a scaling transformation to adjust for the
1096 * resolution of a printer.
1097 * <p>To add a coordinate transform, use the
1098 * <code>transform</code>, <code>rotate</code>, <code>scale</code>,
1099 * or <code>shear</code> methods. The <code>setTransform</code>
1100 * method is intended only for restoring the original
1101 * <code>Graphics2D</code> transform after rendering, as shown in this
1102 * example:
1103 * <pre><blockquote>
1104 * // Get the current transform
1105 * AffineTransform saveAT = g2.getTransform();
1106 * // Perform transformation
1107 * g2d.transform(...);
1108 * // Render
1109 * g2d.draw(...);
1110 * // Restore original transform
1111 * g2d.setTransform(saveAT);
1112 * </blockquote></pre>
1113 *
1114 * @param Tx the <code>AffineTransform</code> that was retrieved
1115 * from the <code>getTransform</code> method
1116 * @see #transform
1117 * @see #getTransform
1118 * @see AffineTransform
1119 */
1120 public abstract void setTransform(AffineTransform Tx);
1121
1122 /**
1123 * Returns a copy of the current <code>Transform</code> in the
1124 * <code>Graphics2D</code> context.
1125 * @return the current <code>AffineTransform</code> in the
1126 * <code>Graphics2D</code> context.
1127 * @see #transform
1128 * @see #setTransform
1129 */
1130 public abstract AffineTransform getTransform();
1131
1132 /**
1133 * Returns the current <code>Paint</code> of the
1134 * <code>Graphics2D</code> context.
1135 * @return the current <code>Graphics2D</code> <code>Paint</code>,
1136 * which defines a color or pattern.
1137 * @see #setPaint
1138 * @see java.awt.Graphics#setColor
1139 */
1140 public abstract Paint getPaint();
1141
1142 /**
1143 * Returns the current <code>Composite</code> in the
1144 * <code>Graphics2D</code> context.
1145 * @return the current <code>Graphics2D</code> <code>Composite</code>,
1146 * which defines a compositing style.
1147 * @see #setComposite
1148 */
1149 public abstract Composite getComposite();
1150
1151 /**
1152 * Sets the background color for the <code>Graphics2D</code> context.
1153 * The background color is used for clearing a region.
1154 * When a <code>Graphics2D</code> is constructed for a
1155 * <code>Component</code>, the background color is
1156 * inherited from the <code>Component</code>. Setting the background color
1157 * in the <code>Graphics2D</code> context only affects the subsequent
1158 * <code>clearRect</code> calls and not the background color of the
1159 * <code>Component</code>. To change the background
1160 * of the <code>Component</code>, use appropriate methods of
1161 * the <code>Component</code>.
1162 * @param color the background color that isused in
1163 * subsequent calls to <code>clearRect</code>
1164 * @see #getBackground
1165 * @see java.awt.Graphics#clearRect
1166 */
1167 public abstract void setBackground(Color color);
1168
1169 /**
1170 * Returns the background color used for clearing a region.
1171 * @return the current <code>Graphics2D</code> <code>Color</code>,
1172 * which defines the background color.
1173 * @see #setBackground
1174 */
1175 public abstract Color getBackground();
1176
1177 /**
1178 * Returns the current <code>Stroke</code> in the
1179 * <code>Graphics2D</code> context.
1180 * @return the current <code>Graphics2D</code> <code>Stroke</code>,
1181 * which defines the line style.
1182 * @see #setStroke
1183 */
1184 public abstract Stroke getStroke();
1185
1186 /**
1187 * Intersects the current <code>Clip</code> with the interior of the
1188 * specified <code>Shape</code> and sets the <code>Clip</code> to the
1189 * resulting intersection. The specified <code>Shape</code> is
1190 * transformed with the current <code>Graphics2D</code>
1191 * <code>Transform</code> before being intersected with the current
1192 * <code>Clip</code>. This method is used to make the current
1193 * <code>Clip</code> smaller.
1194 * To make the <code>Clip</code> larger, use <code>setClip</code>.
1195 * The <i>user clip</i> modified by this method is independent of the
1196 * clipping associated with device bounds and visibility. If no clip has
1197 * previously been set, or if the clip has been cleared using
1198 * {@link Graphics#setClip(Shape) setClip} with a <code>null</code>
1199 * argument, the specified <code>Shape</code> becomes the new
1200 * user clip.
1201 * @param s the <code>Shape</code> to be intersected with the current
1202 * <code>Clip</code>. If <code>s</code> is <code>null</code>,
1203 * this method clears the current <code>Clip</code>.
1204 */
1205 public abstract void clip(Shape s);
1206
1207 /**
1208 * Get the rendering context of the <code>Font</code> within this
1209 * <code>Graphics2D</code> context.
1210 * The {@link FontRenderContext}
1211 * encapsulates application hints such as anti-aliasing and
1212 * fractional metrics, as well as target device specific information
1213 * such as dots-per-inch. This information should be provided by the
1214 * application when using objects that perform typographical
1215 * formatting, such as <code>Font</code> and
1216 * <code>TextLayout</code>. This information should also be provided
1217 * by applications that perform their own layout and need accurate
1218 * measurements of various characteristics of glyphs such as advance
1219 * and line height when various rendering hints have been applied to
1220 * the text rendering.
1221 *
1222 * @return a reference to an instance of FontRenderContext.
1223 * @see java.awt.font.FontRenderContext
1224 * @see java.awt.Font#createGlyphVector
1225 * @see java.awt.font.TextLayout
1226 * @since 1.2
1227 */
1228
1229 public abstract FontRenderContext getFontRenderContext();
1230
1231 }
|