Learn to Make Paint
by Jonathan Knudsen

The 2D API, in JDK 1.2, introduces the concept of paint. Paint is stuff you can use to fill shapes and text. Before the 2D API, you could only fill shapes and text with solid colors. Now, you can use any class that implements the java.awt.Paint interface.

The 2D API offers three options:

• java.awt.Color represents solid colors.
• java.awt.GradientPaint represents a linear color gradient. This kind of gradient fades evenly from one color at a point to a second color at another point. In the late evening on a clear day, the sky has a gradient from dark blue at the horizon to black overhead.
• java.awt.TexturePaint is a kind of paint made by repeating an image over and over, like kitchen floor tiles.

To use one of these paints, just create it and give it to setPaint() on your Graphics2D. Any shapes or text that you render subsequently will use the new paint. To draw text in blue, for example, do this in a paint() method:

g2.setPaint(Color.blue);
g2.drawString("Hello", 50, 50);

The 2D API's predefined paints are pretty cool. But you can write your own, too. In this column I'll develop a radial gradient paint. A radial gradient defines a color at a point; the gradient blends into another color as a function of the distance from that point. The end result is a big, fuzzy spot.

Under the hood

Paint is a subinterface of Transparency, which describes the transparency mode of an object. The Paint interface itself has only one method -- it just knows how to generate a PaintContext:

public PaintContext createContext(ColorModel cm, Rectangle deviceBounds, Rectangle2D userBounds, AffineTransform xform, RenderingHints hints)

This method is called to create a PaintContext. The PaintContext is encouraged to produce colors in the given color model. The deviceBounds rectangle indicates the bounds of the drawing surface, while userBounds indicates the bounds of the shape that is being filled. The supplied AffineTransform indicates the transformation currently in effect, while hints contains information that the PaintContext can use to modify its behavior. The TexturePaint context, for example, is responsive to the KEY_INTERPOLATION hint.

The PaintContext returned by createContext() knows how to actually generate the colors of the Paint. The PaintContext interface defines three methods:

public void dispose()

This method is called when the PaintContext is no longer needed. If you've allocated any images or other large objects, you can free up their references in this method.

This method returns the color model that will be used for this context's output. This could be a different color model than the one suggested in the createContext() method, back in the Paint interface.

This is the mother lode of the PaintContext interface. This method returns a Raster which contains the color data that should be used to fill a shape. (The Raster class is part of 2D's image classes.)

The RoundGradientPaint Class

import java.awt.*;
import java.awt.geom.*;
import java.awt.image.ColorModel;

public class RoundGradientPaint
    implements Paint {
  protected Point2D mPoint;
  protected double mRadius;
  protected Color mPointColor, mBackgroundColor;

  public RoundGradientPaint(double x, double y, Color pointColor,
      double radius, Color backgroundColor) {
    mPoint = new Point2D.Double(x, y);
    mPointColor = pointColor;
    mRadius = radius;
    mBackgroundColor = backgroundColor;
  }

  public PaintContext createContext(ColorModel cm,
      Rectangle deviceBounds, Rectangle2D userBounds,
      AffineTransform xform, RenderingHints hints) {
    Point2D transformedPoint = xform.transform(mPoint, null);
    return new RoundGradientContext(transformedPoint, mPointColor,
        mRadius, mBackgroundColor);
  }

  public int getTransparency() {
    int a1 = mPointColor.getAlpha();
    int a2 = mBackgroundColor.getAlpha();
    return (((a1 & a2) == 0xff) ? OPAQUE : TRANSLUCENT);
  }
}

The getTransparency() method, from the Transparency interface, returns either OPAQUE or TRANSLUCENT, depending on the colors that were passed to RoundGradientPaint's constructor. If both colors are opaque, then the RoundGradientPaint is opaque too. Otherwise it is translucent, which means it may color pixels with arbitrary alpha values.

The RoundGradientContext Class

    WritableRaster raster =
        getColorModel().createCompatibleWritableRaster(w, h);

Then this method iterates over each point in the requested rectangle, calculating the distance from the center point. It calculates a weighting factor, from 0.0 to 1.0, based on the ratio of this distance and the radius:

    for (int j = 0; j < h; j++) {
      for (int i = 0; i < w; i++) {
        double distance = mPoint.distance(x + i, y + j);
        double ratio = distance / mRadius;
        if (ratio < 1.0)
          ratio = 1.0;

Then it simply uses the weighting factor to linearly interpolate between the center color and the background color:

        data[base + 0] = (int)(mC1.getRed() + ratio *
            (mC2.getRed() - mC1.getRed()));
        data[base + 1] = (int)(mC1.getGreen() + ratio *
            (mC2.getGreen() - mC1.getGreen()));
        data[base + 2] = (int)(mC1.getBlue() + ratio *
            (mC2.getBlue() - mC1.getBlue()));
        data[base + 3] = (int)(mC1.getAlpha() + ratio *
            (mC2.getAlpha() - mC1.getAlpha()));

The data is written into an array of integers. Each pixel is stored in four array elements, corresponding to red, green, blue, and alpha. When all the data has been written, the array is assigned to the WritableRaster as follows:

    raster.setPixels(0, 0, w, h, data);

Here's the entire class:

import java.awt.*;
import java.awt.geom.*;
import java.awt.image.*;
class RoundGradientContext
    implements PaintContext {
  protected Point2D mPoint;
  protected double mRadius;
  protected Color mC1, mC2;

  public RoundGradientContext(Point2D p, Color c1, double r, Color c2) {
    mPoint = p;
    mC1 = c1;
    mRadius = r;
    mC2 = c2;
  }

  public void dispose() {}

  public ColorModel getColorModel() { return ColorModel.getRGBdefault(); }

  public Raster getRaster(int x, int y, int w, int h) {
    WritableRaster raster =
        getColorModel().createCompatibleWritableRaster(w, h);

    int[] data = new int[w * h * 4];
    for (int j = 0; j < h; j++) {
      for (int i = 0; i < w; i++) {
        double distance = mPoint.distance(x + i, y + j);
        double ratio = distance / mRadius;
        if (ratio < 1.0)
          ratio = 1.0;

        int base = (j * w + i) * 4;
        data[base + 0] = (int)(mC1.getRed() + ratio *
            (mC2.getRed() - mC1.getRed()));
        data[base + 1] = (int)(mC1.getGreen() + ratio *
            (mC2.getGreen() - mC1.getGreen()));
        data[base + 2] = (int)(mC1.getBlue() + ratio *
            (mC2.getBlue() - mC1.getBlue()));
        data[base + 3] = (int)(mC1.getAlpha() + ratio *
            (mC2.getAlpha() - mC1.getAlpha()));
      }
    }
    raster.setPixels(0, 0, w, h, data);
    return raster;
  }
}

Testing it Out

import java.awt.*;
import java.awt.event.*;
import java.awt.geom.*;

public class RoundGradientTestFrame
    extends Frame {
  public static void main(String[] args) {
    Frame f = new RoundGradientTestFrame();
    f.setTitle("RoundGradientPaintFill v1.0");
    f.setSize(200, 200);
    f.setLocation(200, 200);
    f.addWindowListener(new WindowAdapter() {
      public void windowClosing(WindowEvent we) {
        System.exit(0);
      }
    });
    f.setVisible(true);
  }
  
  public void paint(Graphics g) {
    Graphics2D g2 = (Graphics2D)g;
    RoundRectangle2D r = new RoundRectangle2D.Float(25, 35, 150, 150, 25, 25);
    RoundGradientPaint rgp = new RoundGradientPaint(75, 75, Color.yellow,
        85, Color.red);
    g2.setPaint(rgp);
    g2.fill(r);
  }
}

Most of the class has to do with plumbing -- setting up a Frame. The fun stuff is in the paint() method. A RoundGradientPaint is created and used to fill a round rectangle. Once you've done the work of writing RoundGradientPaint, it's very easy to use.

Download the source code.

Return to: java.oreilly.com