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.
* *
Graphics2D object are specified
* in a device-independent coordinate system called User Space, which is
* used by applications. The 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.
*
* Coordinates in device space usually refer to individual device pixels
* and are aligned on the infinitely thin gaps between these pixels.
* Some 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 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.
*
* Some of the operations performed by the rendering attribute objects
* occur in the device space, but all Graphics2D methods take
* user space coordinates.
*
* Every 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
* Graphics2D object.
*
* When creating a Graphics2D object, the
* GraphicsConfiguration
* specifies the default transform for
* the target of the 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
* Identity transform.
*
*
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.
* * The steps in the rendering process are: *
Clip.
* The Clip is specified by a {@link Shape} in user
* space and is controlled by the program using the various clip
* manipulation methods of Graphics and
* Graphics2D. This user clip
* is transformed into device space by the current
* Transform and combined with the
* device clip, which is defined by the visibility of windows and
* device extents. The combination of the user clip and device clip
* defines the composite clip, which determines the final clipping
* region. The user clip is not modified by the rendering
* system to reflect the resulting composite clip.
* Graphics2D context.
* Shape operations
* draw(Shape) operation, then
* the {@link Stroke#createStrokedShape(Shape) createStrokedShape}
* method on the current {@link Stroke} attribute in the
* Graphics2D context is used to construct a new
* Shape object that contains the outline of the specified
* Shape.
* Shape is transformed from user space to device space
* using the current Transform
* in the Graphics2D context.
* Shape is extracted using the
* {@link Shape#getPathIterator(AffineTransform) getPathIterator} method of
* Shape, which returns a
* {@link java.awt.geom.PathIterator PathIterator}
* object that iterates along the boundary of the Shape.
* Graphics2D object cannot handle the curved segments
* that the PathIterator object returns then it can call the
* alternate
* {@link Shape#getPathIterator(AffineTransform, double) getPathIterator}
* method of Shape, which flattens the Shape.
* Graphics2D context
* is queried for a {@link PaintContext}, which specifies the
* colors to render in device space.
* String:
* String, then the current
* Font in the Graphics2D context is asked to
* convert the Unicode characters in the String into a set of
* glyphs for presentation with whatever basic layout and shaping
* algorithms the font implements.
* TextLayout
* implements more sophisticated glyph layout algorithms that
* perform Unicode bi-directional layout adjustments automatically
* for multiple fonts of differing writing directions.
* GlyphVector object already contains the appropriate
* font-specific glyph codes with explicit coordinates for the position of
* each glyph.
* 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.
* Shape operations.
* Paint is queried for a
* PaintContext, which specifies
* the colors to render in device space.
* Image Operations
* Image.
* This bounding box is specified in Image Space, which is the
* Image object's local coordinate system.
* AffineTransform is passed to
* {@link #drawImage(java.awt.Image, java.awt.geom.AffineTransform, java.awt.image.ImageObserver) drawImage(Image, AffineTransform, ImageObserver)},
* the AffineTransform is used to transform the bounding
* box from image space to user space. If no AffineTransform
* is supplied, the bounding box is treated as if it is already in user space.
* Image is transformed from user
* space into device space using the current Transform.
* Note that the result of transforming the bounding box does not
* necessarily result in a rectangular region in device space.
* Image object determines what colors to render,
* sampled according to the source to destination
* coordinate mapping specified by the current Transform and the
* optional image transform.
* Graphics2D rendering attributes are:
* Paint
* Component.
* Font
* Font of the Component.
* Stroke
* Transform
* GraphicsConfiguration of the Component.
* Composite
* Clip
* Clip, the output is clipped to the
* Component.
* * The Java 2D(tm) (Java(tm) 2 platform) API supports antialiasing renderers. * A pen with a width of one pixel does not need to fall * completely on pixel N as opposed to pixel N+1. The pen can fall * partially on both pixels. It is not necessary to choose a bias * direction for a wide pen since the blending that occurs along the * pen traversal edges makes the sub-pixel position of the pen * visible to the user. On the other hand, when antialiasing is * turned off by setting the * {@link RenderingHints#KEY_ANTIALIASING KEY_ANTIALIASING} hint key * to the * {@link RenderingHints#VALUE_ANTIALIAS_OFF VALUE_ANTIALIAS_OFF} * hint value, the renderer might need * to apply a bias to determine which pixel to modify when the pen * is straddling a pixel boundary, such as when it is drawn * along an integer coordinate in device space. While the capabilities * of an antialiasing renderer make it no longer necessary for the * rendering model to specify a bias for the pen, it is desirable for the * antialiasing and non-antialiasing renderers to perform similarly for * the common cases of drawing one-pixel wide horizontal and vertical * lines on the screen. To ensure that turning on antialiasing by * setting the * {@link RenderingHints#KEY_ANTIALIASING KEY_ANTIALIASING} hint * key to * {@link RenderingHints#VALUE_ANTIALIAS_ON VALUE_ANTIALIAS_ON} * does not cause such lines to suddenly become twice as wide and half * as opaque, it is desirable to have the model specify a path for such * lines so that they completely cover a particular set of pixels to help * increase their crispness. *
* 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 draw and
* fill methods are defined, which clearly indicates
* how Graphics2D extends Graphics based
* on settings of Stroke and Transform
* attributes and rendering hints. The definition
* performs identically under default attribute settings.
* For example, the default Stroke is a
* BasicStroke with a width of 1 and no dashing and the
* default Transform for screen drawing is an Identity transform.
*
* The following two rules provide predictable rendering behavior whether * aliasing or antialiasing is being used. *
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.
* The exact normalization algorithm is not specified, but the goals
* of this normalization are to ensure that lines are rendered with
* consistent visual appearance regardless of how they fall on the
* pixel grid and to promote more solid horizontal and vertical
* lines in antialiased mode so that they resemble their non-antialiased
* counterparts more closely. A typical normalization step might
* promote antialiased line endpoints to pixel centers to reduce the
* amount of blending or adjust the subpixel positioning of
* non-antialiased lines so that the floating point line widths
* round to even or odd pixel counts with equal likelihood. This
* process can move endpoints by up to half a pixel (usually towards
* positive infinity along both axes) to promote these consistent
* results.
* * The following definitions of general legacy methods * perform identically to previously specified behavior under default * attribute settings: *
fill operations, including fillRect,
* fillRoundRect, fillOval,
* fillArc, fillPolygon, and
* clearRect, {@link #fill(Shape) fill} can now be called
* with the desired Shape. For example, when filling a
* rectangle:
* * fill(new Rectangle(x, y, w, h)); ** is called. *
*
drawLine,
* drawRect, drawRoundRect,
* drawOval, drawArc, drawPolyline,
* and drawPolygon, {@link #draw(Shape) draw} can now be
* called with the desired Shape. For example, when drawing a
* rectangle:
* * draw(new Rectangle(x, y, w, h)); ** is called. *
*
draw3DRect and fill3DRect methods were
* implemented in terms of the drawLine and
* fillRect methods in the Graphics class which
* would predicate their behavior upon the current Stroke
* and Paint objects in a Graphics2D context.
* This class overrides those implementations with versions that use
* the current Color exclusively, overriding the current
* Paint and which uses fillRect to describe
* the exact same behavior as the preexisting methods regardless of the
* setting of the current Stroke.
* Graphics class defines only the setColor
* method to control the color to be painted. Since the Java 2D API extends
* the Color object to implement the new Paint
* interface, the existing
* setColor method is now a convenience method for setting the
* current Paint attribute to a Color object.
* setColor(c) is equivalent to setPaint(c).
*
* The Graphics class defines two methods for controlling
* how colors are applied to the destination.
*
setPaintMode method is implemented as a convenience
* method to set the default Composite, equivalent to
* setComposite(new AlphaComposite.SrcOver).
* setXORMode(Color xorcolor) method is implemented
* as a convenience method to set a special Composite object that
* ignores the Alpha components of source colors and sets the
* destination color to the value:
* * dstpixel = (PixelOf(srccolor) ^ PixelOf(xorcolor) ^ dstpixel); **
Graphics2D object. Since
* Graphics2D is an abstract class, and since it must be
* customized by subclasses for different output devices,
* Graphics2D objects cannot be created directly.
* Instead, Graphics2D objects must be obtained from another
* Graphics2D object, created by a
* Component, or obtained from images such as
* {@link BufferedImage} objects.
* @see java.awt.Component#getGraphics
* @see java.awt.Graphics#create
*/
protected Graphics2D() {
}
/**
* Draws a 3-D highlighted outline of the specified rectangle.
* The edges of the rectangle are highlighted so that they
* appear to be beveled and lit from the upper left corner.
*
* The colors used for the highlighting effect are determined
* based on the current color.
* The resulting rectangle covers an area that is
* width + 1 pixels wide
* by height + 1 pixels tall. This method
* uses the current Color exclusively and ignores
* the current 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
* appears to be raised above the surface
* or sunk into the surface.
* @see java.awt.Graphics#fill3DRect
*/
public void draw3DRect(int x, int y, int width, int height,
boolean raised) {
Paint p = getPaint();
Color c = getColor();
Color brighter = c.brighter();
Color darker = c.darker();
setColor(raised ? brighter : darker);
//drawLine(x, y, x, y + height);
fillRect(x, y, 1, height + 1);
//drawLine(x + 1, y, x + width - 1, y);
fillRect(x + 1, y, width - 1, 1);
setColor(raised ? darker : brighter);
//drawLine(x + 1, y + height, x + width, y + height);
fillRect(x + 1, y + height, width, 1);
//drawLine(x + width, y, x + width, y + height - 1);
fillRect(x + width, y, 1, height);
setPaint(p);
}
/**
* 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 Color. This method uses
* the current Color exclusively and ignores the current
* 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
* rectangle appears to be raised above the surface
* or etched into the surface.
* @see java.awt.Graphics#draw3DRect
*/
public void fill3DRect(int x, int y, int width, int height,
boolean raised) {
Paint p = getPaint();
Color c = getColor();
Color brighter = c.brighter();
Color darker = c.darker();
if (!raised) {
setColor(darker);
} else if (p != c) {
setColor(c);
}
fillRect(x+1, y+1, width-2, height-2);
setColor(raised ? brighter : darker);
//drawLine(x, y, x, y + height - 1);
fillRect(x, y, 1, height);
//drawLine(x + 1, y, x + width - 2, y);
fillRect(x + 1, y, width - 2, 1);
setColor(raised ? darker : brighter);
//drawLine(x + 1, y + height - 1, x + width - 1, y + height - 1);
fillRect(x + 1, y + height - 1, width - 1, 1);
//drawLine(x + width - 1, y, x + width - 1, y + height - 2);
fillRect(x + width - 1, y, 1, height - 1);
setPaint(p);
}
/**
* Strokes the outline of a Shape using the settings of the
* current Graphics2D context. The rendering attributes
* applied include the Clip, Transform,
* Paint, Composite and
* Stroke attributes.
* @param s the Shape to be rendered
* @see #setStroke
* @see #setPaint
* @see java.awt.Graphics#setColor
* @see #transform
* @see #setTransform
* @see #clip
* @see #setClip
* @see #setComposite
*/
public abstract void draw(Shape s);
/**
* 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 Transform in the Graphics2D.
* The specified transformation is applied to the image before the
* transform attribute in the Graphics2D context is applied.
* The rendering attributes applied include the Clip,
* Transform, and 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 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 Image
* is converted
* @return true if the Image is
* fully loaded and completely rendered, or if it's null;
* false if the Image is still being loaded.
* @see #transform
* @see #setTransform
* @see #setComposite
* @see #clip
* @see #setClip
*/
public abstract boolean drawImage(Image img,
AffineTransform xform,
ImageObserver obs);
/**
* Renders a BufferedImage that is
* filtered with a
* {@link BufferedImageOp}.
* The rendering attributes applied include the Clip,
* Transform
* and Composite attributes. This is equivalent to:
*
* img1 = op.filter(img, null);
* drawImage(img1, new AffineTransform(1f,0f,0f,1f,x,y), null);
*
* @param op the filter to be applied to the image before rendering
* @param img the specified BufferedImage to be rendered.
* This method does nothing if 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
*
* @see #transform
* @see #setTransform
* @see #setComposite
* @see #clip
* @see #setClip
*/
public abstract void drawImage(BufferedImage img,
BufferedImageOp op,
int x,
int y);
/**
* 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 Transform in the Graphics2D.
* The specified transformation is applied to the image before the
* transform attribute in the Graphics2D context is applied.
* The rendering attributes applied include the Clip,
* Transform, and 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 img is null.
* @param xform the transformation from image space into user space
* @see #transform
* @see #setTransform
* @see #setComposite
* @see #clip
* @see #setClip
*/
public abstract void drawRenderedImage(RenderedImage img,
AffineTransform xform);
/**
* 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 Transform in the Graphics2D.
* The specified transformation is applied to the image before the
* transform attribute in the Graphics2D context is applied.
* The rendering attributes applied include the Clip,
* Transform, and Composite attributes. Note
* that no rendering is done if the specified transform is
* noninvertible.
*
* Rendering hints set on the Graphics2D object might
* be used in rendering the RenderableImage.
* If explicit control is required over specific hints recognized by a
* specific RenderableImage, or if knowledge of which hints
* are used is required, then a RenderedImage should be
* obtained directly from the RenderableImage
* and rendered using
*{@link #drawRenderedImage(RenderedImage, AffineTransform) drawRenderedImage}.
* @param img the image to be rendered. This method does
* nothing if img is null.
* @param xform the transformation from image space into user space
* @see #transform
* @see #setTransform
* @see #setComposite
* @see #clip
* @see #setClip
* @see #drawRenderedImage
*/
public abstract void drawRenderableImage(RenderableImage img,
AffineTransform xform);
/**
* Renders the text of the specified String, using the
* current text attribute state in the Graphics2D context.
* The baseline of the
* first character is at position (x, y) in
* the User Space.
* The rendering attributes applied include the Clip,
* Transform, Paint, Font and
* 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
* String should be rendered
* @param y the y coordinate of the location where the
* String should be rendered
* @throws NullPointerException if str is
* null
* @see java.awt.Graphics#drawBytes
* @see java.awt.Graphics#drawChars
* @since JDK1.0
*/
public abstract void drawString(String str, int x, int y);
/**
* Renders the text specified by the specified String,
* using the current text attribute state in the Graphics2D context.
* The baseline of the first character is at position
* (x, y) in the User Space.
* The rendering attributes applied include the Clip,
* Transform, Paint, Font and
* 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 s the String to be rendered
* @param x the x coordinate of the location where the
* String should be rendered
* @param y the y coordinate of the location where the
* String should be rendered
* @throws NullPointerException if str is
* null
* @see #setPaint
* @see java.awt.Graphics#setColor
* @see java.awt.Graphics#setFont
* @see #setTransform
* @see #setComposite
* @see #setClip
*/
public abstract void drawString(String s, float x, float y);
/**
* Renders the text of the specified iterator, using the
* Graphics2D context's current Paint. The
* iterator has to specify a font
* for each character. The baseline of the
* first character is at position (x, y) in the
* User Space.
* The rendering attributes applied include the Clip,
* Transform, Paint, and
* 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 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
* @see #setPaint
* @see java.awt.Graphics#setColor
* @see #setTransform
* @see #setComposite
* @see #setClip
*/
public abstract void drawString(AttributedCharacterIterator iterator,
int x, int y);
/**
* Renders the text of the specified iterator, using the
* Graphics2D context's current Paint. The
* iterator must specify a font
* for each character. The baseline of the
* first character is at position (x, y) in the
* User Space.
* The rendering attributes applied include the Clip,
* Transform, Paint, and
* 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 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
* @see #setPaint
* @see java.awt.Graphics#setColor
* @see #setTransform
* @see #setComposite
* @see #setClip
*/
public abstract void drawString(AttributedCharacterIterator iterator,
float x, float y);
/**
* Renders the text of the specified
* {@link GlyphVector} using
* the Graphics2D context's rendering attributes.
* The rendering attributes applied include the Clip,
* Transform, Paint, and
* Composite attributes. The GlyphVector
* specifies individual glyphs from a {@link Font}.
* The GlyphVector can also contain the glyph positions.
* This is the fastest way to render a set of characters to the
* screen.
* @param g the 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
*
* @see java.awt.Font#createGlyphVector
* @see java.awt.font.GlyphVector
* @see #setPaint
* @see java.awt.Graphics#setColor
* @see #setTransform
* @see #setComposite
* @see #setClip
*/
public abstract void drawGlyphVector(GlyphVector g, float x, float y);
/**
* Fills the interior of a Shape using the settings of the
* Graphics2D context. The rendering attributes applied
* include the Clip, Transform,
* Paint, and Composite.
* @param s the Shape to be filled
* @see #setPaint
* @see java.awt.Graphics#setColor
* @see #transform
* @see #setTransform
* @see #setComposite
* @see #clip
* @see #setClip
*/
public abstract void fill(Shape s);
/**
* Checks whether or not the specified Shape intersects
* the specified {@link Rectangle}, which is in device
* space. If onStroke is false, this method checks
* whether or not the interior of the specified Shape
* intersects the specified Rectangle. If
* onStroke is true, this method checks
* whether or not the Stroke of the specified
* Shape outline intersects the specified
* Rectangle.
* The rendering attributes taken into account include the
* Clip, Transform, and Stroke
* attributes.
* @param rect the area in device space to check for a hit
* @param s the Shape to check for a hit
* @param onStroke flag used to choose between testing the
* stroked or the filled shape. If the flag is true, the
* Stroke oultine is tested. If the flag is
* false, the filled Shape is tested.
* @return true if there is a hit; false
* otherwise.
* @see #setStroke
* @see #fill
* @see #draw
* @see #transform
* @see #setTransform
* @see #clip
* @see #setClip
*/
public abstract boolean hit(Rectangle rect,
Shape s,
boolean onStroke);
/**
* Returns the device configuration associated with this
* Graphics2D.
* @return the device configuration of this Graphics2D.
*/
public abstract GraphicsConfiguration getDeviceConfiguration();
/**
* Sets the Composite for the Graphics2D context.
* The Composite is used in all drawing methods such as
* drawImage, drawString, draw,
* and fill. It specifies how new pixels are to be combined
* with the existing pixels on the graphics device during the rendering
* process.
*
If this Graphics2D context is drawing to a
* Component on the display screen and the
* Composite is a custom object rather than an
* instance of the AlphaComposite class, and if
* there is a security manager, its checkPermission
* method is called with an AWTPermission("readDisplayPixels")
* permission.
* @throws SecurityException
* if a custom Composite object is being
* used to render to the screen and a security manager
* is set and its checkPermission method
* does not allow the operation.
* @param comp the 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 Paint attribute for the
* Graphics2D context. Calling this method
* with a null Paint object does
* not have any effect on the current Paint attribute
* of this Graphics2D.
* @param paint the Paint object to be used to generate
* color during the rendering process, or null
* @see java.awt.Graphics#setColor
* @see #getPaint
* @see GradientPaint
* @see TexturePaint
*/
public abstract void setPaint( Paint paint );
/**
* Sets the Stroke for the Graphics2D context.
* @param s the Stroke object to be used to stroke a
* 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
* 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)
* @see RenderingHints
*/
public abstract void setRenderingHint(Key hintKey, Object hintValue);
/**
* 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
* 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
* 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 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 RenderingHints class for definitions of
* some common keys and values.
* @param hints the rendering hints to be set
* @see #getRenderingHints
* @see RenderingHints
*/
public abstract void setRenderingHints(Map hints);
/**
* 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 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 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);
/**
* 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
* RenderingHints class for definitions of some common
* keys and values.
* @return a reference to an instance of RenderingHints
* that contains the current preferences.
* @see RenderingHints
* @see #setRenderingHints(Map)
*/
public abstract RenderingHints getRenderingHints();
/**
* Translates the origin of the Graphics2D context to the
* point (x, y) in the current coordinate system.
* Modifies the Graphics2D context so that its new origin
* corresponds to the point (x, y) in the
* 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 JDK1.0
*/
public abstract void translate(int x, int y);
/**
* Concatenates the current
* 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
* AffineTransform represented by the following matrix:
*
* [ 1 0 tx ]
* [ 0 1 ty ]
* [ 0 0 1 ]
*
* @param tx the distance to translate along the x-axis
* @param ty the distance to translate along the y-axis
*/
public abstract void translate(double tx, double ty);
/**
* Concatenates the current Graphics2D
* Transform with a rotation transform.
* Subsequent rendering is rotated by the specified radians relative
* to the previous origin.
* This is equivalent to calling transform(R), where R is an
* AffineTransform represented by the following matrix:
*
* [ cos(theta) -sin(theta) 0 ]
* [ sin(theta) cos(theta) 0 ]
* [ 0 0 1 ]
*
* Rotating with a positive angle theta rotates points on the positive
* x axis toward the positive y axis.
* @param theta the angle of rotation in radians
*/
public abstract void rotate(double theta);
/**
* Concatenates the current Graphics2D
* 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:
*
* translate(x, y);
* rotate(theta);
* translate(-x, -y);
*
* Rotating with a positive angle theta rotates points on the positive
* x axis toward the positive y axis.
* @param theta the angle of rotation in radians
* @param x the x coordinate of the origin of the rotation
* @param y the y coordinate of the origin of the rotation
*/
public abstract void rotate(double theta, double x, double y);
/**
* Concatenates the current Graphics2D
* 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 transform(S), where S is an
* AffineTransform represented by the following matrix:
*
* [ sx 0 0 ]
* [ 0 sy 0 ]
* [ 0 0 1 ]
*
* @param sx the amount by which X coordinates in subsequent
* rendering operations are multiplied relative to previous
* rendering operations.
* @param sy the amount by which Y coordinates in subsequent
* rendering operations are multiplied relative to previous
* rendering operations.
*/
public abstract void scale(double sx, double sy);
/**
* Concatenates the current Graphics2D
* Transform with a shearing transform.
* Subsequent renderings are sheared by the specified
* multiplier relative to the previous position.
* This is equivalent to calling transform(SH), where SH
* is an AffineTransform represented by the following
* matrix:
*
* [ 1 shx 0 ]
* [ shy 1 0 ]
* [ 0 0 1 ]
*
* @param shx the multiplier by which coordinates are shifted in
* the positive X axis direction as a function of their Y coordinate
* @param shy the multiplier by which coordinates are shifted in
* the positive Y axis direction as a function of their X coordinate
*/
public abstract void shear(double shx, double shy);
/**
* Composes an AffineTransform object with the
* Transform in this Graphics2D according
* to the rule last-specified-first-applied. If the current
* Transform is Cx, the result of composition
* with Tx is a new Transform Cx'. Cx' becomes the
* current Transform for this Graphics2D.
* Transforming a point p by the updated Transform Cx' is
* equivalent to first transforming p by Tx and then transforming
* the result by the original 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 AffineTransform object to be composed with
* the current Transform
* @see #setTransform
* @see AffineTransform
*/
public abstract void transform(AffineTransform Tx);
/**
* Overwrites the Transform in the Graphics2D context.
* WARNING: This method should never be used to apply a new
* coordinate transform on top of an existing transform because the
* 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.
* To add a coordinate transform, use the
* transform, rotate, scale,
* or shear methods. The setTransform
* method is intended only for restoring the original
* Graphics2D transform after rendering, as shown in this
* example:
*
* * @param Tx the* // Get the current transform * AffineTransform saveAT = g2.getTransform(); * // Perform transformation * g2d.transform(...); * // Render * g2d.draw(...); * // Restore original transform * g2d.setTransform(saveAT); *
AffineTransform that was retrieved
* from the getTransform method
* @see #transform
* @see #getTransform
* @see AffineTransform
*/
public abstract void setTransform(AffineTransform Tx);
/**
* Returns a copy of the current Transform in the
* Graphics2D context.
* @return the current AffineTransform in the
* Graphics2D context.
* @see #transform
* @see #setTransform
*/
public abstract AffineTransform getTransform();
/**
* Returns the current Paint of the
* Graphics2D context.
* @return the current Graphics2D Paint,
* which defines a color or pattern.
* @see #setPaint
* @see java.awt.Graphics#setColor
*/
public abstract Paint getPaint();
/**
* Returns the current Composite in the
* Graphics2D context.
* @return the current Graphics2D Composite,
* which defines a compositing style.
* @see #setComposite
*/
public abstract Composite getComposite();
/**
* Sets the background color for the Graphics2D context.
* The background color is used for clearing a region.
* When a Graphics2D is constructed for a
* Component, the background color is
* inherited from the Component. Setting the background color
* in the Graphics2D context only affects the subsequent
* clearRect calls and not the background color of the
* Component. To change the background
* of the Component, use appropriate methods of
* the Component.
* @param color the background color that isused in
* subsequent calls to 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 Graphics2D Color,
* which defines the background color.
* @see #setBackground
*/
public abstract Color getBackground();
/**
* Returns the current Stroke in the
* Graphics2D context.
* @return the current Graphics2D Stroke,
* which defines the line style.
* @see #setStroke
*/
public abstract Stroke getStroke();
/**
* Intersects the current Clip with the interior of the
* specified Shape and sets the Clip to the
* resulting intersection. The specified Shape is
* transformed with the current Graphics2D
* Transform before being intersected with the current
* Clip. This method is used to make the current
* Clip smaller.
* To make the Clip larger, use setClip.
* The user clip 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 null
* argument, the specified Shape becomes the new
* user clip.
* @param s the Shape to be intersected with the current
* Clip. If s is null,
* this method clears the current Clip.
*/
public abstract void clip(Shape s);
/**
* Get the rendering context of the Font within this
* 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 Font and
* 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.
*
* @return a reference to an instance of FontRenderContext.
* @see java.awt.font.FontRenderContext
* @see java.awt.Font#createGlyphVector
* @see java.awt.font.TextLayout
* @since 1.2
*/
public abstract FontRenderContext getFontRenderContext();
}