< prev index next >

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

Print this page

        

*** 37,102 **** import java.awt.font.TextAttribute; import java.text.AttributedCharacterIterator; import java.util.Map; /** ! * This <code>Graphics2D</code> class extends the * {@link Graphics} class to provide more sophisticated * control over geometry, coordinate transformations, color management, * and text layout. This is the fundamental class for rendering * 2-dimensional shapes, text and images on the Java(tm) platform. * * <h2>Coordinate Spaces</h2> ! * All coordinates passed to a <code>Graphics2D</code> object are specified * in a device-independent coordinate system called User Space, which is ! * used by applications. The <code>Graphics2D</code> object contains * an {@link AffineTransform} object as part of its rendering state * that defines how to convert coordinates from user space to * device-dependent coordinates in Device Space. * <p> * Coordinates in device space usually refer to individual device pixels * and are aligned on the infinitely thin gaps between these pixels. ! * Some <code>Graphics2D</code> objects can be used to capture rendering * operations for storage into a graphics metafile for playback on a * concrete device of unknown physical resolution at a later time. Since * the resolution might not be known when the rendering operations are ! * captured, the <code>Graphics2D</code> <code>Transform</code> is set up * to transform user coordinates to a virtual device space that * approximates the expected resolution of the target device. Further * transformations might need to be applied at playback time if the * estimate is incorrect. * <p> * Some of the operations performed by the rendering attribute objects ! * occur in the device space, but all <code>Graphics2D</code> methods take * user space coordinates. * <p> ! * Every <code>Graphics2D</code> object is associated with a target that * defines where rendering takes place. A * {@link GraphicsConfiguration} object defines the characteristics * of the rendering target, such as pixel format and resolution. * The same rendering target is used throughout the life of a ! * <code>Graphics2D</code> object. * <p> ! * When creating a <code>Graphics2D</code> object, the ! * <code>GraphicsConfiguration</code> * specifies the <a name="deftransform">default transform</a> for ! * the target of the <code>Graphics2D</code> (a * {@link Component} or {@link Image}). This default transform maps the * user space coordinate system to screen and printer device coordinates * such that the origin maps to the upper left hand corner of the * target region of the device with increasing X coordinates extending * to the right and increasing Y coordinates extending downward. * The scaling of the default transform is set to identity for those devices * that are close to 72 dpi, such as screen devices. * The scaling of the default transform is set to approximately 72 user * space coordinates per square inch for high resolution devices, such as * printers. For image buffers, the default transform is the ! * <code>Identity</code> transform. * * <h2>Rendering Process</h2> * The Rendering Process can be broken down into four phases that are ! * controlled by the <code>Graphics2D</code> rendering attributes. * The renderer can optimize many of these steps, either by caching the * results for future calls, by collapsing multiple virtual steps into * a single operation, or by recognizing various attributes as common * simple cases that can be eliminated by modifying other parts of the * operation. --- 37,102 ---- import java.awt.font.TextAttribute; import java.text.AttributedCharacterIterator; import java.util.Map; /** ! * This {@code Graphics2D} class extends the * {@link Graphics} class to provide more sophisticated * control over geometry, coordinate transformations, color management, * and text layout. This is the fundamental class for rendering * 2-dimensional shapes, text and images on the Java(tm) platform. * * <h2>Coordinate Spaces</h2> ! * All coordinates passed to a {@code Graphics2D} object are specified * in a device-independent coordinate system called User Space, which is ! * used by applications. The {@code Graphics2D} object contains * an {@link AffineTransform} object as part of its rendering state * that defines how to convert coordinates from user space to * device-dependent coordinates in Device Space. * <p> * Coordinates in device space usually refer to individual device pixels * and are aligned on the infinitely thin gaps between these pixels. ! * Some {@code Graphics2D} objects can be used to capture rendering * operations for storage into a graphics metafile for playback on a * concrete device of unknown physical resolution at a later time. Since * the resolution might not be known when the rendering operations are ! * captured, the {@code Graphics2D Transform} is set up * to transform user coordinates to a virtual device space that * approximates the expected resolution of the target device. Further * transformations might need to be applied at playback time if the * estimate is incorrect. * <p> * Some of the operations performed by the rendering attribute objects ! * occur in the device space, but all {@code Graphics2D} methods take * user space coordinates. * <p> ! * Every {@code Graphics2D} object is associated with a target that * defines where rendering takes place. A * {@link GraphicsConfiguration} object defines the characteristics * of the rendering target, such as pixel format and resolution. * The same rendering target is used throughout the life of a ! * {@code Graphics2D} object. * <p> ! * When creating a {@code Graphics2D} object, the ! * {@code GraphicsConfiguration} * specifies the <a name="deftransform">default transform</a> for ! * the target of the {@code Graphics2D} (a * {@link Component} or {@link Image}). This default transform maps the * user space coordinate system to screen and printer device coordinates * such that the origin maps to the upper left hand corner of the * target region of the device with increasing X coordinates extending * to the right and increasing Y coordinates extending downward. * The scaling of the default transform is set to identity for those devices * that are close to 72 dpi, such as screen devices. * The scaling of the default transform is set to approximately 72 user * space coordinates per square inch for high resolution devices, such as * printers. For image buffers, the default transform is the ! * {@code Identity} transform. * * <h2>Rendering Process</h2> * The Rendering Process can be broken down into four phases that are ! * controlled by the {@code Graphics2D} rendering attributes. * The renderer can optimize many of these steps, either by caching the * results for future calls, by collapsing multiple virtual steps into * a single operation, or by recognizing various attributes as common * simple cases that can be eliminated by modifying other parts of the * operation.
*** 104,253 **** * The steps in the rendering process are: * <ol> * <li> * Determine what to render. * <li> ! * Constrain the rendering operation to the current <code>Clip</code>. ! * The <code>Clip</code> is specified by a {@link Shape} in user * space and is controlled by the program using the various clip ! * manipulation methods of <code>Graphics</code> and ! * <code>Graphics2D</code>. This <i>user clip</i> * is transformed into device space by the current ! * <code>Transform</code> and combined with the * <i>device clip</i>, which is defined by the visibility of windows and * device extents. The combination of the user clip and device clip * defines the <i>composite clip</i>, which determines the final clipping * region. The user clip is not modified by the rendering * system to reflect the resulting composite clip. * <li> * Determine what colors to render. * <li> * Apply the colors to the destination drawing surface using the current ! * {@link Composite} attribute in the <code>Graphics2D</code> context. * </ol> * <br> * The three types of rendering operations, along with details of each * of their particular rendering processes are: * <ol> * <li> ! * <b><a name="rendershape"><code>Shape</code> operations</a></b> * <ol> * <li> ! * If the operation is a <code>draw(Shape)</code> operation, then * the {@link Stroke#createStrokedShape(Shape) createStrokedShape} * method on the current {@link Stroke} attribute in the ! * <code>Graphics2D</code> context is used to construct a new ! * <code>Shape</code> object that contains the outline of the specified ! * <code>Shape</code>. ! * <li> ! * The <code>Shape</code> is transformed from user space to device space ! * using the current <code>Transform</code> ! * in the <code>Graphics2D</code> context. * <li> ! * The outline of the <code>Shape</code> is extracted using the * {@link Shape#getPathIterator(AffineTransform) getPathIterator} method of ! * <code>Shape</code>, which returns a * {@link java.awt.geom.PathIterator PathIterator} ! * object that iterates along the boundary of the <code>Shape</code>. * <li> ! * If the <code>Graphics2D</code> object cannot handle the curved segments ! * that the <code>PathIterator</code> object returns then it can call the * alternate * {@link Shape#getPathIterator(AffineTransform, double) getPathIterator} ! * method of <code>Shape</code>, which flattens the <code>Shape</code>. * <li> ! * The current {@link Paint} in the <code>Graphics2D</code> context * is queried for a {@link PaintContext}, which specifies the * colors to render in device space. * </ol> * <li> * <b><a name=rendertext>Text operations</a></b> * <ol> * <li> * The following steps are used to determine the set of glyphs required ! * to render the indicated <code>String</code>: * <ol> * <li> ! * If the argument is a <code>String</code>, then the current ! * <code>Font</code> in the <code>Graphics2D</code> context is asked to ! * convert the Unicode characters in the <code>String</code> into a set of * glyphs for presentation with whatever basic layout and shaping * algorithms the font implements. * <li> * If the argument is an * {@link AttributedCharacterIterator}, * the iterator is asked to convert itself to a * {@link java.awt.font.TextLayout TextLayout} ! * using its embedded font attributes. The <code>TextLayout</code> * implements more sophisticated glyph layout algorithms that * perform Unicode bi-directional layout adjustments automatically * for multiple fonts of differing writing directions. * <li> * If the argument is a * {@link GlyphVector}, then the ! * <code>GlyphVector</code> object already contains the appropriate * font-specific glyph codes with explicit coordinates for the position of * each glyph. * </ol> * <li> ! * The current <code>Font</code> is queried to obtain outlines for the * indicated glyphs. These outlines are treated as shapes in user space * relative to the position of each glyph that was determined in step 1. * <li> * The character outlines are filled as indicated above ! * under <a href="#rendershape"><code>Shape</code> operations</a>. * <li> ! * The current <code>Paint</code> is queried for a ! * <code>PaintContext</code>, which specifies * the colors to render in device space. * </ol> * <li> ! * <b><a name= renderingimage><code>Image</code> Operations</a></b> * <ol> * <li> * The region of interest is defined by the bounding box of the source ! * <code>Image</code>. * This bounding box is specified in Image Space, which is the ! * <code>Image</code> object's local coordinate system. * <li> ! * If an <code>AffineTransform</code> is passed to * {@link #drawImage(java.awt.Image, java.awt.geom.AffineTransform, java.awt.image.ImageObserver) drawImage(Image, AffineTransform, ImageObserver)}, ! * the <code>AffineTransform</code> is used to transform the bounding ! * box from image space to user space. If no <code>AffineTransform</code> * is supplied, the bounding box is treated as if it is already in user space. * <li> ! * The bounding box of the source <code>Image</code> is transformed from user ! * space into device space using the current <code>Transform</code>. * Note that the result of transforming the bounding box does not * necessarily result in a rectangular region in device space. * <li> ! * The <code>Image</code> object determines what colors to render, * sampled according to the source to destination ! * coordinate mapping specified by the current <code>Transform</code> and the * optional image transform. * </ol> * </ol> * * <h2>Default Rendering Attributes</h2> ! * The default values for the <code>Graphics2D</code> rendering attributes are: * <dl> ! * <dt><i><code>Paint</code></i> ! * <dd>The color of the <code>Component</code>. ! * <dt><i><code>Font</code></i> ! * <dd>The <code>Font</code> of the <code>Component</code>. ! * <dt><i><code>Stroke</code></i> * <dd>A square pen with a linewidth of 1, no dashing, miter segment joins * and square end caps. ! * <dt><i><code>Transform</code></i> * <dd>The * {@link GraphicsConfiguration#getDefaultTransform() getDefaultTransform} ! * for the <code>GraphicsConfiguration</code> of the <code>Component</code>. ! * <dt><i><code>Composite</code></i> * <dd>The {@link AlphaComposite#SRC_OVER} rule. ! * <dt><i><code>Clip</code></i> ! * <dd>No rendering <code>Clip</code>, the output is clipped to the ! * <code>Component</code>. * </dl> * * <h2>Rendering Compatibility Issues</h2> * The JDK(tm) 1.1 rendering model is based on a pixelization model * that specifies that coordinates --- 104,253 ---- * The steps in the rendering process are: * <ol> * <li> * Determine what to render. * <li> ! * Constrain the rendering operation to the current {@code Clip}. ! * The {@code Clip} is specified by a {@link Shape} in user * space and is controlled by the program using the various clip ! * manipulation methods of {@code Graphics} and ! * {@code Graphics2D}. This <i>user clip</i> * is transformed into device space by the current ! * {@code Transform} and combined with the * <i>device clip</i>, which is defined by the visibility of windows and * device extents. The combination of the user clip and device clip * defines the <i>composite clip</i>, which determines the final clipping * region. The user clip is not modified by the rendering * system to reflect the resulting composite clip. * <li> * Determine what colors to render. * <li> * Apply the colors to the destination drawing surface using the current ! * {@link Composite} attribute in the {@code Graphics2D} context. * </ol> * <br> * The three types of rendering operations, along with details of each * of their particular rendering processes are: * <ol> * <li> ! * <b><a name="rendershape">{@code Shape} operations</a></b> * <ol> * <li> ! * If the operation is a {@code draw(Shape)} operation, then * the {@link Stroke#createStrokedShape(Shape) createStrokedShape} * method on the current {@link Stroke} attribute in the ! * {@code Graphics2D} context is used to construct a new ! * {@code Shape} object that contains the outline of the specified ! * {@code Shape}. ! * <li> ! * The {@code Shape} is transformed from user space to device space ! * using the current {@code Transform} ! * in the {@code Graphics2D} context. * <li> ! * The outline of the {@code Shape} is extracted using the * {@link Shape#getPathIterator(AffineTransform) getPathIterator} method of ! * {@code Shape}, which returns a * {@link java.awt.geom.PathIterator PathIterator} ! * object that iterates along the boundary of the {@code Shape}. * <li> ! * If the {@code Graphics2D} object cannot handle the curved segments ! * that the {@code PathIterator} object returns then it can call the * alternate * {@link Shape#getPathIterator(AffineTransform, double) getPathIterator} ! * method of {@code Shape}, which flattens the {@code Shape}. * <li> ! * The current {@link Paint} in the {@code Graphics2D} context * is queried for a {@link PaintContext}, which specifies the * colors to render in device space. * </ol> * <li> * <b><a name=rendertext>Text operations</a></b> * <ol> * <li> * The following steps are used to determine the set of glyphs required ! * to render the indicated {@code String}: * <ol> * <li> ! * If the argument is a {@code String}, then the current ! * {@code Font} in the {@code Graphics2D} context is asked to ! * convert the Unicode characters in the {@code String} into a set of * glyphs for presentation with whatever basic layout and shaping * algorithms the font implements. * <li> * If the argument is an * {@link AttributedCharacterIterator}, * the iterator is asked to convert itself to a * {@link java.awt.font.TextLayout TextLayout} ! * using its embedded font attributes. The {@code TextLayout} * implements more sophisticated glyph layout algorithms that * perform Unicode bi-directional layout adjustments automatically * for multiple fonts of differing writing directions. * <li> * If the argument is a * {@link GlyphVector}, then the ! * {@code GlyphVector} object already contains the appropriate * font-specific glyph codes with explicit coordinates for the position of * each glyph. * </ol> * <li> ! * The current {@code Font} is queried to obtain outlines for the * indicated glyphs. These outlines are treated as shapes in user space * relative to the position of each glyph that was determined in step 1. * <li> * The character outlines are filled as indicated above ! * under <a href="#rendershape">{@code Shape} operations</a>. * <li> ! * The current {@code Paint} is queried for a ! * {@code PaintContext}, which specifies * the colors to render in device space. * </ol> * <li> ! * <b><a name= renderingimage>{@code Image} Operations</a></b> * <ol> * <li> * The region of interest is defined by the bounding box of the source ! * {@code Image}. * This bounding box is specified in Image Space, which is the ! * {@code Image} object's local coordinate system. * <li> ! * If an {@code AffineTransform} is passed to * {@link #drawImage(java.awt.Image, java.awt.geom.AffineTransform, java.awt.image.ImageObserver) drawImage(Image, AffineTransform, ImageObserver)}, ! * the {@code AffineTransform} is used to transform the bounding ! * box from image space to user space. If no {@code AffineTransform} * is supplied, the bounding box is treated as if it is already in user space. * <li> ! * The bounding box of the source {@code Image} is transformed from user ! * space into device space using the current {@code Transform}. * Note that the result of transforming the bounding box does not * necessarily result in a rectangular region in device space. * <li> ! * The {@code Image} object determines what colors to render, * sampled according to the source to destination ! * coordinate mapping specified by the current {@code Transform} and the * optional image transform. * </ol> * </ol> * * <h2>Default Rendering Attributes</h2> ! * The default values for the {@code Graphics2D} rendering attributes are: * <dl> ! * <dt><i>{@code Paint}</i> ! * <dd>The color of the {@code Component}. ! * <dt><i>{@code Font}</i> ! * <dd>The {@code Font} of the {@code Component}. ! * <dt><i>{@code Stroke}</i> * <dd>A square pen with a linewidth of 1, no dashing, miter segment joins * and square end caps. ! * <dt><i>{@code Transform}</i> * <dd>The * {@link GraphicsConfiguration#getDefaultTransform() getDefaultTransform} ! * for the {@code GraphicsConfiguration} of the {@code Component}. ! * <dt><i>{@code Composite}</i> * <dd>The {@link AlphaComposite#SRC_OVER} rule. ! * <dt><i>{@code Clip}</i> ! * <dd>No rendering {@code Clip}, the output is clipped to the ! * {@code Component}. * </dl> * * <h2>Rendering Compatibility Issues</h2> * The JDK(tm) 1.1 rendering model is based on a pixelization model * that specifies that coordinates
*** 289,306 **** * increase their crispness. * <p> * Java 2D API maintains compatibility with JDK 1.1 rendering * behavior, such that legacy operations and existing renderer * behavior is unchanged under Java 2D API. Legacy ! * methods that map onto general <code>draw</code> and ! * <code>fill</code> methods are defined, which clearly indicates ! * how <code>Graphics2D</code> extends <code>Graphics</code> based ! * on settings of <code>Stroke</code> and <code>Transform</code> * attributes and rendering hints. The definition * performs identically under default attribute settings. ! * For example, the default <code>Stroke</code> is a ! * <code>BasicStroke</code> with a width of 1 and no dashing and the * default Transform for screen drawing is an Identity transform. * <p> * The following two rules provide predictable rendering behavior whether * aliasing or antialiasing is being used. * <ul> --- 289,306 ---- * increase their crispness. * <p> * Java 2D API maintains compatibility with JDK 1.1 rendering * behavior, such that legacy operations and existing renderer * behavior is unchanged under Java 2D API. Legacy ! * methods that map onto general {@code draw} and ! * {@code fill} methods are defined, which clearly indicates ! * how {@code Graphics2D} extends {@code Graphics} based ! * on settings of {@code Stroke} and {@code Transform} * attributes and rendering hints. The definition * performs identically under default attribute settings. ! * For example, the default {@code Stroke} is a ! * {@code BasicStroke} with a width of 1 and no dashing and the * default Transform for screen drawing is an Identity transform. * <p> * The following two rules provide predictable rendering behavior whether * aliasing or antialiasing is being used. * <ul>
*** 313,323 **** * rendered inside the shape or outside the shape. With anti-aliased * rendering, the pixels on the entire edge of the shape would be half * covered. On the other hand, since coordinates are defined to be * between pixels, a shape like a rectangle would have no half covered * pixels, whether or not it is rendered using antialiasing. ! * <li> Lines and paths stroked using the <code>BasicStroke</code> * object may be "normalized" to provide consistent rendering of the * outlines when positioned at various points on the drawable and * whether drawn with aliased or antialiased rendering. This * normalization process is controlled by the * {@link RenderingHints#KEY_STROKE_CONTROL KEY_STROKE_CONTROL} hint. --- 313,323 ---- * rendered inside the shape or outside the shape. With anti-aliased * rendering, the pixels on the entire edge of the shape would be half * covered. On the other hand, since coordinates are defined to be * between pixels, a shape like a rectangle would have no half covered * pixels, whether or not it is rendered using antialiasing. ! * <li> Lines and paths stroked using the {@code BasicStroke} * object may be "normalized" to provide consistent rendering of the * outlines when positioned at various points on the drawable and * whether drawn with aliased or antialiased rendering. This * normalization process is controlled by the * {@link RenderingHints#KEY_STROKE_CONTROL KEY_STROKE_CONTROL} hint.
*** 339,402 **** * The following definitions of general legacy methods * perform identically to previously specified behavior under default * attribute settings: * <ul> * <li> ! * For <code>fill</code> operations, including <code>fillRect</code>, ! * <code>fillRoundRect</code>, <code>fillOval</code>, ! * <code>fillArc</code>, <code>fillPolygon</code>, and ! * <code>clearRect</code>, {@link #fill(Shape) fill} can now be called ! * with the desired <code>Shape</code>. For example, when filling a * rectangle: * <pre> * fill(new Rectangle(x, y, w, h)); * </pre> * is called. * * <li> ! * Similarly, for draw operations, including <code>drawLine</code>, ! * <code>drawRect</code>, <code>drawRoundRect</code>, ! * <code>drawOval</code>, <code>drawArc</code>, <code>drawPolyline</code>, ! * and <code>drawPolygon</code>, {@link #draw(Shape) draw} can now be ! * called with the desired <code>Shape</code>. For example, when drawing a * rectangle: * <pre> * draw(new Rectangle(x, y, w, h)); * </pre> * is called. * * <li> ! * The <code>draw3DRect</code> and <code>fill3DRect</code> methods were ! * implemented in terms of the <code>drawLine</code> and ! * <code>fillRect</code> methods in the <code>Graphics</code> class which ! * would predicate their behavior upon the current <code>Stroke</code> ! * and <code>Paint</code> objects in a <code>Graphics2D</code> context. * This class overrides those implementations with versions that use ! * the current <code>Color</code> exclusively, overriding the current ! * <code>Paint</code> and which uses <code>fillRect</code> to describe * the exact same behavior as the preexisting methods regardless of the ! * setting of the current <code>Stroke</code>. * </ul> ! * The <code>Graphics</code> class defines only the <code>setColor</code> * method to control the color to be painted. Since the Java 2D API extends ! * the <code>Color</code> object to implement the new <code>Paint</code> * interface, the existing ! * <code>setColor</code> method is now a convenience method for setting the ! * current <code>Paint</code> attribute to a <code>Color</code> object. ! * <code>setColor(c)</code> is equivalent to <code>setPaint(c)</code>. * <p> ! * The <code>Graphics</code> class defines two methods for controlling * how colors are applied to the destination. * <ol> * <li> ! * The <code>setPaintMode</code> method is implemented as a convenience ! * method to set the default <code>Composite</code>, equivalent to ! * <code>setComposite(new AlphaComposite.SrcOver)</code>. ! * <li> ! * The <code>setXORMode(Color xorcolor)</code> method is implemented ! * as a convenience method to set a special <code>Composite</code> object that ! * ignores the <code>Alpha</code> components of source colors and sets the * destination color to the value: * <pre> * dstpixel = (PixelOf(srccolor) ^ PixelOf(xorcolor) ^ dstpixel); * </pre> * </ol> --- 339,402 ---- * The following definitions of general legacy methods * perform identically to previously specified behavior under default * attribute settings: * <ul> * <li> ! * For {@code fill} operations, including {@code fillRect}, ! * {@code fillRoundRect}, {@code fillOval}, ! * {@code fillArc}, {@code fillPolygon}, and ! * {@code clearRect}, {@link #fill(Shape) fill} can now be called ! * with the desired {@code Shape}. For example, when filling a * rectangle: * <pre> * fill(new Rectangle(x, y, w, h)); * </pre> * is called. * * <li> ! * Similarly, for draw operations, including {@code drawLine}, ! * {@code drawRect}, {@code drawRoundRect}, ! * {@code drawOval}, {@code drawArc}, {@code drawPolyline}, ! * and {@code drawPolygon}, {@link #draw(Shape) draw} can now be ! * called with the desired {@code Shape}. For example, when drawing a * rectangle: * <pre> * draw(new Rectangle(x, y, w, h)); * </pre> * is called. * * <li> ! * The {@code draw3DRect} and {@code fill3DRect} methods were ! * implemented in terms of the {@code drawLine} and ! * {@code fillRect} methods in the {@code Graphics} class which ! * would predicate their behavior upon the current {@code Stroke} ! * and {@code Paint} objects in a {@code Graphics2D} context. * This class overrides those implementations with versions that use ! * the current {@code Color} exclusively, overriding the current ! * {@code Paint} and which uses {@code fillRect} to describe * the exact same behavior as the preexisting methods regardless of the ! * setting of the current {@code Stroke}. * </ul> ! * The {@code Graphics} class defines only the {@code setColor} * method to control the color to be painted. Since the Java 2D API extends ! * the {@code Color} object to implement the new {@code Paint} * interface, the existing ! * {@code setColor} method is now a convenience method for setting the ! * current {@code Paint} attribute to a {@code Color} object. ! * {@code setColor(c)} is equivalent to {@code setPaint(c)}. * <p> ! * The {@code Graphics} class defines two methods for controlling * how colors are applied to the destination. * <ol> * <li> ! * The {@code setPaintMode} method is implemented as a convenience ! * method to set the default {@code Composite}, equivalent to ! * {@code setComposite(new AlphaComposite.SrcOver)}. ! * <li> ! * The {@code setXORMode(Color xorcolor)} method is implemented ! * as a convenience method to set a special {@code Composite} object that ! * ignores the {@code Alpha} components of source colors and sets the * destination color to the value: * <pre> * dstpixel = (PixelOf(srccolor) ^ PixelOf(xorcolor) ^ dstpixel); * </pre> * </ol>
*** 405,421 **** * @see java.awt.RenderingHints */ public abstract class Graphics2D extends Graphics { /** ! * Constructs a new <code>Graphics2D</code> object. Since ! * <code>Graphics2D</code> is an abstract class, and since it must be * customized by subclasses for different output devices, ! * <code>Graphics2D</code> objects cannot be created directly. ! * Instead, <code>Graphics2D</code> objects must be obtained from another ! * <code>Graphics2D</code> object, created by a ! * <code>Component</code>, or obtained from images such as * {@link BufferedImage} objects. * @see java.awt.Component#getGraphics * @see java.awt.Graphics#create */ protected Graphics2D() { --- 405,421 ---- * @see java.awt.RenderingHints */ public abstract class Graphics2D extends Graphics { /** ! * Constructs a new {@code Graphics2D} object. Since ! * {@code Graphics2D} is an abstract class, and since it must be * customized by subclasses for different output devices, ! * {@code Graphics2D} objects cannot be created directly. ! * Instead, {@code Graphics2D} objects must be obtained from another ! * {@code Graphics2D} object, created by a ! * {@code Component}, or obtained from images such as * {@link BufferedImage} objects. * @see java.awt.Component#getGraphics * @see java.awt.Graphics#create */ protected Graphics2D() {
*** 429,440 **** * The colors used for the highlighting effect are determined * based on the current color. * The resulting rectangle covers an area that is * <code>width&nbsp;+&nbsp;1</code> pixels wide * by <code>height&nbsp;+&nbsp;1</code> pixels tall. This method ! * uses the current <code>Color</code> exclusively and ignores ! * the current <code>Paint</code>. * @param x the x coordinate of the rectangle to be drawn. * @param y the y coordinate of the rectangle to be drawn. * @param width the width of the rectangle to be drawn. * @param height the height of the rectangle to be drawn. * @param raised a boolean that determines whether the rectangle --- 429,440 ---- * The colors used for the highlighting effect are determined * based on the current color. * The resulting rectangle covers an area that is * <code>width&nbsp;+&nbsp;1</code> pixels wide * by <code>height&nbsp;+&nbsp;1</code> pixels tall. This method ! * uses the current {@code Color} exclusively and ignores ! * the current {@code Paint}. * @param x the x coordinate of the rectangle to be drawn. * @param y the y coordinate of the rectangle to be drawn. * @param width the width of the rectangle to be drawn. * @param height the height of the rectangle to be drawn. * @param raised a boolean that determines whether the rectangle
*** 465,477 **** /** * Paints a 3-D highlighted rectangle filled with the current color. * The edges of the rectangle are highlighted so that it appears * as if the edges were beveled and lit from the upper left corner. * The colors used for the highlighting effect and for filling are ! * determined from the current <code>Color</code>. This method uses ! * the current <code>Color</code> exclusively and ignores the current ! * <code>Paint</code>. * @param x the x coordinate of the rectangle to be filled. * @param y the y coordinate of the rectangle to be filled. * @param width the width of the rectangle to be filled. * @param height the height of the rectangle to be filled. * @param raised a boolean value that determines whether the --- 465,477 ---- /** * Paints a 3-D highlighted rectangle filled with the current color. * The edges of the rectangle are highlighted so that it appears * as if the edges were beveled and lit from the upper left corner. * The colors used for the highlighting effect and for filling are ! * determined from the current {@code Color}. This method uses ! * the current {@code Color} exclusively and ignores the current ! * {@code Paint}. * @param x the x coordinate of the rectangle to be filled. * @param y the y coordinate of the rectangle to be filled. * @param width the width of the rectangle to be filled. * @param height the height of the rectangle to be filled. * @param raised a boolean value that determines whether the
*** 504,519 **** fillRect(x + width - 1, y, 1, height - 1); setPaint(p); } /** ! * Strokes the outline of a <code>Shape</code> using the settings of the ! * current <code>Graphics2D</code> context. The rendering attributes ! * applied include the <code>Clip</code>, <code>Transform</code>, ! * <code>Paint</code>, <code>Composite</code> and ! * <code>Stroke</code> attributes. ! * @param s the <code>Shape</code> to be rendered * @see #setStroke * @see #setPaint * @see java.awt.Graphics#setColor * @see #transform * @see #setTransform --- 504,519 ---- fillRect(x + width - 1, y, 1, height - 1); setPaint(p); } /** ! * Strokes the outline of a {@code Shape} using the settings of the ! * current {@code Graphics2D} context. The rendering attributes ! * applied include the {@code Clip}, {@code Transform}, ! * {@code Paint}, {@code Composite} and ! * {@code Stroke} attributes. ! * @param s the {@code Shape} to be rendered * @see #setStroke * @see #setPaint * @see java.awt.Graphics#setColor * @see #transform * @see #setTransform
*** 525,550 **** /** * Renders an image, applying a transform from image space into user space * before drawing. * The transformation from user space into device space is done with ! * the current <code>Transform</code> in the <code>Graphics2D</code>. * The specified transformation is applied to the image before the ! * transform attribute in the <code>Graphics2D</code> context is applied. ! * The rendering attributes applied include the <code>Clip</code>, ! * <code>Transform</code>, and <code>Composite</code> attributes. * Note that no rendering is done if the specified transform is * noninvertible. * @param img the specified image to be rendered. ! * This method does nothing if <code>img</code> is null. * @param xform the transformation from image space into user space * @param obs the {@link ImageObserver} ! * to be notified as more of the <code>Image</code> * is converted ! * @return <code>true</code> if the <code>Image</code> is * fully loaded and completely rendered, or if it's null; ! * <code>false</code> if the <code>Image</code> is still being loaded. * @see #transform * @see #setTransform * @see #setComposite * @see #clip * @see #setClip --- 525,550 ---- /** * Renders an image, applying a transform from image space into user space * before drawing. * The transformation from user space into device space is done with ! * the current {@code Transform} in the {@code Graphics2D}. * The specified transformation is applied to the image before the ! * transform attribute in the {@code Graphics2D} context is applied. ! * The rendering attributes applied include the {@code Clip}, ! * {@code Transform}, and {@code Composite} attributes. * Note that no rendering is done if the specified transform is * noninvertible. * @param img the specified image to be rendered. ! * This method does nothing if {@code img} is null. * @param xform the transformation from image space into user space * @param obs the {@link ImageObserver} ! * to be notified as more of the {@code Image} * is converted ! * @return {@code true} if the {@code Image} is * fully loaded and completely rendered, or if it's null; ! * {@code false} if the {@code Image} is still being loaded. * @see #transform * @see #setTransform * @see #setComposite * @see #clip * @see #setClip
*** 552,574 **** public abstract boolean drawImage(Image img, AffineTransform xform, ImageObserver obs); /** ! * Renders a <code>BufferedImage</code> that is * filtered with a * {@link BufferedImageOp}. ! * The rendering attributes applied include the <code>Clip</code>, ! * <code>Transform</code> ! * and <code>Composite</code> attributes. This is equivalent to: * <pre> * img1 = op.filter(img, null); * drawImage(img1, new AffineTransform(1f,0f,0f,1f,x,y), null); * </pre> * @param op the filter to be applied to the image before rendering ! * @param img the specified <code>BufferedImage</code> to be rendered. ! * This method does nothing if <code>img</code> is null. * @param x the x coordinate of the location in user space where * the upper left corner of the image is rendered * @param y the y coordinate of the location in user space where * the upper left corner of the image is rendered * --- 552,574 ---- public abstract boolean drawImage(Image img, AffineTransform xform, ImageObserver obs); /** ! * Renders a {@code BufferedImage} that is * filtered with a * {@link BufferedImageOp}. ! * The rendering attributes applied include the {@code Clip}, ! * {@code Transform} ! * and {@code Composite} attributes. This is equivalent to: * <pre> * img1 = op.filter(img, null); * drawImage(img1, new AffineTransform(1f,0f,0f,1f,x,y), null); * </pre> * @param op the filter to be applied to the image before rendering ! * @param img the specified {@code BufferedImage} to be rendered. ! * This method does nothing if {@code img} is null. * @param x the x coordinate of the location in user space where * the upper left corner of the image is rendered * @param y the y coordinate of the location in user space where * the upper left corner of the image is rendered *
*** 586,604 **** /** * Renders a {@link RenderedImage}, * applying a transform from image * space into user space before drawing. * The transformation from user space into device space is done with ! * the current <code>Transform</code> in the <code>Graphics2D</code>. * The specified transformation is applied to the image before the ! * transform attribute in the <code>Graphics2D</code> context is applied. ! * The rendering attributes applied include the <code>Clip</code>, ! * <code>Transform</code>, and <code>Composite</code> attributes. Note * that no rendering is done if the specified transform is * noninvertible. * @param img the image to be rendered. This method does ! * nothing if <code>img</code> is null. * @param xform the transformation from image space into user space * @see #transform * @see #setTransform * @see #setComposite * @see #clip --- 586,604 ---- /** * Renders a {@link RenderedImage}, * applying a transform from image * space into user space before drawing. * The transformation from user space into device space is done with ! * the current {@code Transform} in the {@code Graphics2D}. * The specified transformation is applied to the image before the ! * transform attribute in the {@code Graphics2D} context is applied. ! * The rendering attributes applied include the {@code Clip}, ! * {@code Transform}, and {@code Composite} attributes. Note * that no rendering is done if the specified transform is * noninvertible. * @param img the image to be rendered. This method does ! * nothing if {@code img} is null. * @param xform the transformation from image space into user space * @see #transform * @see #setTransform * @see #setComposite * @see #clip
*** 610,637 **** /** * Renders a * {@link RenderableImage}, * applying a transform from image space into user space before drawing. * The transformation from user space into device space is done with ! * the current <code>Transform</code> in the <code>Graphics2D</code>. * The specified transformation is applied to the image before the ! * transform attribute in the <code>Graphics2D</code> context is applied. ! * The rendering attributes applied include the <code>Clip</code>, ! * <code>Transform</code>, and <code>Composite</code> attributes. Note * that no rendering is done if the specified transform is * noninvertible. *<p> ! * Rendering hints set on the <code>Graphics2D</code> object might ! * be used in rendering the <code>RenderableImage</code>. * If explicit control is required over specific hints recognized by a ! * specific <code>RenderableImage</code>, or if knowledge of which hints ! * are used is required, then a <code>RenderedImage</code> should be ! * obtained directly from the <code>RenderableImage</code> * and rendered using *{@link #drawRenderedImage(RenderedImage, AffineTransform) drawRenderedImage}. * @param img the image to be rendered. This method does ! * nothing if <code>img</code> is null. * @param xform the transformation from image space into user space * @see #transform * @see #setTransform * @see #setComposite * @see #clip --- 610,637 ---- /** * Renders a * {@link RenderableImage}, * applying a transform from image space into user space before drawing. * The transformation from user space into device space is done with ! * the current {@code Transform} in the {@code Graphics2D}. * The specified transformation is applied to the image before the ! * transform attribute in the {@code Graphics2D} context is applied. ! * The rendering attributes applied include the {@code Clip}, ! * {@code Transform}, and {@code Composite} attributes. Note * that no rendering is done if the specified transform is * noninvertible. *<p> ! * Rendering hints set on the {@code Graphics2D} object might ! * be used in rendering the {@code RenderableImage}. * If explicit control is required over specific hints recognized by a ! * specific {@code RenderableImage}, or if knowledge of which hints ! * are used is required, then a {@code RenderedImage} should be ! * obtained directly from the {@code RenderableImage} * and rendered using *{@link #drawRenderedImage(RenderedImage, AffineTransform) drawRenderedImage}. * @param img the image to be rendered. This method does ! * nothing if {@code img} is null. * @param xform the transformation from image space into user space * @see #transform * @see #setTransform * @see #setComposite * @see #clip
*** 640,691 **** */ public abstract void drawRenderableImage(RenderableImage img, AffineTransform xform); /** ! * Renders the text of the specified <code>String</code>, using the ! * current text attribute state in the <code>Graphics2D</code> context. * The baseline of the * first character is at position (<i>x</i>,&nbsp;<i>y</i>) in * the User Space. ! * The rendering attributes applied include the <code>Clip</code>, ! * <code>Transform</code>, <code>Paint</code>, <code>Font</code> and ! * <code>Composite</code> attributes. For characters in script * systems such as Hebrew and Arabic, the glyphs can be rendered from * right to left, in which case the coordinate supplied is the * location of the leftmost character on the baseline. * @param str the string to be rendered * @param x the x coordinate of the location where the ! * <code>String</code> should be rendered * @param y the y coordinate of the location where the ! * <code>String</code> should be rendered ! * @throws NullPointerException if <code>str</code> is ! * <code>null</code> * @see java.awt.Graphics#drawBytes * @see java.awt.Graphics#drawChars * @since 1.0 */ public abstract void drawString(String str, int x, int y); /** ! * Renders the text specified by the specified <code>String</code>, ! * using the current text attribute state in the <code>Graphics2D</code> context. * The baseline of the first character is at position * (<i>x</i>,&nbsp;<i>y</i>) in the User Space. ! * The rendering attributes applied include the <code>Clip</code>, ! * <code>Transform</code>, <code>Paint</code>, <code>Font</code> and ! * <code>Composite</code> attributes. For characters in script systems * such as Hebrew and Arabic, the glyphs can be rendered from right to * left, in which case the coordinate supplied is the location of the * leftmost character on the baseline. ! * @param str the <code>String</code> to be rendered * @param x the x coordinate of the location where the ! * <code>String</code> should be rendered * @param y the y coordinate of the location where the ! * <code>String</code> should be rendered ! * @throws NullPointerException if <code>str</code> is ! * <code>null</code> * @see #setPaint * @see java.awt.Graphics#setColor * @see java.awt.Graphics#setFont * @see #setTransform * @see #setComposite --- 640,691 ---- */ public abstract void drawRenderableImage(RenderableImage img, AffineTransform xform); /** ! * Renders the text of the specified {@code String}, using the ! * current text attribute state in the {@code Graphics2D} context. * The baseline of the * first character is at position (<i>x</i>,&nbsp;<i>y</i>) in * the User Space. ! * The rendering attributes applied include the {@code Clip}, ! * {@code Transform}, {@code Paint}, {@code Font} and ! * {@code Composite} attributes. For characters in script * systems such as Hebrew and Arabic, the glyphs can be rendered from * right to left, in which case the coordinate supplied is the * location of the leftmost character on the baseline. * @param str the string to be rendered * @param x the x coordinate of the location where the ! * {@code String} should be rendered * @param y the y coordinate of the location where the ! * {@code String} should be rendered ! * @throws NullPointerException if {@code str} is ! * {@code null} * @see java.awt.Graphics#drawBytes * @see java.awt.Graphics#drawChars * @since 1.0 */ public abstract void drawString(String str, int x, int y); /** ! * Renders the text specified by the specified {@code String}, ! * using the current text attribute state in the {@code Graphics2D} context. * The baseline of the first character is at position * (<i>x</i>,&nbsp;<i>y</i>) in the User Space. ! * The rendering attributes applied include the {@code Clip}, ! * {@code Transform}, {@code Paint}, {@code Font} and ! * {@code Composite} attributes. For characters in script systems * such as Hebrew and Arabic, the glyphs can be rendered from right to * left, in which case the coordinate supplied is the location of the * leftmost character on the baseline. ! * @param str the {@code String} to be rendered * @param x the x coordinate of the location where the ! * {@code String} should be rendered * @param y the y coordinate of the location where the ! * {@code String} should be rendered ! * @throws NullPointerException if {@code str} is ! * {@code null} * @see #setPaint * @see java.awt.Graphics#setColor * @see java.awt.Graphics#setFont * @see #setTransform * @see #setComposite
*** 706,717 **** * @param iterator the iterator whose text is to be rendered * @param x the x coordinate where the iterator's text is to be * rendered * @param y the y coordinate where the iterator's text is to be * rendered ! * @throws NullPointerException if <code>iterator</code> is ! * <code>null</code> * @see #setPaint * @see java.awt.Graphics#setColor * @see #setTransform * @see #setComposite * @see #setClip --- 706,717 ---- * @param iterator the iterator whose text is to be rendered * @param x the x coordinate where the iterator's text is to be * rendered * @param y the y coordinate where the iterator's text is to be * rendered ! * @throws NullPointerException if {@code iterator} is ! * {@code null} * @see #setPaint * @see java.awt.Graphics#setColor * @see #setTransform * @see #setComposite * @see #setClip
*** 732,743 **** * @param iterator the iterator whose text is to be rendered * @param x the x coordinate where the iterator's text is to be * rendered * @param y the y coordinate where the iterator's text is to be * rendered ! * @throws NullPointerException if <code>iterator</code> is ! * <code>null</code> * @see #setPaint * @see java.awt.Graphics#setColor * @see #setTransform * @see #setComposite * @see #setClip --- 732,743 ---- * @param iterator the iterator whose text is to be rendered * @param x the x coordinate where the iterator's text is to be * rendered * @param y the y coordinate where the iterator's text is to be * rendered ! * @throws NullPointerException if {@code iterator} is ! * {@code null} * @see #setPaint * @see java.awt.Graphics#setColor * @see #setTransform * @see #setComposite * @see #setClip
*** 746,769 **** float x, float y); /** * Renders the text of the specified * {@link GlyphVector} using ! * the <code>Graphics2D</code> context's rendering attributes. ! * The rendering attributes applied include the <code>Clip</code>, ! * <code>Transform</code>, <code>Paint</code>, and ! * <code>Composite</code> attributes. The <code>GlyphVector</code> * specifies individual glyphs from a {@link Font}. ! * The <code>GlyphVector</code> can also contain the glyph positions. * This is the fastest way to render a set of characters to the * screen. ! * @param g the <code>GlyphVector</code> to be rendered * @param x the x position in User Space where the glyphs should * be rendered * @param y the y position in User Space where the glyphs should * be rendered ! * @throws NullPointerException if <code>g</code> is <code>null</code>. * * @see java.awt.Font#createGlyphVector * @see java.awt.font.GlyphVector * @see #setPaint * @see java.awt.Graphics#setColor --- 746,769 ---- float x, float y); /** * Renders the text of the specified * {@link GlyphVector} using ! * the {@code Graphics2D} context's rendering attributes. ! * The rendering attributes applied include the {@code Clip}, ! * {@code Transform}, {@code Paint}, and ! * {@code Composite} attributes. The {@code GlyphVector} * specifies individual glyphs from a {@link Font}. ! * The {@code GlyphVector} can also contain the glyph positions. * This is the fastest way to render a set of characters to the * screen. ! * @param g the {@code GlyphVector} to be rendered * @param x the x position in User Space where the glyphs should * be rendered * @param y the y position in User Space where the glyphs should * be rendered ! * @throws NullPointerException if {@code g} is {@code null}. * * @see java.awt.Font#createGlyphVector * @see java.awt.font.GlyphVector * @see #setPaint * @see java.awt.Graphics#setColor
*** 772,786 **** * @see #setClip */ public abstract void drawGlyphVector(GlyphVector g, float x, float y); /** ! * Fills the interior of a <code>Shape</code> using the settings of the ! * <code>Graphics2D</code> context. The rendering attributes applied ! * include the <code>Clip</code>, <code>Transform</code>, ! * <code>Paint</code>, and <code>Composite</code>. ! * @param s the <code>Shape</code> to be filled * @see #setPaint * @see java.awt.Graphics#setColor * @see #transform * @see #setTransform * @see #setComposite --- 772,786 ---- * @see #setClip */ public abstract void drawGlyphVector(GlyphVector g, float x, float y); /** ! * Fills the interior of a {@code Shape} using the settings of the ! * {@code Graphics2D} context. The rendering attributes applied ! * include the {@code Clip}, {@code Transform}, ! * {@code Paint}, and {@code Composite}. ! * @param s the {@code Shape} to be filled * @see #setPaint * @see java.awt.Graphics#setColor * @see #transform * @see #setTransform * @see #setComposite
*** 788,816 **** * @see #setClip */ public abstract void fill(Shape s); /** ! * Checks whether or not the specified <code>Shape</code> intersects * the specified {@link Rectangle}, which is in device ! * space. If <code>onStroke</code> is false, this method checks ! * whether or not the interior of the specified <code>Shape</code> ! * intersects the specified <code>Rectangle</code>. If ! * <code>onStroke</code> is <code>true</code>, this method checks ! * whether or not the <code>Stroke</code> of the specified ! * <code>Shape</code> outline intersects the specified ! * <code>Rectangle</code>. * The rendering attributes taken into account include the ! * <code>Clip</code>, <code>Transform</code>, and <code>Stroke</code> * attributes. * @param rect the area in device space to check for a hit ! * @param s the <code>Shape</code> to check for a hit * @param onStroke flag used to choose between testing the ! * stroked or the filled shape. If the flag is <code>true</code>, the ! * <code>Stroke</code> outline is tested. If the flag is ! * <code>false</code>, the filled <code>Shape</code> is tested. ! * @return <code>true</code> if there is a hit; <code>false</code> * otherwise. * @see #setStroke * @see #fill * @see #draw * @see #transform --- 788,816 ---- * @see #setClip */ public abstract void fill(Shape s); /** ! * Checks whether or not the specified {@code Shape} intersects * the specified {@link Rectangle}, which is in device ! * space. If {@code onStroke} is false, this method checks ! * whether or not the interior of the specified {@code Shape} ! * intersects the specified {@code Rectangle}. If ! * {@code onStroke} is {@code true}, this method checks ! * whether or not the {@code Stroke} of the specified ! * {@code Shape} outline intersects the specified ! * {@code Rectangle}. * The rendering attributes taken into account include the ! * {@code Clip}, {@code Transform}, and {@code Stroke} * attributes. * @param rect the area in device space to check for a hit ! * @param s the {@code Shape} to check for a hit * @param onStroke flag used to choose between testing the ! * stroked or the filled shape. If the flag is {@code true}, the ! * {@code Stroke} outline is tested. If the flag is ! * {@code false}, the filled {@code Shape} is tested. ! * @return {@code true} if there is a hit; {@code false} * otherwise. * @see #setStroke * @see #fill * @see #draw * @see #transform
*** 822,894 **** Shape s, boolean onStroke); /** * Returns the device configuration associated with this ! * <code>Graphics2D</code>. ! * @return the device configuration of this <code>Graphics2D</code>. */ public abstract GraphicsConfiguration getDeviceConfiguration(); /** ! * Sets the <code>Composite</code> for the <code>Graphics2D</code> context. ! * The <code>Composite</code> is used in all drawing methods such as ! * <code>drawImage</code>, <code>drawString</code>, <code>draw</code>, ! * and <code>fill</code>. It specifies how new pixels are to be combined * with the existing pixels on the graphics device during the rendering * process. ! * <p>If this <code>Graphics2D</code> context is drawing to a ! * <code>Component</code> on the display screen and the ! * <code>Composite</code> is a custom object rather than an ! * instance of the <code>AlphaComposite</code> class, and if ! * there is a security manager, its <code>checkPermission</code> ! * method is called with an <code>AWTPermission("readDisplayPixels")</code> * permission. * @throws SecurityException ! * if a custom <code>Composite</code> object is being * used to render to the screen and a security manager ! * is set and its <code>checkPermission</code> method * does not allow the operation. ! * @param comp the <code>Composite</code> object to be used for rendering * @see java.awt.Graphics#setXORMode * @see java.awt.Graphics#setPaintMode * @see #getComposite * @see AlphaComposite * @see SecurityManager#checkPermission * @see java.awt.AWTPermission */ public abstract void setComposite(Composite comp); /** ! * Sets the <code>Paint</code> attribute for the ! * <code>Graphics2D</code> context. Calling this method ! * with a <code>null</code> <code>Paint</code> object does ! * not have any effect on the current <code>Paint</code> attribute ! * of this <code>Graphics2D</code>. ! * @param paint the <code>Paint</code> object to be used to generate ! * color during the rendering process, or <code>null</code> * @see java.awt.Graphics#setColor * @see #getPaint * @see GradientPaint * @see TexturePaint */ public abstract void setPaint( Paint paint ); /** ! * Sets the <code>Stroke</code> for the <code>Graphics2D</code> context. ! * @param s the <code>Stroke</code> object to be used to stroke a ! * <code>Shape</code> during the rendering process * @see BasicStroke * @see #getStroke */ public abstract void setStroke(Stroke s); /** * Sets the value of a single preference for the rendering algorithms. * Hint categories include controls for rendering quality and overall * time/quality trade-off in the rendering process. Refer to the ! * <code>RenderingHints</code> class for definitions of some common * keys and values. * @param hintKey the key of the hint to be set. * @param hintValue the value indicating preferences for the specified * hint category. * @see #getRenderingHint(RenderingHints.Key) --- 822,894 ---- Shape s, boolean onStroke); /** * Returns the device configuration associated with this ! * {@code Graphics2D}. ! * @return the device configuration of this {@code Graphics2D}. */ public abstract GraphicsConfiguration getDeviceConfiguration(); /** ! * Sets the {@code Composite} for the {@code Graphics2D} context. ! * The {@code Composite} is used in all drawing methods such as ! * {@code drawImage}, {@code drawString}, {@code draw}, ! * and {@code fill}. It specifies how new pixels are to be combined * with the existing pixels on the graphics device during the rendering * process. ! * <p>If this {@code Graphics2D} context is drawing to a ! * {@code Component} on the display screen and the ! * {@code Composite} is a custom object rather than an ! * instance of the {@code AlphaComposite} class, and if ! * there is a security manager, its {@code checkPermission} ! * method is called with an {@code AWTPermission("readDisplayPixels")} * permission. * @throws SecurityException ! * if a custom {@code Composite} object is being * used to render to the screen and a security manager ! * is set and its {@code checkPermission} method * does not allow the operation. ! * @param comp the {@code Composite} object to be used for rendering * @see java.awt.Graphics#setXORMode * @see java.awt.Graphics#setPaintMode * @see #getComposite * @see AlphaComposite * @see SecurityManager#checkPermission * @see java.awt.AWTPermission */ public abstract void setComposite(Composite comp); /** ! * Sets the {@code Paint} attribute for the ! * {@code Graphics2D} context. Calling this method ! * with a {@code null Paint} object does ! * not have any effect on the current {@code Paint} attribute ! * of this {@code Graphics2D}. ! * @param paint the {@code Paint} object to be used to generate ! * color during the rendering process, or {@code null} * @see java.awt.Graphics#setColor * @see #getPaint * @see GradientPaint * @see TexturePaint */ public abstract void setPaint( Paint paint ); /** ! * Sets the {@code Stroke} for the {@code Graphics2D} context. ! * @param s the {@code Stroke} object to be used to stroke a ! * {@code Shape} during the rendering process * @see BasicStroke * @see #getStroke */ public abstract void setStroke(Stroke s); /** * Sets the value of a single preference for the rendering algorithms. * Hint categories include controls for rendering quality and overall * time/quality trade-off in the rendering process. Refer to the ! * {@code RenderingHints} class for definitions of some common * keys and values. * @param hintKey the key of the hint to be set. * @param hintValue the value indicating preferences for the specified * hint category. * @see #getRenderingHint(RenderingHints.Key)
*** 898,927 **** /** * Returns the value of a single preference for the rendering algorithms. * Hint categories include controls for rendering quality and overall * time/quality trade-off in the rendering process. Refer to the ! * <code>RenderingHints</code> class for definitions of some common * keys and values. * @param hintKey the key corresponding to the hint to get. * @return an object representing the value for the specified hint key. * Some of the keys and their associated values are defined in the ! * <code>RenderingHints</code> class. * @see RenderingHints * @see #setRenderingHint(RenderingHints.Key, Object) */ public abstract Object getRenderingHint(Key hintKey); /** * Replaces the values of all preferences for the rendering ! * algorithms with the specified <code>hints</code>. * The existing values for all rendering hints are discarded and * the new set of known hints and values are initialized from the * specified {@link Map} object. * Hint categories include controls for rendering quality and * overall time/quality trade-off in the rendering process. ! * Refer to the <code>RenderingHints</code> class for definitions of * some common keys and values. * @param hints the rendering hints to be set * @see #getRenderingHints * @see RenderingHints */ --- 898,927 ---- /** * Returns the value of a single preference for the rendering algorithms. * Hint categories include controls for rendering quality and overall * time/quality trade-off in the rendering process. Refer to the ! * {@code RenderingHints} class for definitions of some common * keys and values. * @param hintKey the key corresponding to the hint to get. * @return an object representing the value for the specified hint key. * Some of the keys and their associated values are defined in the ! * {@code RenderingHints} class. * @see RenderingHints * @see #setRenderingHint(RenderingHints.Key, Object) */ public abstract Object getRenderingHint(Key hintKey); /** * Replaces the values of all preferences for the rendering ! * algorithms with the specified {@code hints}. * The existing values for all rendering hints are discarded and * the new set of known hints and values are initialized from the * specified {@link Map} object. * Hint categories include controls for rendering quality and * overall time/quality trade-off in the rendering process. ! * Refer to the {@code RenderingHints} class for definitions of * some common keys and values. * @param hints the rendering hints to be set * @see #getRenderingHints * @see RenderingHints */
*** 929,944 **** /** * Sets the values of an arbitrary number of preferences for the * rendering algorithms. * Only values for the rendering hints that are present in the ! * specified <code>Map</code> object are modified. * All other preferences not present in the specified * object are left unmodified. * Hint categories include controls for rendering quality and * overall time/quality trade-off in the rendering process. ! * Refer to the <code>RenderingHints</code> class for definitions of * some common keys and values. * @param hints the rendering hints to be set * @see RenderingHints */ public abstract void addRenderingHints(Map<?,?> hints); --- 929,944 ---- /** * Sets the values of an arbitrary number of preferences for the * rendering algorithms. * Only values for the rendering hints that are present in the ! * specified {@code Map} object are modified. * All other preferences not present in the specified * object are left unmodified. * Hint categories include controls for rendering quality and * overall time/quality trade-off in the rendering process. ! * Refer to the {@code RenderingHints} class for definitions of * some common keys and values. * @param hints the rendering hints to be set * @see RenderingHints */ public abstract void addRenderingHints(Map<?,?> hints);
*** 947,987 **** * Gets the preferences for the rendering algorithms. Hint categories * include controls for rendering quality and overall time/quality * trade-off in the rendering process. * Returns all of the hint key/value pairs that were ever specified in * one operation. Refer to the ! * <code>RenderingHints</code> class for definitions of some common * keys and values. ! * @return a reference to an instance of <code>RenderingHints</code> * that contains the current preferences. * @see RenderingHints * @see #setRenderingHints(Map) */ public abstract RenderingHints getRenderingHints(); /** ! * Translates the origin of the <code>Graphics2D</code> context to the * point (<i>x</i>,&nbsp;<i>y</i>) in the current coordinate system. ! * Modifies the <code>Graphics2D</code> context so that its new origin * corresponds to the point (<i>x</i>,&nbsp;<i>y</i>) in the ! * <code>Graphics2D</code> context's former coordinate system. All * coordinates used in subsequent rendering operations on this graphics * context are relative to this new origin. * @param x the specified x coordinate * @param y the specified y coordinate * @since 1.0 */ public abstract void translate(int x, int y); /** * Concatenates the current ! * <code>Graphics2D</code> <code>Transform</code> * with a translation transform. * Subsequent rendering is translated by the specified * distance relative to the previous position. * This is equivalent to calling transform(T), where T is an ! * <code>AffineTransform</code> represented by the following matrix: * <pre> * [ 1 0 tx ] * [ 0 1 ty ] * [ 0 0 1 ] * </pre> --- 947,987 ---- * Gets the preferences for the rendering algorithms. Hint categories * include controls for rendering quality and overall time/quality * trade-off in the rendering process. * Returns all of the hint key/value pairs that were ever specified in * one operation. Refer to the ! * {@code RenderingHints} class for definitions of some common * keys and values. ! * @return a reference to an instance of {@code RenderingHints} * that contains the current preferences. * @see RenderingHints * @see #setRenderingHints(Map) */ public abstract RenderingHints getRenderingHints(); /** ! * Translates the origin of the {@code Graphics2D} context to the * point (<i>x</i>,&nbsp;<i>y</i>) in the current coordinate system. ! * Modifies the {@code Graphics2D} context so that its new origin * corresponds to the point (<i>x</i>,&nbsp;<i>y</i>) in the ! * {@code Graphics2D} context's former coordinate system. All * coordinates used in subsequent rendering operations on this graphics * context are relative to this new origin. * @param x the specified x coordinate * @param y the specified y coordinate * @since 1.0 */ public abstract void translate(int x, int y); /** * Concatenates the current ! * {@code Graphics2D Transform} * with a translation transform. * Subsequent rendering is translated by the specified * distance relative to the previous position. * This is equivalent to calling transform(T), where T is an ! * {@code AffineTransform} represented by the following matrix: * <pre> * [ 1 0 tx ] * [ 0 1 ty ] * [ 0 0 1 ] * </pre>
*** 989,1004 **** * @param ty the distance to translate along the y-axis */ public abstract void translate(double tx, double ty); /** ! * Concatenates the current <code>Graphics2D</code> ! * <code>Transform</code> with a rotation transform. * Subsequent rendering is rotated by the specified radians relative * to the previous origin. ! * This is equivalent to calling <code>transform(R)</code>, where R is an ! * <code>AffineTransform</code> represented by the following matrix: * <pre> * [ cos(theta) -sin(theta) 0 ] * [ sin(theta) cos(theta) 0 ] * [ 0 0 1 ] * </pre> --- 989,1004 ---- * @param ty the distance to translate along the y-axis */ public abstract void translate(double tx, double ty); /** ! * Concatenates the current {@code Graphics2D} ! * {@code Transform} with a rotation transform. * Subsequent rendering is rotated by the specified radians relative * to the previous origin. ! * This is equivalent to calling {@code transform(R)}, where R is an ! * {@code AffineTransform} represented by the following matrix: * <pre> * [ cos(theta) -sin(theta) 0 ] * [ sin(theta) cos(theta) 0 ] * [ 0 0 1 ] * </pre>
*** 1007,1018 **** * @param theta the angle of rotation in radians */ public abstract void rotate(double theta); /** ! * Concatenates the current <code>Graphics2D</code> ! * <code>Transform</code> with a translated rotation * transform. Subsequent rendering is transformed by a transform * which is constructed by translating to the specified location, * rotating by the specified radians, and translating back by the same * amount as the original translation. This is equivalent to the * following sequence of calls: --- 1007,1018 ---- * @param theta the angle of rotation in radians */ public abstract void rotate(double theta); /** ! * Concatenates the current {@code Graphics2D} ! * {@code Transform} with a translated rotation * transform. Subsequent rendering is transformed by a transform * which is constructed by translating to the specified location, * rotating by the specified radians, and translating back by the same * amount as the original translation. This is equivalent to the * following sequence of calls:
*** 1028,1043 **** * @param y the y coordinate of the origin of the rotation */ public abstract void rotate(double theta, double x, double y); /** ! * Concatenates the current <code>Graphics2D</code> ! * <code>Transform</code> with a scaling transformation * Subsequent rendering is resized according to the specified scaling * factors relative to the previous scaling. ! * This is equivalent to calling <code>transform(S)</code>, where S is an ! * <code>AffineTransform</code> represented by the following matrix: * <pre> * [ sx 0 0 ] * [ 0 sy 0 ] * [ 0 0 1 ] * </pre> --- 1028,1043 ---- * @param y the y coordinate of the origin of the rotation */ public abstract void rotate(double theta, double x, double y); /** ! * Concatenates the current {@code Graphics2D} ! * {@code Transform} with a scaling transformation * Subsequent rendering is resized according to the specified scaling * factors relative to the previous scaling. ! * This is equivalent to calling {@code transform(S)}, where S is an ! * {@code AffineTransform} represented by the following matrix: * <pre> * [ sx 0 0 ] * [ 0 sy 0 ] * [ 0 0 1 ] * </pre>
*** 1049,1064 **** * rendering operations. */ public abstract void scale(double sx, double sy); /** ! * Concatenates the current <code>Graphics2D</code> ! * <code>Transform</code> with a shearing transform. * Subsequent renderings are sheared by the specified * multiplier relative to the previous position. ! * This is equivalent to calling <code>transform(SH)</code>, where SH ! * is an <code>AffineTransform</code> represented by the following * matrix: * <pre> * [ 1 shx 0 ] * [ shy 1 0 ] * [ 0 0 1 ] --- 1049,1064 ---- * rendering operations. */ public abstract void scale(double sx, double sy); /** ! * Concatenates the current {@code Graphics2D} ! * {@code Transform} with a shearing transform. * Subsequent renderings are sheared by the specified * multiplier relative to the previous position. ! * This is equivalent to calling {@code transform(SH)}, where SH ! * is an {@code AffineTransform} represented by the following * matrix: * <pre> * [ 1 shx 0 ] * [ shy 1 0 ] * [ 0 0 1 ]
*** 1069,1109 **** * the positive Y axis direction as a function of their X coordinate */ public abstract void shear(double shx, double shy); /** ! * Composes an <code>AffineTransform</code> object with the ! * <code>Transform</code> in this <code>Graphics2D</code> according * to the rule last-specified-first-applied. If the current ! * <code>Transform</code> is Cx, the result of composition ! * with Tx is a new <code>Transform</code> Cx'. Cx' becomes the ! * current <code>Transform</code> for this <code>Graphics2D</code>. ! * Transforming a point p by the updated <code>Transform</code> Cx' is * equivalent to first transforming p by Tx and then transforming ! * the result by the original <code>Transform</code> Cx. In other * words, Cx'(p) = Cx(Tx(p)). A copy of the Tx is made, if necessary, * so further modifications to Tx do not affect rendering. ! * @param Tx the <code>AffineTransform</code> object to be composed with ! * the current <code>Transform</code> * @see #setTransform * @see AffineTransform */ public abstract void transform(AffineTransform Tx); /** ! * Overwrites the Transform in the <code>Graphics2D</code> context. * WARNING: This method should <b>never</b> be used to apply a new * coordinate transform on top of an existing transform because the ! * <code>Graphics2D</code> might already have a transform that is * needed for other purposes, such as rendering Swing * components or applying a scaling transformation to adjust for the * resolution of a printer. * <p>To add a coordinate transform, use the ! * <code>transform</code>, <code>rotate</code>, <code>scale</code>, ! * or <code>shear</code> methods. The <code>setTransform</code> * method is intended only for restoring the original ! * <code>Graphics2D</code> transform after rendering, as shown in this * example: * <pre> * // Get the current transform * AffineTransform saveAT = g2.getTransform(); * // Perform transformation --- 1069,1109 ---- * the positive Y axis direction as a function of their X coordinate */ public abstract void shear(double shx, double shy); /** ! * Composes an {@code AffineTransform} object with the ! * {@code Transform} in this {@code Graphics2D} according * to the rule last-specified-first-applied. If the current ! * {@code Transform} is Cx, the result of composition ! * with Tx is a new {@code Transform} Cx'. Cx' becomes the ! * current {@code Transform} for this {@code Graphics2D}. ! * Transforming a point p by the updated {@code Transform} Cx' is * equivalent to first transforming p by Tx and then transforming ! * the result by the original {@code Transform} Cx. In other * words, Cx'(p) = Cx(Tx(p)). A copy of the Tx is made, if necessary, * so further modifications to Tx do not affect rendering. ! * @param Tx the {@code AffineTransform} object to be composed with ! * the current {@code Transform} * @see #setTransform * @see AffineTransform */ public abstract void transform(AffineTransform Tx); /** ! * Overwrites the Transform in the {@code Graphics2D} context. * WARNING: This method should <b>never</b> be used to apply a new * coordinate transform on top of an existing transform because the ! * {@code Graphics2D} might already have a transform that is * needed for other purposes, such as rendering Swing * components or applying a scaling transformation to adjust for the * resolution of a printer. * <p>To add a coordinate transform, use the ! * {@code transform}, {@code rotate}, {@code scale}, ! * or {@code shear} methods. The {@code setTransform} * method is intended only for restoring the original ! * {@code Graphics2D} transform after rendering, as shown in this * example: * <pre> * // Get the current transform * AffineTransform saveAT = g2.getTransform(); * // Perform transformation
*** 1112,1224 **** * g2d.draw(...); * // Restore original transform * g2d.setTransform(saveAT); * </pre> * ! * @param Tx the <code>AffineTransform</code> that was retrieved ! * from the <code>getTransform</code> method * @see #transform * @see #getTransform * @see AffineTransform */ public abstract void setTransform(AffineTransform Tx); /** ! * Returns a copy of the current <code>Transform</code> in the ! * <code>Graphics2D</code> context. ! * @return the current <code>AffineTransform</code> in the ! * <code>Graphics2D</code> context. * @see #transform * @see #setTransform */ public abstract AffineTransform getTransform(); /** ! * Returns the current <code>Paint</code> of the ! * <code>Graphics2D</code> context. ! * @return the current <code>Graphics2D</code> <code>Paint</code>, * which defines a color or pattern. * @see #setPaint * @see java.awt.Graphics#setColor */ public abstract Paint getPaint(); /** ! * Returns the current <code>Composite</code> in the ! * <code>Graphics2D</code> context. ! * @return the current <code>Graphics2D</code> <code>Composite</code>, * which defines a compositing style. * @see #setComposite */ public abstract Composite getComposite(); /** ! * Sets the background color for the <code>Graphics2D</code> context. * The background color is used for clearing a region. ! * When a <code>Graphics2D</code> is constructed for a ! * <code>Component</code>, the background color is ! * inherited from the <code>Component</code>. Setting the background color ! * in the <code>Graphics2D</code> context only affects the subsequent ! * <code>clearRect</code> calls and not the background color of the ! * <code>Component</code>. To change the background ! * of the <code>Component</code>, use appropriate methods of ! * the <code>Component</code>. * @param color the background color that is used in ! * subsequent calls to <code>clearRect</code> * @see #getBackground * @see java.awt.Graphics#clearRect */ public abstract void setBackground(Color color); /** * Returns the background color used for clearing a region. ! * @return the current <code>Graphics2D</code> <code>Color</code>, * which defines the background color. * @see #setBackground */ public abstract Color getBackground(); /** ! * Returns the current <code>Stroke</code> in the ! * <code>Graphics2D</code> context. ! * @return the current <code>Graphics2D</code> <code>Stroke</code>, * which defines the line style. * @see #setStroke */ public abstract Stroke getStroke(); /** ! * Intersects the current <code>Clip</code> with the interior of the ! * specified <code>Shape</code> and sets the <code>Clip</code> to the ! * resulting intersection. The specified <code>Shape</code> is ! * transformed with the current <code>Graphics2D</code> ! * <code>Transform</code> before being intersected with the current ! * <code>Clip</code>. This method is used to make the current ! * <code>Clip</code> smaller. ! * To make the <code>Clip</code> larger, use <code>setClip</code>. * The <i>user clip</i> modified by this method is independent of the * clipping associated with device bounds and visibility. If no clip has * previously been set, or if the clip has been cleared using ! * {@link Graphics#setClip(Shape) setClip} with a <code>null</code> ! * argument, the specified <code>Shape</code> becomes the new * user clip. ! * @param s the <code>Shape</code> to be intersected with the current ! * <code>Clip</code>. If <code>s</code> is <code>null</code>, ! * this method clears the current <code>Clip</code>. */ public abstract void clip(Shape s); /** ! * Get the rendering context of the <code>Font</code> within this ! * <code>Graphics2D</code> context. * The {@link FontRenderContext} * encapsulates application hints such as anti-aliasing and * fractional metrics, as well as target device specific information * such as dots-per-inch. This information should be provided by the * application when using objects that perform typographical ! * formatting, such as <code>Font</code> and ! * <code>TextLayout</code>. This information should also be provided * by applications that perform their own layout and need accurate * measurements of various characteristics of glyphs such as advance * and line height when various rendering hints have been applied to * the text rendering. * --- 1112,1224 ---- * g2d.draw(...); * // Restore original transform * g2d.setTransform(saveAT); * </pre> * ! * @param Tx the {@code AffineTransform} that was retrieved ! * from the {@code getTransform} method * @see #transform * @see #getTransform * @see AffineTransform */ public abstract void setTransform(AffineTransform Tx); /** ! * Returns a copy of the current {@code Transform} in the ! * {@code Graphics2D} context. ! * @return the current {@code AffineTransform} in the ! * {@code Graphics2D} context. * @see #transform * @see #setTransform */ public abstract AffineTransform getTransform(); /** ! * Returns the current {@code Paint} of the ! * {@code Graphics2D} context. ! * @return the current {@code Graphics2D Paint}, * which defines a color or pattern. * @see #setPaint * @see java.awt.Graphics#setColor */ public abstract Paint getPaint(); /** ! * Returns the current {@code Composite} in the ! * {@code Graphics2D} context. ! * @return the current {@code Graphics2D Composite}, * which defines a compositing style. * @see #setComposite */ public abstract Composite getComposite(); /** ! * Sets the background color for the {@code Graphics2D} context. * The background color is used for clearing a region. ! * When a {@code Graphics2D} is constructed for a ! * {@code Component}, the background color is ! * inherited from the {@code Component}. Setting the background color ! * in the {@code Graphics2D} context only affects the subsequent ! * {@code clearRect} calls and not the background color of the ! * {@code Component}. To change the background ! * of the {@code Component}, use appropriate methods of ! * the {@code Component}. * @param color the background color that is used in ! * subsequent calls to {@code clearRect} * @see #getBackground * @see java.awt.Graphics#clearRect */ public abstract void setBackground(Color color); /** * Returns the background color used for clearing a region. ! * @return the current {@code Graphics2D Color}, * which defines the background color. * @see #setBackground */ public abstract Color getBackground(); /** ! * Returns the current {@code Stroke} in the ! * {@code Graphics2D} context. ! * @return the current {@code Graphics2D Stroke}, * which defines the line style. * @see #setStroke */ public abstract Stroke getStroke(); /** ! * Intersects the current {@code Clip} with the interior of the ! * specified {@code Shape} and sets the {@code Clip} to the ! * resulting intersection. The specified {@code Shape} is ! * transformed with the current {@code Graphics2D} ! * {@code Transform} before being intersected with the current ! * {@code Clip}. This method is used to make the current ! * {@code Clip} smaller. ! * To make the {@code Clip} larger, use {@code setClip}. * The <i>user clip</i> modified by this method is independent of the * clipping associated with device bounds and visibility. If no clip has * previously been set, or if the clip has been cleared using ! * {@link Graphics#setClip(Shape) setClip} with a {@code null} ! * argument, the specified {@code Shape} becomes the new * user clip. ! * @param s the {@code Shape} to be intersected with the current ! * {@code Clip}. If {@code s} is {@code null}, ! * this method clears the current {@code Clip}. */ public abstract void clip(Shape s); /** ! * Get the rendering context of the {@code Font} within this ! * {@code Graphics2D} context. * The {@link FontRenderContext} * encapsulates application hints such as anti-aliasing and * fractional metrics, as well as target device specific information * such as dots-per-inch. This information should be provided by the * application when using objects that perform typographical ! * formatting, such as {@code Font} and ! * {@code TextLayout}. This information should also be provided * by applications that perform their own layout and need accurate * measurements of various characteristics of glyphs such as advance * and line height when various rendering hints have been applied to * the text rendering. *
< prev index next >