java.awt
public final class: RadialGradientPaint [javadoc 
source]
java.lang.Object
java.awt.MultipleGradientPaint
java.awt.RadialGradientPaint
All Implemented Interfaces:
Paint
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 inbetween 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 radius of the circle will cause
the rings of the gradient pattern to be centered on the point just inside
the edge of the circle in the direction of the focus point.
The rendering will internally use this modified location as if it were
the specified focus point.
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} object
takes when it is filling the space outside the circle's radius by
setting {@code CycleMethod} to either {@code REFLECTION} or {@code REPEAT}.
The gradient color proportions are equal for any particular line drawn
from the focus point. The following figure shows that the distance AB
is equal to the distance BC, and the distance AD is equal to the distance DE.
If the gradient and graphics rendering transforms are uniformly scaled and
the user sets the focus so that it coincides with the center of the circle,
the gradient color proportions are equal for any line drawn from the center.
The following figure shows the distances AB, BC, AD, and DE. They are all equal.
Note that some minor variations in distances may occur due to sampling at
the granularity of a pixel.
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 noncentered 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 noncentered
focus for each of the three cycle methods:
Also see:
 java.awt.Paint
 java.awt.Graphics2D#setPaint
 author:
Nicholas
 Talian, Vincent Hardy, Jim Graham, Jerry Evans
 since:
1.6

Fields inherited from java.awt.MultipleGradientPaint: 

transparency, fractions, colors, gradientTransform, cycleMethod, colorSpace, model, normalizedIntervals, isSimpleLookup, gradients, gradient, fastGradientArraySize 
Constructor: 
public RadialGradientPaint(Point2D center,
float radius,
float[] fractions,
Color[] colors) {
this(center,
radius,
center,
fractions,
colors,
CycleMethod.NO_CYCLE);
} Constructs a {@code RadialGradientPaint} with a default
{@code NO_CYCLE} repeating method and {@code SRGB} color space,
using the center as the focus point. Parameters:
center  the center point, in user space, of the circle defining
the gradient
radius  the radius of the circle defining the extents of the
color gradient
fractions  numbers ranging from 0.0 to 1.0 specifying the
distribution of colors along the gradient
colors  array of colors to use in the gradient. The first color
is used at the focus point, the last color around the
perimeter of the circle.
Throws:
NullPointerException 
if {@code center} point is null,
or {@code fractions} array is null,
or {@code colors} array is null
IllegalArgumentException 
if {@code radius} is nonpositive,
or {@code fractions.length != colors.length},
or {@code colors} is less than 2 in size,
or a {@code fractions} value is less than 0.0 or greater than 1.0,
or the {@code fractions} are not provided in strictly increasing order

public RadialGradientPaint(Rectangle2D gradientBounds,
float[] fractions,
Color[] colors,
CycleMethod cycleMethod) {
// 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 " +
"nonempty");
}
} 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);
Parameters:
gradientBounds  the bounding box, in user space, of the circle
defining the outermost extent of the gradient
fractions  numbers ranging from 0.0 to 1.0 specifying the
distribution of colors along the gradient
colors  array of colors to use in the gradient. The first color
is used at the focus point, the last color around the
perimeter of the circle.
cycleMethod  either {@code NO_CYCLE}, {@code REFLECT},
or {@code REPEAT}
Throws:
NullPointerException 
if {@code gradientBounds} is null,
or {@code fractions} array is null,
or {@code colors} array is null,
or {@code cycleMethod} is null
IllegalArgumentException 
if {@code gradientBounds} is empty,
or {@code fractions.length != colors.length},
or {@code colors} is less than 2 in size,
or a {@code fractions} value is less than 0.0 or greater than 1.0,
or the {@code fractions} are not provided in strictly increasing order

public RadialGradientPaint(float cx,
float cy,
float radius,
float[] fractions,
Color[] colors) {
this(cx, cy,
radius,
cx, cy,
fractions,
colors,
CycleMethod.NO_CYCLE);
} Constructs a {@code RadialGradientPaint} with a default
{@code NO_CYCLE} repeating method and {@code SRGB} color space,
using the center as the focus point. Parameters:
cx  the X coordinate in user space of the center point of the
circle defining the gradient. The last color of the
gradient is mapped to the perimeter of this circle.
cy  the Y coordinate in user space of the center point of the
circle defining the gradient. The last color of the
gradient is mapped to the perimeter of this circle.
radius  the radius of the circle defining the extents of the
color gradient
fractions  numbers ranging from 0.0 to 1.0 specifying the
distribution of colors along the gradient
colors  array of colors to use in the gradient. The first color
is used at the focus point, the last color around the
perimeter of the circle.
Throws:
NullPointerException 
if {@code fractions} array is null,
or {@code colors} array is null
IllegalArgumentException 
if {@code radius} is nonpositive,
or {@code fractions.length != colors.length},
or {@code colors} is less than 2 in size,
or a {@code fractions} value is less than 0.0 or greater than 1.0,
or the {@code fractions} are not provided in strictly increasing order

public RadialGradientPaint(Point2D center,
float radius,
float[] fractions,
Color[] colors,
CycleMethod cycleMethod) {
this(center,
radius,
center,
fractions,
colors,
cycleMethod);
} Constructs a {@code RadialGradientPaint} with a default
{@code SRGB} color space, using the center as the focus point. Parameters:
center  the center point, in user space, of the circle defining
the gradient
radius  the radius of the circle defining the extents of the
color gradient
fractions  numbers ranging from 0.0 to 1.0 specifying the
distribution of colors along the gradient
colors  array of colors to use in the gradient. The first color
is used at the focus point, the last color around the
perimeter of the circle.
cycleMethod  either {@code NO_CYCLE}, {@code REFLECT},
or {@code REPEAT}
Throws:
NullPointerException 
if {@code center} point is null,
or {@code fractions} array is null,
or {@code colors} array is null,
or {@code cycleMethod} is null
IllegalArgumentException 
if {@code radius} is nonpositive,
or {@code fractions.length != colors.length},
or {@code colors} is less than 2 in size,
or a {@code fractions} value is less than 0.0 or greater than 1.0,
or the {@code fractions} are not provided in strictly increasing order

public RadialGradientPaint(float cx,
float cy,
float radius,
float[] fractions,
Color[] colors,
CycleMethod cycleMethod) {
this(cx, cy,
radius,
cx, cy,
fractions,
colors,
cycleMethod);
} Constructs a {@code RadialGradientPaint} with a default
{@code SRGB} color space, using the center as the focus point. Parameters:
cx  the X coordinate in user space of the center point of the
circle defining the gradient. The last color of the
gradient is mapped to the perimeter of this circle.
cy  the Y coordinate in user space of the center point of the
circle defining the gradient. The last color of the
gradient is mapped to the perimeter of this circle.
radius  the radius of the circle defining the extents of the
color gradient
fractions  numbers ranging from 0.0 to 1.0 specifying the
distribution of colors along the gradient
colors  array of colors to use in the gradient. The first color
is used at the focus point, the last color around the
perimeter of the circle.
cycleMethod  either {@code NO_CYCLE}, {@code REFLECT},
or {@code REPEAT}
Throws:
NullPointerException 
if {@code fractions} array is null,
or {@code colors} array is null,
or {@code cycleMethod} is null
IllegalArgumentException 
if {@code radius} is nonpositive,
or {@code fractions.length != colors.length},
or {@code colors} is less than 2 in size,
or a {@code fractions} value is less than 0.0 or greater than 1.0,
or the {@code fractions} are not provided in strictly increasing order

public RadialGradientPaint(Point2D center,
float radius,
Point2D focus,
float[] fractions,
Color[] colors,
CycleMethod cycleMethod) {
this(center,
radius,
focus,
fractions,
colors,
cycleMethod,
ColorSpaceType.SRGB,
new AffineTransform());
} Constructs a {@code RadialGradientPaint} with a default
{@code SRGB} color space. Parameters:
center  the center point, in user space, of the circle defining
the gradient. The last color of the gradient is mapped
to the perimeter of this circle.
radius  the radius of the circle defining the extents of the color
gradient
focus  the point in user space to which the first color is mapped
fractions  numbers ranging from 0.0 to 1.0 specifying the
distribution of colors along the gradient
colors  array of colors to use in the gradient. The first color
is used at the focus point, the last color around the
perimeter of the circle.
cycleMethod  either {@code NO_CYCLE}, {@code REFLECT},
or {@code REPEAT}
Throws:
NullPointerException 
if one of the points is null,
or {@code fractions} array is null,
or {@code colors} array is null,
or {@code cycleMethod} is null
IllegalArgumentException 
if {@code radius} is nonpositive,
or {@code fractions.length != colors.length},
or {@code colors} is less than 2 in size,
or a {@code fractions} value is less than 0.0 or greater than 1.0,
or the {@code fractions} are not provided in strictly increasing order

public RadialGradientPaint(float cx,
float cy,
float radius,
float fx,
float fy,
float[] fractions,
Color[] colors,
CycleMethod cycleMethod) {
this(new Point2D.Float(cx, cy),
radius,
new Point2D.Float(fx, fy),
fractions,
colors,
cycleMethod);
} Constructs a {@code RadialGradientPaint} with a default
{@code SRGB} color space. Parameters:
cx  the X coordinate in user space of the center point of the
circle defining the gradient. The last color of the
gradient is mapped to the perimeter of this circle.
cy  the Y coordinate in user space of the center point of the
circle defining the gradient. The last color of the
gradient is mapped to the perimeter of this circle.
radius  the radius of the circle defining the extents of the
color gradient
fx  the X coordinate of the point in user space to which the
first color is mapped
fy  the Y coordinate of the point in user space to which the
first color is mapped
fractions  numbers ranging from 0.0 to 1.0 specifying the
distribution of colors along the gradient
colors  array of colors to use in the gradient. The first color
is used at the focus point, the last color around the
perimeter of the circle.
cycleMethod  either {@code NO_CYCLE}, {@code REFLECT},
or {@code REPEAT}
Throws:
NullPointerException 
if {@code fractions} array is null,
or {@code colors} array is null,
or {@code cycleMethod} is null
IllegalArgumentException 
if {@code radius} is nonpositive,
or {@code fractions.length != colors.length},
or {@code colors} is less than 2 in size,
or a {@code fractions} value is less than 0.0 or greater than 1.0,
or the {@code fractions} are not provided in strictly increasing order

public RadialGradientPaint(Point2D center,
float radius,
Point2D focus,
float[] fractions,
Color[] colors,
CycleMethod cycleMethod,
ColorSpaceType colorSpace,
AffineTransform gradientTransform) {
super(fractions, colors, cycleMethod, colorSpace, gradientTransform);
// check input arguments
if (center == null) {
throw new NullPointerException("Center point must be nonnull");
}
if (focus == null) {
throw new NullPointerException("Focus point must be nonnull");
}
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;
} Constructs a {@code RadialGradientPaint}. Parameters:
center  the center point in user space of the circle defining the
gradient. The last color of the gradient is mapped to
the perimeter of this circle.
radius  the radius of the circle defining the extents of the
color gradient
focus  the point in user space to which the first color is mapped
fractions  numbers ranging from 0.0 to 1.0 specifying the
distribution of colors along the gradient
colors  array of colors to use in the gradient. The first color
is used at the focus point, the last color around the
perimeter of the circle.
cycleMethod  either {@code NO_CYCLE}, {@code REFLECT},
or {@code REPEAT}
colorSpace  which color space to use for interpolation,
either {@code SRGB} or {@code LINEAR_RGB}
gradientTransform  transform to apply to the gradient
Throws:
NullPointerException 
if one of the points is null,
or {@code fractions} array is null,
or {@code colors} array is null,
or {@code cycleMethod} is null,
or {@code colorSpace} is null,
or {@code gradientTransform} is null
IllegalArgumentException 
if {@code radius} is nonpositive,
or {@code fractions.length != colors.length},
or {@code colors} is less than 2 in size,
or a {@code fractions} value is less than 0.0 or greater than 1.0,
or the {@code fractions} are not provided in strictly increasing order

Methods from java.lang.Object: 

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait 
Method from java.awt.RadialGradientPaint Detail: 
public PaintContext createContext(ColorModel cm,
Rectangle deviceBounds,
Rectangle2D userBounds,
AffineTransform transform,
RenderingHints hints) {
// 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);
} Creates and returns a PaintContext used to
generate a circular radial color gradient pattern.
See the description of the createContext method
for information on null parameter handling. 
public Point2D getCenterPoint() {
return new Point2D.Double(center.getX(), center.getY());
} Returns a copy of the center point of the radial gradient. 
public Point2D getFocusPoint() {
return new Point2D.Double(focus.getX(), focus.getY());
} Returns a copy of the focus point of the radial gradient.
Note that if the focus point specified when the radial gradient
was constructed lies outside of the radius of the circle, this
method will still return the original focus point even though
the rendering may center the rings of color on a different
point that lies inside the radius. 
public float getRadius() {
return radius;
} Returns the radius of the circle defining the radial gradient. 