RadialGradientPaintpublic final class RadialGradientPaint extends MultipleGradientPaint | The {@code RadialGradientPaint} class provides a way to fill a shape with
a circular radial color gradient pattern. The user may specify 2 or more
gradient colors, and this paint will provide an interpolation between
each color.
The user must specify the circle controlling the gradient pattern,
which is described by a center point and a radius. The user can also
specify a separate focus point within that circle, which controls the
location of the first color of the gradient. By default the focus is
set to be the center of the circle.
This paint will map the first color of the gradient to the focus point,
and the last color to the perimeter of the circle, interpolating
smoothly for any in-between colors specified by the user. Any line drawn
from the focus point to the circumference will thus span all the gradient
colors.
Specifying a focus point outside of the circle's radius will result in the
focus being set to the intersection point of the focus-center line and the
perimeter of the circle.
The user must provide an array of floats specifying how to distribute the
colors along the gradient. These values should range from 0.0 to 1.0 and
act like keyframes along the gradient (they mark where the gradient should
be exactly a particular color).
In the event that the user does not set the first keyframe value equal
to 0 and/or the last keyframe value equal to 1, keyframes will be created
at these positions and the first and last colors will be replicated there.
So, if a user specifies the following arrays to construct a gradient:
{Color.BLUE, Color.RED}, {.3f, .7f}
this will be converted to a gradient with the following keyframes:
{Color.BLUE, Color.BLUE, Color.RED, Color.RED}, {0f, .3f, .7f, 1f}
The user may also select what action the {@code RadialGradientPaint}
should take when filling color outside the bounds of the circle's radius.
If no cycle method is specified, {@code NO_CYCLE} will be chosen by
default, which means the the last keyframe color will be used to fill the
remaining area.
The colorSpace parameter allows the user to specify in which colorspace
the interpolation should be performed, default sRGB or linearized RGB.
The following code demonstrates typical usage of
{@code RadialGradientPaint}, where the center and focus points are
the same:
Point2D center = new Point2D.Float(50, 50);
float radius = 25;
float[] dist = {0.0f, 0.2f, 1.0f};
Color[] colors = {Color.RED, Color.WHITE, Color.BLUE};
RadialGradientPaint p =
new RadialGradientPaint(center, radius, dist, colors);
This image demonstrates the example code above, with default
(centered) focus for each of the three cycle methods:
It is also possible to specify a non-centered focus point, as
in the following code:
Point2D center = new Point2D.Float(50, 50);
float radius = 25;
Point2D focus = new Point2D.Float(40, 40);
float[] dist = {0.0f, 0.2f, 1.0f};
Color[] colors = {Color.RED, Color.WHITE, Color.BLUE};
RadialGradientPaint p =
new RadialGradientPaint(center, radius, focus,
dist, colors,
CycleMethod.NO_CYCLE);
This image demonstrates the previous example code, with non-centered
focus for each of the three cycle methods:
|
| Fields Summary |
|---|
| private final Point2D | focusFocus point which defines the 0% gradient stop X coordinate. | | private final Point2D | centerCenter of the circle defining the 100% gradient stop X coordinate. | | private final float | radiusRadius of the outermost circle defining the 100% gradient stop. |
| Constructors Summary |
|---|
public RadialGradientPaint(float cx, float cy, float radius, float[] fractions, Color[] colors)Constructs a {@code RadialGradientPaint} with a default
{@code NO_CYCLE} repeating method and {@code SRGB} color space,
using the center as the focus point.
this(cx, cy,
radius,
cx, cy,
fractions,
colors,
CycleMethod.NO_CYCLE);
| public RadialGradientPaint(Point2D center, float radius, float[] fractions, Color[] colors)Constructs a {@code RadialGradientPaint} with a default
{@code NO_CYCLE} repeating method and {@code SRGB} color space,
using the center as the focus point.
this(center,
radius,
center,
fractions,
colors,
CycleMethod.NO_CYCLE);
| public RadialGradientPaint(float cx, float cy, float radius, float[] fractions, Color[] colors, CycleMethod cycleMethod)Constructs a {@code RadialGradientPaint} with a default
{@code SRGB} color space, using the center as the focus point.
this(cx, cy,
radius,
cx, cy,
fractions,
colors,
cycleMethod);
| public RadialGradientPaint(Point2D center, float radius, float[] fractions, Color[] colors, CycleMethod cycleMethod)Constructs a {@code RadialGradientPaint} with a default
{@code SRGB} color space, using the center as the focus point.
this(center,
radius,
center,
fractions,
colors,
cycleMethod);
| public RadialGradientPaint(float cx, float cy, float radius, float fx, float fy, float[] fractions, Color[] colors, CycleMethod cycleMethod)Constructs a {@code RadialGradientPaint} with a default
{@code SRGB} color space.
this(new Point2D.Float(cx, cy),
radius,
new Point2D.Float(fx, fy),
fractions,
colors,
cycleMethod);
| public RadialGradientPaint(Point2D center, float radius, Point2D focus, float[] fractions, Color[] colors, CycleMethod cycleMethod)Constructs a {@code RadialGradientPaint} with a default
{@code SRGB} color space.
this(center,
radius,
focus,
fractions,
colors,
cycleMethod,
ColorSpaceType.SRGB,
new AffineTransform());
| public RadialGradientPaint(Point2D center, float radius, Point2D focus, float[] fractions, Color[] colors, CycleMethod cycleMethod, ColorSpaceType colorSpace, AffineTransform gradientTransform)Constructs a {@code RadialGradientPaint}.
super(fractions, colors, cycleMethod, colorSpace, gradientTransform);
// check input arguments
if (center == null) {
throw new NullPointerException("Center point must be non-null");
}
if (focus == null) {
throw new NullPointerException("Focus point must be non-null");
}
if (radius <= 0) {
throw new IllegalArgumentException("Radius must be greater " +
"than zero");
}
// copy parameters
this.center = new Point2D.Double(center.getX(), center.getY());
this.focus = new Point2D.Double(focus.getX(), focus.getY());
this.radius = radius;
| public RadialGradientPaint(Rectangle2D gradientBounds, float[] fractions, Color[] colors, CycleMethod cycleMethod)Constructs a {@code RadialGradientPaint} with a default
{@code SRGB} color space.
The gradient circle of the {@code RadialGradientPaint} is defined
by the given bounding box.
This constructor is a more convenient way to express the
following (equivalent) code:
double gw = gradientBounds.getWidth();
double gh = gradientBounds.getHeight();
double cx = gradientBounds.getCenterX();
double cy = gradientBounds.getCenterY();
Point2D center = new Point2D.Double(cx, cy);
AffineTransform gradientTransform = new AffineTransform();
gradientTransform.translate(cx, cy);
gradientTransform.scale(gw / 2, gh / 2);
gradientTransform.translate(-cx, -cy);
RadialGradientPaint gp =
new RadialGradientPaint(center, 1.0f, center,
fractions, colors,
cycleMethod,
ColorSpaceType.SRGB,
gradientTransform);
// gradient center/focal point is the center of the bounding box,
// radius is set to 1.0, and then we set a scale transform
// to achieve an elliptical gradient defined by the bounding box
this(new Point2D.Double(gradientBounds.getCenterX(),
gradientBounds.getCenterY()),
1.0f,
new Point2D.Double(gradientBounds.getCenterX(),
gradientBounds.getCenterY()),
fractions,
colors,
cycleMethod,
ColorSpaceType.SRGB,
createGradientTransform(gradientBounds));
if (gradientBounds.isEmpty()) {
throw new IllegalArgumentException("Gradient bounds must be " +
"non-empty");
}
|
| Methods Summary |
|---|
| public java.awt.PaintContext | createContext(java.awt.image.ColorModel cm, java.awt.Rectangle deviceBounds, java.awt.geom.Rectangle2D userBounds, java.awt.geom.AffineTransform transform, java.awt.RenderingHints hints){@inheritDoc}
// avoid modifying the user's transform...
transform = new AffineTransform(transform);
// incorporate the gradient transform
transform.concatenate(gradientTransform);
return new RadialGradientPaintContext(this, cm,
deviceBounds, userBounds,
transform, hints,
(float)center.getX(),
(float)center.getY(),
radius,
(float)focus.getX(),
(float)focus.getY(),
fractions, colors,
cycleMethod, colorSpace);
| | private static java.awt.geom.AffineTransform | createGradientTransform(java.awt.geom.Rectangle2D r)
double cx = r.getCenterX();
double cy = r.getCenterY();
AffineTransform xform = AffineTransform.getTranslateInstance(cx, cy);
xform.scale(r.getWidth()/2, r.getHeight()/2);
xform.translate(-cx, -cy);
return xform;
| | public java.awt.geom.Point2D | getCenterPoint()Returns a copy of the center point of the radial gradient.
return new Point2D.Double(center.getX(), center.getY());
| | public java.awt.geom.Point2D | getFocusPoint()Returns a copy of the end point of the gradient axis.
return new Point2D.Double(focus.getX(), focus.getY());
| | public float | getRadius()Returns the radius of the circle defining the radial gradient.
return radius;
|
|
