drawString

public void drawString(java.lang.String s,
float x,
float 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.

Specified by:

drawString in class java.awt.Graphics2D

Parameters:

s - the String to be rendered

x - the x coordinate of the location where the
String should be rendered

y - the y coordinate of the location where the
String should be rendered

translate

public void translate(int x,
int y)

Translates the origin of the graphics context to the point
(x, y) in the current coordinate system.
Modifies this graphics context so that its new origin corresponds
to the point (x, y) in this graphics context's
original coordinate system. All coordinates used in subsequent
rendering operations on this graphics context will be relative
to this new origin.

Specified by:

translate in class java.awt.Graphics2D

Parameters:

x - the x coordinate.

y - the y coordinate.

clip

public void clip(java.awt.Shape s)

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 Graphics2DTransform 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
setClip with a
null argument, the specified Shape becomes
the new user clip.

Specified by:

clip in class java.awt.Graphics2D

Parameters:

s - the Shape to be intersected with the current
Clip. If s is null,
this method clears the current Clip.

getClip

public java.awt.Shape getClip()

Gets the current clipping area.
This method returns the user clip, which is independent of the
clipping associated with device bounds and window visibility.
If no clip has previously been set, or if the clip has been
cleared using setClip(null), this method returns
null.

Specified by:

getClip in class java.awt.Graphics

Returns:

a Shape object representing the
current clipping area, or null if
no clip is set.

scale

public void scale(double sx,
double sy)

Concatenates the current Graphics2DTransform 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 ]

Specified by:

scale in class java.awt.Graphics2D

Parameters:

sx - the amount by which X coordinates in subsequent
rendering operations are multiplied relative to previous
rendering operations.

sy - the amount by which Y coordinates in subsequent
rendering operations are multiplied relative to previous
rendering operations.

drawRoundRect

Draws an outlined round-cornered rectangle using this graphics
context's current color. The left and right edges of the rectangle
are at x and x + width,
respectively. The top and bottom edges of the rectangle are at
y and y + height.

Specified by:

drawRoundRect in class java.awt.Graphics

Parameters:

x - the x coordinate of the rectangle to be drawn.

y - the y coordinate of the rectangle to be drawn.

width - the width of the rectangle to be drawn.

height - the height of the rectangle to be drawn.

arcWidth - the horizontal diameter of the arc
at the four corners.

arcHeight - the vertical diameter of the arc
at the four corners.

See Also:

Graphics.fillRoundRect(int, int, int, int, int, int)

drawString

public void drawString(java.lang.String str,
int x,
int y)

Draws the text given by the specified string, using this
graphics context's current font and color. The baseline of the
first character is at position (x, y) in this
graphics context's coordinate system.

fillRoundRect

Fills the specified rounded corner rectangle with the current color.
The left and right edges of the rectangle
are at x and x + width - 1,
respectively. The top and bottom edges of the rectangle are at
y and y + height - 1.

Specified by:

fillRoundRect in class java.awt.Graphics

Parameters:

x - the x coordinate of the rectangle to be filled.

y - the y coordinate of the rectangle to be filled.

width - the width of the rectangle to be filled.

height - the height of the rectangle to be filled.

arcWidth - the horizontal diameter
of the arc at the four corners.

arcHeight - the vertical diameter
of the arc at the four corners.

See Also:

Graphics.drawRoundRect(int, int, int, int, int, int)

fillArc

The resulting arc begins at startAngle and extends
for arcAngle degrees.
Angles are interpreted such that 0 degrees
is at the 3 o'clock position.
A positive value indicates a counter-clockwise rotation
while a negative value indicates a clockwise rotation.

The center of the arc is the center of the rectangle whose origin
is (x, y) and whose size is specified by the
width and height arguments.

The angles are specified relative to the non-square extents of
the bounding rectangle such that 45 degrees always falls on the
line from the center of the ellipse to the upper right corner of
the bounding rectangle. As a result, if the bounding rectangle is
noticeably longer in one axis than the other, the angles to the
start and end of the arc segment will be skewed farther along the
longer axis of the bounds.

Specified by:

fillArc in class java.awt.Graphics

Parameters:

x - the x coordinate of the
upper-left corner of the arc to be filled.

y - the y coordinate of the
upper-left corner of the arc to be filled.

width - the width of the arc to be filled.

height - the height of the arc to be filled.

startAngle - the beginning angle.

arcAngle - the angular extent of the arc,
relative to the start angle.

See Also:

Graphics.drawArc(int, int, int, int, int, int)

drawArc

Draws the outline of a circular or elliptical arc
covering the specified rectangle.

The resulting arc begins at startAngle and extends
for arcAngle degrees, using the current color.
Angles are interpreted such that 0 degrees
is at the 3 o'clock position.
A positive value indicates a counter-clockwise rotation
while a negative value indicates a clockwise rotation.

The center of the arc is the center of the rectangle whose origin
is (x, y) and whose size is specified by the
width and height arguments.

The angles are specified relative to the non-square extents of
the bounding rectangle such that 45 degrees always falls on the
line from the center of the ellipse to the upper right corner of
the bounding rectangle. As a result, if the bounding rectangle is
noticeably longer in one axis than the other, the angles to the
start and end of the arc segment will be skewed farther along the
longer axis of the bounds.

Specified by:

drawArc in class java.awt.Graphics

Parameters:

x - the x coordinate of the
upper-left corner of the arc to be drawn.

y - the y coordinate of the
upper-left corner of the arc to be drawn.

width - the width of the arc to be drawn.

height - the height of the arc to be drawn.

startAngle - the beginning angle.

arcAngle - the angular extent of the arc,
relative to the start angle.

See Also:

Graphics.fillArc(int, int, int, int, int, int)

drawPolyline

public void drawPolyline(int[] xPoints,
int[] yPoints,
int nPoints)

Draws a sequence of connected lines defined by
arrays of x and y coordinates.
Each pair of (x, y) coordinates defines a point.
The figure is not closed if the first point
differs from the last point.

Specified by:

drawPolyline in class java.awt.Graphics

Parameters:

xPoints - an array of x points

yPoints - an array of y points

nPoints - the total number of points

Since:

JDK1.1

See Also:

Graphics.drawPolygon(int[], int[], int)

drawOval

public void drawOval(int x,
int y,
int width,
int height)

Draws the outline of an oval.
The result is a circle or ellipse that fits within the
rectangle specified by the x, y,
width, and height arguments.

The oval covers an area that is
width + 1 pixels wide
and height + 1 pixels tall.

Specified by:

drawOval in class java.awt.Graphics

Parameters:

x - the x coordinate of the upper left
corner of the oval to be drawn.

y - the y coordinate of the upper left
corner of the oval to be drawn.

width - the width of the oval to be drawn.

height - the height of the oval to be drawn.

See Also:

Graphics.fillOval(int, int, int, int)

drawImage

Draws as much of the specified image as is currently available.
The image is drawn with its top-left corner at
(x, y) in this graphics context's coordinate
space. Transparent pixels are drawn in the specified
background color.

This operation is equivalent to filling a rectangle of the
width and height of the specified image with the given color and then
drawing the image on top of it, but possibly more efficient.

This method returns immediately in all cases, even if the
complete image has not yet been loaded, and it has not been dithered
and converted for the current output device.

If the image has not yet been completely loaded, then
drawImage returns false. As more of
the image becomes available, the process that draws the image notifies
the specified image observer.

Specified by:

drawImage in class java.awt.Graphics

Parameters:

img - the specified image to be drawn.

x - the x coordinate.

y - the y coordinate.

bgcolor - the background color to paint under the
non-opaque portions of the image.

drawImage

Draws as much of the specified image as has already been scaled
to fit inside the specified rectangle.

The image is drawn inside the specified rectangle of this
graphics context's coordinate space, and is scaled if
necessary. Transparent pixels are drawn in the specified
background color.
This operation is equivalent to filling a rectangle of the
width and height of the specified image with the given color and then
drawing the image on top of it, but possibly more efficient.

This method returns immediately in all cases, even if the
entire image has not yet been scaled, dithered, and converted
for the current output device.
If the current output representation is not yet complete then
drawImage returns false. As more of
the image becomes available, the process that draws the image notifies
the specified image observer.

A scaled version of an image will not necessarily be
available immediately just because an unscaled version of the
image has been constructed for this output device. Each size of
the image may be cached separately and generated from the original
data in a separate image production sequence.

Specified by:

drawImage in class java.awt.Graphics

Parameters:

img - the specified image to be drawn.

x - the x coordinate.

y - the y coordinate.

width - the width of the rectangle.

height - the height of the rectangle.

bgcolor - the background color to paint under the
non-opaque portions of the image.

drawImage

Draws as much of the specified area of the specified image as is
currently available, scaling it on the fly to fit inside the
specified area of the destination drawable surface. Transparent pixels
do not affect whatever pixels are already there.

This method returns immediately in all cases, even if the
image area to be drawn has not yet been scaled, dithered, and converted
for the current output device.
If the current output representation is not yet complete then
drawImage returns false. As more of
the image becomes available, the process that draws the image notifies
the specified image observer.

This method always uses the unscaled version of the image
to render the scaled rectangle and performs the required
scaling on the fly. It does not use a cached, scaled version
of the image for this operation. Scaling of the image from source
to destination is performed such that the first coordinate
of the source rectangle is mapped to the first coordinate of
the destination rectangle, and the second source coordinate is
mapped to the second destination coordinate. The subimage is
scaled and flipped as needed to preserve those mappings.

Specified by:

drawImage in class java.awt.Graphics

Parameters:

img - the specified image to be drawn

dx1 - the x coordinate of the first corner of the
destination rectangle.

dy1 - the y coordinate of the first corner of the
destination rectangle.

dx2 - the x coordinate of the second corner of the
destination rectangle.

dy2 - the y coordinate of the second corner of the
destination rectangle.

sx1 - the x coordinate of the first corner of the
source rectangle.

sy1 - the y coordinate of the first corner of the
source rectangle.

sx2 - the x coordinate of the second corner of the
source rectangle.

sy2 - the y coordinate of the second corner of the
source rectangle.

observer - object to be notified as more of the image is
scaled and converted.

drawImage

Draws as much of the specified area of the specified image as is
currently available, scaling it on the fly to fit inside the
specified area of the destination drawable surface.

Transparent pixels are drawn in the specified background color.
This operation is equivalent to filling a rectangle of the
width and height of the specified image with the given color and then
drawing the image on top of it, but possibly more efficient.

This method returns immediately in all cases, even if the
image area to be drawn has not yet been scaled, dithered, and converted
for the current output device.
If the current output representation is not yet complete then
drawImage returns false. As more of
the image becomes available, the process that draws the image notifies
the specified image observer.

This method always uses the unscaled version of the image
to render the scaled rectangle and performs the required
scaling on the fly. It does not use a cached, scaled version
of the image for this operation. Scaling of the image from source
to destination is performed such that the first coordinate
of the source rectangle is mapped to the first coordinate of
the destination rectangle, and the second source coordinate is
mapped to the second destination coordinate. The subimage is
scaled and flipped as needed to preserve those mappings.

Specified by:

drawImage in class java.awt.Graphics

Parameters:

img - the specified image to be drawn

dx1 - the x coordinate of the first corner of the
destination rectangle.

dy1 - the y coordinate of the first corner of the
destination rectangle.

dx2 - the x coordinate of the second corner of the
destination rectangle.

dy2 - the y coordinate of the second corner of the
destination rectangle.

sx1 - the x coordinate of the first corner of the
source rectangle.

sy1 - the y coordinate of the first corner of the
source rectangle.

sx2 - the x coordinate of the second corner of the
source rectangle.

sy2 - the y coordinate of the second corner of the
source rectangle.

bgcolor - the background color to paint under the
non-opaque portions of the image.

observer - object to be notified as more of the image is
scaled and converted.

drawImage

Draws as much of the specified image as is currently available.
The image is drawn with its top-left corner at
(x, y) in this graphics context's coordinate
space. Transparent pixels in the image do not affect whatever
pixels are already there.

This method returns immediately in all cases, even if the
complete image has not yet been loaded, and it has not been dithered
and converted for the current output device.

If the image has completely loaded and its pixels are
no longer being changed, then
drawImage returns true.
Otherwise, drawImage returns false
and as more of
the image becomes available
or it is time to draw another frame of animation,
the process that loads the image notifies
the specified image observer.

Specified by:

drawImage in class java.awt.Graphics

Parameters:

img - the specified image to be drawn. This method does
nothing if img is null.

dispose

public void dispose()

Disposes of this graphics context and releases
any system resources that it is using.
A Graphics object cannot be used after
disposehas been called.

When a Java program runs, a large number of Graphics
objects can be created within a short time frame.
Although the finalization process of the garbage collector
also disposes of the same system resources, it is preferable
to manually free the associated resources by calling this
method rather than to rely on a finalization process which
may not run to completion for a long period of time.

Graphics objects which are provided as arguments to the
paint and update methods
of components are automatically released by the system when
those methods return. For efficiency, programmers should
call dispose when finished using
a Graphics object only if it was created
directly from a component or another Graphics object.

drawLine

Draws a line, using the current color, between the points
(x1, y1) and (x2, y2)
in this graphics context's coordinate system.

Specified by:

drawLine in class java.awt.Graphics

Parameters:

x1 - the first point's x coordinate.

y1 - the first point's y coordinate.

x2 - the second point's x coordinate.

y2 - the second point's y coordinate.

fillPolygon

public void fillPolygon(int[] xPoints,
int[] yPoints,
int nPoints)

Fills a closed polygon defined by
arrays of x and y coordinates.

This method draws the polygon defined by nPoint line
segments, where the first nPoint - 1
line segments are line segments from
(xPoints[i - 1], yPoints[i - 1])
to (xPoints[i], yPoints[i]), for
1 ≤ i ≤ nPoints.
The figure is automatically closed by drawing a line connecting
the final point to the first point, if those points are different.

The area inside the polygon is defined using an
even-odd fill rule, also known as the alternating rule.

Specified by:

fillPolygon in class java.awt.Graphics

Parameters:

xPoints - a an array of x coordinates.

yPoints - a an array of y coordinates.

nPoints - a the total number of points.

See Also:

Graphics.drawPolygon(int[], int[], int)

fillRect

public void fillRect(int x,
int y,
int width,
int height)

Fills the specified rectangle.
The left and right edges of the rectangle are at
x and x + width - 1.
The top and bottom edges are at
y and y + height - 1.
The resulting rectangle covers an area
width pixels wide by
height pixels tall.
The rectangle is filled using the graphics context's current color.

drawRect

public void drawRect(int x,
int y,
int width,
int height)

Draws the outline of the specified rectangle.
The left and right edges of the rectangle are at
x and x + width.
The top and bottom edges are at
y and y + height.
The rectangle is drawn using the graphics context's current color.

drawPolygon

public void drawPolygon(int[] xPoints,
int[] yPoints,
int nPoints)

Draws a closed polygon defined by
arrays of x and y coordinates.
Each pair of (x, y) coordinates defines a point.

This method draws the polygon defined by nPoint line
segments, where the first nPoint - 1
line segments are line segments from
(xPoints[i - 1], yPoints[i - 1])
to (xPoints[i], yPoints[i]), for
1 ≤ i ≤ nPoints.
The figure is automatically closed by drawing a line connecting
the final point to the first point, if those points are different.

clipRect

public void clipRect(int x,
int y,
int width,
int height)

Intersects the current clip with the specified rectangle.
The resulting clipping area is the intersection of the current
clipping area and the specified rectangle. If there is no
current clipping area, either because the clip has never been
set, or the clip has been cleared using setClip(null),
the specified rectangle becomes the new clip.
This method sets the user clip, which is independent of the
clipping associated with device bounds and window visibility.
This method can only be used to make the current clip smaller.
To set the current clip larger, use any of the setClip methods.
Rendering operations have no effect outside of the clipping area.

setClip

public void setClip(java.awt.Shape clip)

Sets the current clipping area to an arbitrary clip shape.
Not all objects that implement the Shape
interface can be used to set the clip. The only
Shape objects that are guaranteed to be
supported are Shape objects that are
obtained via the getClip method and via
Rectangle objects. This method sets the
user clip, which is independent of the clipping associated
with device bounds and window visibility.

getClipBounds

public java.awt.Rectangle getClipBounds()

Returns the bounding rectangle of the current clipping area.
This method refers to the user clip, which is independent of the
clipping associated with device bounds and window visibility.
If no clip has previously been set, or if the clip has been
cleared using setClip(null), this method returns
null.
The coordinates in the rectangle are relative to the coordinate
system origin of this graphics context.

Specified by:

getClipBounds in class java.awt.Graphics

Returns:

the bounding rectangle of the current clipping area,
or null if no clip is set.

drawString

Draws the text given by the specified iterator, using this
graphics context's current color. The iterator has to specify a font
for each character. The baseline of the
first character is at position (x, y) in this
graphics context's coordinate system.

clearRect

Clears the specified rectangle by filling it with the background
color of the current drawing surface. This operation does not
use the current paint mode.

Beginning with Java 1.1, the background color
of offscreen images may be system dependent. Applications should
use setColor followed by fillRect to
ensure that an offscreen image is cleared to a specific color.

copyArea

setClip

public void setClip(int x,
int y,
int width,
int height)

Sets the current clip to the rectangle specified by the given
coordinates. This method sets the user clip, which is
independent of the clipping associated with device bounds
and window visibility.
Rendering operations have no effect outside of the clipping area.

Specified by:

setClip in class java.awt.Graphics

Parameters:

x - the x coordinate of the new clip rectangle.

y - the y coordinate of the new clip rectangle.

width - the width of the new clip rectangle.

height - the height of the new clip rectangle.

Since:

JDK1.1

See Also:

Graphics.clipRect(int, int, int, int),
Graphics.setClip(Shape)

rotate

public void rotate(double theta)

Concatenates the current Graphics2DTransform 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:

rotate

public void rotate(double theta,
double x,
double y)

Concatenates the current Graphics2DTransform 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:

shear

public void shear(double shx,
double shy)

Concatenates the current Graphics2DTransform 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 ]

Specified by:

shear in class java.awt.Graphics2D

Parameters:

shx - the multiplier by which coordinates are shifted in
the positive X axis direction as a function of their Y coordinate

shy - the multiplier by which coordinates are shifted in
the positive Y axis direction as a function of their X coordinate

getFontRenderContext

public java.awt.font.FontRenderContext getFontRenderContext()

Get the rendering context of the Font within this
Graphics2D context.
The 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.

transform

public void transform(java.awt.geom.AffineTransform Tx)

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.

Specified by:

transform in class java.awt.Graphics2D

Parameters:

Tx - the AffineTransform object to be composed with
the current Transform

setBackground

public void setBackground(java.awt.Color color)

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.

Specified by:

setBackground in class java.awt.Graphics2D

Parameters:

color - the background color that isused in
subsequent calls to clearRect

setComposite

public void setComposite(java.awt.Composite comp)

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.

Specified by:

setComposite in class java.awt.Graphics2D

Parameters:

comp - the Composite object to be used for rendering

Throws:

java.lang.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.

getRenderingHint

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.

Specified by:

getRenderingHint in class java.awt.Graphics2D

Parameters:

hintKey - the key corresponding to the hint to get.

Returns:

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 Also:

RenderingHints

setRenderingHint

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.

drawGlyphVector

Renders the text of the specified
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 Font.
The GlyphVector can also contain the glyph positions.
This is the fastest way to render a set of characters to the
screen.

addRenderingHints

public void addRenderingHints(java.util.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.

Specified by:

addRenderingHints in class java.awt.Graphics2D

Parameters:

hints - the rendering hints to be set

See Also:

RenderingHints

translate

public void translate(double tx,
double ty)

Concatenates the current
Graphics2DTransform
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 ]

Specified by:

translate in class java.awt.Graphics2D

Parameters:

tx - the distance to translate along the x-axis

ty - the distance to translate along the y-axis

drawString

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.

hit

Checks whether or not the specified Shape intersects
the specified 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.

Specified by:

hit in class java.awt.Graphics2D

Parameters:

rect - the area in device space to check for a hit

s - the Shape to check for a hit

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.

getRenderingHints

public java.awt.RenderingHints getRenderingHints()

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.

Specified by:

getRenderingHints in class java.awt.Graphics2D

Returns:

a reference to an instance of RenderingHints
that contains the current preferences.

See Also:

RenderingHints

setRenderingHints

public void setRenderingHints(java.util.Map hints)

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 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.

Specified by:

setRenderingHints in class java.awt.Graphics2D

Parameters:

hints - the rendering hints to be set

See Also:

RenderingHints

drawImage

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.

Specified by:

drawImage in class java.awt.Graphics2D

Parameters:

img - the Image to be rendered

xform - the transformation from image space into user space

obs - the ImageObserver
to be notified as more of the Image
is converted

Returns:

true if the Image is
fully loaded and completely rendered;
false if the Image is still being loaded.

drawImage

Draws as much of the specified image as has already been scaled
to fit inside the specified rectangle.

The image is drawn inside the specified rectangle of this
graphics context's coordinate space, and is scaled if
necessary. Transparent pixels do not affect whatever pixels
are already there.

This method returns immediately in all cases, even if the
entire image has not yet been scaled, dithered, and converted
for the current output device.
If the current output representation is not yet complete, then
drawImage returns false. As more of
the image becomes available, the process that loads the image notifies
the image observer by calling its imageUpdate method.

A scaled version of an image will not necessarily be
available immediately just because an unscaled version of the
image has been constructed for this output device. Each size of
the image may be cached separately and generated from the original
data in a separate image production sequence.

Specified by:

drawImage in class java.awt.Graphics

Parameters:

img - the specified image to be drawn. This method does
nothing if img is null.

setXORMode

public void setXORMode(java.awt.Color c1)

Sets the paint mode of this graphics context to alternate between
this graphics context's current color and the new specified color.
This specifies that logical pixel operations are performed in the
XOR mode, which alternates pixels between the current color and
a specified XOR color.

When drawing operations are performed, pixels which are the
current color are changed to the specified color, and vice versa.

Pixels that are of colors other than those two colors are changed
in an unpredictable but reversible manner; if the same figure is
drawn twice, then all pixels are restored to their original values.

Specified by:

setXORMode in class java.awt.Graphics

Parameters:

c1 - the XOR alternation color

setPaintMode

public void setPaintMode()

Sets the paint mode of this graphics context to overwrite the
destination with this graphics context's current color.
This sets the logical pixel operation function to the paint or
overwrite mode. All subsequent rendering operations will
overwrite the destination with the current color.

Specified by:

setPaintMode in class java.awt.Graphics

drawRenderedImage

Renders a
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
drawRenderedImage.

Specified by:

drawRenderedImage in class java.awt.Graphics2D

Parameters:

img - the image to be rendered. This method does
nothing if img is null.

drawRenderableImage

Renders a 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.

Specified by:

drawRenderableImage in class java.awt.Graphics2D

Parameters:

img - the image to be rendered. This method does
nothing if img is null.