Help converting my class to Paint

Question

A while back I wrote this class, ColorGradient (see below)
Before you start telling me about GradientPaint, this class is pretty different from GradientPaint - it handles multiple colors, and it doesn't cycle (last color goes on forever)
The way I built it at the time was to extend BufferedImage and draw on that. I got critique at the time suggesting that I should detach it from being a BufferedImage; I agree, it would be great if I could turn this class into a Paint, where here is no Image, just basically the algorithm for creating a multicolor color gradient.
From what I know, it seems like creating my own implementation of Paint could be the way to go. Looking into this, it isn't Paint that confuses me so much as how to create a SampleModel and a Raster. I just took a stab at creating a SampleModel - it seems like I've got to give it a width and a height, which I already didn't want to do.
Anyone have any experience with this, or advice about the best way to decouple the painting algorithm from a BufferedImage?
* Created on Jun 14, 2006 by @author Tom Jacobs
package tjacobs.ui.ex;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Point;
import java.awt.Polygon;
import java.awt.Rectangle;
import java.awt.Window;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.ComponentAdapter;
import java.awt.event.ComponentEvent;
import java.awt.event.MouseListener;
import java.awt.image.BufferedImage;
import javax.swing.JComponent;
import javax.swing.JMenu;
import javax.swing.JMenuItem;
import javax.swing.JPanel;
import javax.swing.JPopupMenu;
import tjacobs.MathUtils;
import tjacobs.print.StandardPrint;
import tjacobs.ui.drag.Draggable;
import tjacobs.ui.shape.PolygonFactory;
import tjacobs.ui.util.WindowUtilities;
public class ColorGradient extends BufferedImage {
     private Color[] mColors;
     private double mSpan;
     private Point mCenter;
     private int mOrientation;
     private boolean mAutoRender = false;
     private boolean mOptimized;
     private int[] mDrawColors;
     public static final int BOTH_EUCLID = 0;
     public static final int HORIZONTAL = 1;
     public static final int VERTICAL = 2;
     public static final int BOTH_MANHATTAN = 3;
     public ColorGradient(int width, int height) {
          super(width, height, BufferedImage.TYPE_INT_RGB);
          setSpan(MathUtils.distance(width, height) / 7);
          setCenter(0,0);
          setOrientation(BOTH_EUCLID);
          setColors(getROYGBIV());
          render();
          mAutoRender = true;
     public void setAutoRender(boolean b) {
          mAutoRender = b;
     public boolean getAutoRender() {
          return mAutoRender;
     public ColorGradient(int width, int height, boolean autoRender) {
          this(width, height);
          mAutoRender = autoRender;
      * sets the span of the color gradient
     public void setSpan(double d) {
          mSpan = d;
          if (mAutoRender) {
               render();
     public double getSpan() {
          return mSpan;
      * sets the center of the color gradient. Default is 0,0
     public void setCenter(int x, int y) {
          if (mCenter == null) {
               mCenter = new Point(x,y);
          else {
               mCenter.x = x; mCenter.y = y;
          if (mAutoRender) render();
     public Point getCenter() {
          return mCenter;
      * sets the colors to use in the color gradient. Default is ROYGBIV
     public void setColors(Color[] colors) {
          mColors = colors;
          if (mAutoRender) render();
     public Color[] getColors() {
          return mColors;
     public int getOrientation() {
          return mOrientation;
      * sets the orientation of the gradient in case you want a gradient
      * just in one direction. default is both directions
     public void setOrientation(int orientation) {
          mOrientation = orientation;
          if (mAutoRender) render();
     protected double getScore(int CenterX, int CenterY, int x2, int y2) {
          double distance = 0;
          if (mOrientation == BOTH_EUCLID) {
                distance = MathUtils.distance(CenterX, CenterY, x2, y2);
          else if (mOrientation == BOTH_MANHATTAN) {
               distance = (Math.abs(CenterX - x2) + Math.abs(CenterY - y2)) / 2;
          else if (mOrientation == HORIZONTAL) {
               distance = Math.abs(CenterX - x2);
          else {
               distance = Math.abs(CenterY - y2);
          return distance;
     public void renderMoveCenter(int x1, int y1, int x2, int y2) {
          if (mColors == null) {
               return;
          int width = getWidth();
          int height = getHeight();
          int x = mCenter.x;
          int y = mCenter.y;
          float parts1[] = new float[3], parts2[] = new float[3], partsEnd[] = new float[3];
          int xDiff = x2 - x1;
          int yDiff = y2 - y1;
          int absXDiff = xDiff, absYDiff = yDiff;
          if (absXDiff < 0) absXDiff = -absXDiff;
          if (absYDiff < 0) absYDiff = -absYDiff;
          if (xDiff >= 0) {
               for (int i = width - 1; i < width - absXDiff ; i--) {
                    if (yDiff >= 0) {
                         for (int j = height - 1; j < height -absYDiff; j--) {
          else {
               for (int i = 0; i < width - absXDiff ; i++) {
          for (int i = 0; i < width - absXDiff ; i++) {
               for (int j = 0; j < height - absYDiff; j++) {
                    double distance;
                    double seg;
                    int low;
                    int high;
                    distance = getScore(x, y, i, j);
                    seg = distance / mSpan;
                    low = (int) seg;
                    high = low + 1;
                    if (low >= mColors.length) {
                         low = mColors.length - 1;
                         high = low;
                    if (high >= mColors.length) {
                         high = mColors.length - 1;
                    float lowPart = (float) seg - low ;
                    mColors[low].getColorComponents(parts1);
                    mColors[high].getColorComponents(parts2);
                    float hipart = (1 - lowPart);
                    for (int k = 0; k < 3; k++) {
                         partsEnd[k] = parts2[k] * lowPart + parts1[k] * hipart;
                    int rgb = (((int) (partsEnd[0]*255+0.5)) & 0xff) << 16 |
                    (((int) (partsEnd[1]*255+0.5)) & 0xff) << 8 |
                    (((int) (partsEnd[2]*255+0.5)) & 0xff);
                    super.setRGB(i, j, rgb);
     public void render() {
          if (mColors == null) {
               return;
          int width = getWidth();
          int height = getHeight();
          int x = mCenter.x;
          int y = mCenter.y;
          if (!mOptimized) {
               float parts1[] = new float[3], parts2[] = new float[3], partsEnd[] = new float[3];
               for (int i = 0; i < width; i++) {
                    for (int j = 0; j < height; j++) {
                         double distance = getScore(x, y, i, j);
                         double seg = distance / mSpan;
                         int low = (int) seg;
                         int high = low + 1;
                         if (low >= mColors.length) {
                              low = mColors.length - 1;
                              high = low;
                         if (high >= mColors.length) {
                              high = mColors.length - 1;
                         float lowPart = (float) seg - low ;
                         mColors[low].getColorComponents(parts1);
                         mColors[high].getColorComponents(parts2);
                         float hipart = (1 - lowPart);
                         for (int k = 0; k < 3; k++) {
                              partsEnd[k] = parts2[k] * lowPart + parts1[k] * hipart;
                         int rgb = (((int) (partsEnd[0]*255+0.5)) & 0xff) << 16 |
                         (((int) (partsEnd[1]*255+0.5)) & 0xff) << 8 |
                         (((int) (partsEnd[2]*255+0.5)) & 0xff);
                         super.setRGB(i, j, rgb);
          } else {
               for (int i = 0; i < width; i++) {
                    for (int j = 0; j < height; j++) {
                         int distance = (int)Math.round(getScore(x, y, i, j));
                         if (distance >= mDrawColors.length) {
                              distance = mDrawColors.length - 1;
                         setRGB(i, j, mDrawColors[distance]);
     public static Color[] getROYGBIV() {
          return new Color[] {Color.RED, Color.ORANGE, Color.YELLOW,
                                   Color.GREEN, Color.BLUE,
                                   new Color(75, 0, 130), Color.MAGENTA};
     public static class GradientPane extends JComponent {
          private static final long serialVersionUID = 0;
          private ColorGradient mGradient;
          private JPopupMenu mPopup;
          private MouseListener mPopupListener;
          public class ReportColorMenuItem extends ColorMenuItem {
               private static final long serialVersionUID = 0;
               public ReportColorMenuItem(Color c) {
                    super(c);
               public ReportColorMenuItem(Color c, boolean addListener) {
                    super(c, addListener);
               public void setColor(Color c) {
                    super.setColor(c);
                    updateColorsFromPopup();
          public GradientPane(int width, int height) {
               setSize(width, height);
               setPreferredSize(new Dimension(width, height));
               mGradient = new ColorGradient(width, height);
               mGradient.render();
          public ColorGradient getGradient() {
               return mGradient;
          private void updateColorsFromPopup() {
               Color[] colors = new Color[mPopup.getComponentCount() - 2];
               for (int i = 0; i < colors.length; i++) {
                    colors[i] = ((ColorMenuItem)mPopup.getComponent(i)).getColor();
               getGradient().setColors(colors);
               if (!getGradient().getAutoRender()) {
                    getGradient().render();
               repaint();
          public void useColorSelectorPopup(boolean b) {
               if (b && mPopup == null) {
                    mPopup = new JPopupMenu();
                    ColorGradient grad = getGradient();
                    Color[] colors = grad.getColors();
                    for (int i = 0; i < colors.length; i++) {
                         mPopup.add(new ReportColorMenuItem(colors));
                    final JMenu remove = new JMenu("Remove");
                    ActionListener al = new ActionListener() {
                         public void actionPerformed(ActionEvent ae) {
                              //int num = Integer.parseInt(ae.getActionCommand());
                              int num = -1;
                              Object src = ae.getSource();
                              for (int i = 0; i < remove.getMenuComponentCount(); i++) {
                                   if (remove.getMenuComponent(i) == src) {
                                        num = i;
                                        break;
                              if (num == -1) {
                                   System.out.println("Trouble");
                              getGradient().removeColor(num);
                              repaint();
                              mPopup.remove(num);
                              remove.remove(num);
                    for (int i = 0; i < colors.length; i++) {
                         JMenuItem item = new ColorMenuItem(colors[i], false);
                         item.setActionCommand(String.valueOf(i));
                         item.addActionListener(al);
                         remove.add(item);
                    JMenuItem add = new JMenuItem("Add");
                    add.addActionListener(new ActionListener() {
                         public void actionPerformed(ActionEvent ae) {
                              JMenuItem src = (JMenuItem) ae.getSource();
                              mPopup.remove(src);
                              mPopup.remove(remove);
                              Color toAdd = Color.WHITE;
                              mPopup.add(new ReportColorMenuItem(toAdd));
                              ColorGradient cg = getGradient();
                              cg.addColor(toAdd);
                              if (!cg.getAutoRender()) {
                                   cg.render();
                              mPopup.add(src);
                              mPopup.add(remove);
                              remove.add(new ReportColorMenuItem(toAdd, false));
                              repaint();
                    mPopup.add(add);
                    mPopup.add(remove);
                    mPopupListener = WindowUtilities.addAsPopup(mPopup, this);
               else if (!b && mPopup != null) {
                    mPopup = null;
                    removeMouseListener(mPopupListener);
                    mPopupListener = null;
          public void paintComponent(Graphics g) {
               g.drawImage(mGradient, 0, 0, null);
     public void addColor(Color c) {
          Color[] nc = new Color[mColors.length + 1];
          for (int i = 0; i < mColors.length; i++) {
               nc[i] = mColors[i];
          nc[nc.length - 1] = c;
          mColors = nc;
          render();
     public void removeColor(int colorNum) {
          Color[] nc = new Color[mColors.length -1];
          for (int i = 0; i < mColors.length - 1; i++) {
               nc[i] = mColors[i < colorNum ? i : i + 1];
          mColors = nc;
          render();
     public void setOptimized(boolean b) {
          mOptimized = b;
          if (b) {
               int maxDistance = (int) MathUtils.distance(getWidth(), getHeight()) + 1;
               mDrawColors = new int[maxDistance];
               float[] parts1 = new float[3], parts2 = new float[3], partsEnd = new float[3];
               for (int distance = 0; distance < maxDistance; distance++) {
                    double seg = distance / mSpan;
                    int low = (int) seg;
                    int high = low + 1;
                    if (low >= mColors.length) {
                         low = mColors.length - 1;
                         high = low;
                    if (high >= mColors.length) {
                         high = mColors.length - 1;
                    float lowPart = (float) seg - low ;
                    mColors[low].getColorComponents(parts1);
                    mColors[high].getColorComponents(parts2);
                    float hipart = (1 - lowPart);
                    for (int k = 0; k < 3; k++) {
                         partsEnd[k] = parts2[k] * lowPart + parts1[k] * hipart;
                    int rgb = (((int) (partsEnd[0]*255+0.5)) & 0xff) << 16 |
          (((int) (partsEnd[1]*255+0.5)) & 0xff) << 8 |
          (((int) (partsEnd[2]*255+0.5)) & 0xff);
                    mDrawColors[distance] = rgb;
                    //super.setRGB(i, j, rgb);               
          else {
               mDrawColors = null;
     public static void main(String args[]) {
          final GradientPane gp = new GradientPane(800, 800);
          gp.getGradient().setOptimized(true);
          CreatePopupWindow cpw = new CreatePopupWindow() {
               public Window createPopupWindow(Point p) {
                    //ParamDialog pd = new ParamDialog((JFrame)SwingUtilities.windowForComponent(gp), new String[] {"Center", "Colors", "Orientation", "Span"});
                    //JDialog pd = new JDialog((JFrame)SwingUtilities.windowForComponent(gp));
                    //pd.setDefaultCloseOperation(pd.DISPOSE_ON_CLOSE);
                    JWindow pd = new JWindow();
                    pd.add(new JLabel("Hello"));
                    //PopupFactory fac = PopupFactory.getSharedInstance();
                    //Popup pd = fac.getPopup(gp, new JLabel("Hello"), p.x, p.y);
                    return pd;
          gp.useColorSelectorPopup(true);
          //gp.setPreferredSize(new Dimension(200, 200));
          //gp.getGradient().setCenter(100,100);
          final JPanel handle = new JPanel();
          handle.setSize(5,5);
          handle.setLocation(10,10);
          handle.setBackground(Color.PINK);
          handle.addComponentListener(new ComponentAdapter() {
               public void componentMoved(ComponentEvent ev) {
                    gp.getGradient().setCenter(handle.getX(), handle.getY());
                    gp.repaint();
          gp.setLayout(null);
          new Draggable(handle);
          gp.add(handle);
          Dimension d = new Dimension(800,800);
          gp.setPreferredSize(d);
          gp.setSize(d);
          WindowUtilities.visualize(gp);
          GradientPane gp2 = new GradientPane(200,200);
          gp2.getGradient().setOrientation(HORIZONTAL);
          WindowUtilities.visualize(gp2);
          GradientPane gp3 = new GradientPane(200,200);
          gp3.getGradient().setOrientation(VERTICAL);
          GradientPane gp4 = new GradientPane(200,200);
          gp4.getGradient().setOrientation(BOTH_MANHATTAN);
          Window w3 = WindowUtilities.visualize(gp3);
          WindowUtilities.visualize(gp4);
          final Polygon gon = PolygonFactory.createPolygon(6, 0, new Rectangle(0,0,200,200));
          GradientPane gp5 = new GradientPane(200,200) {
               public void paintComponent(Graphics g) {
                    g.setClip(gon);
                    super.paintComponent(g);
          WindowUtilities.visualize(gp5);
          //StandardPrint sp1 = new StandardPrint(gp);
          //StandardPrint sp2 = new StandardPrint(w3);
          //WindowUtilities.visualize(StandardPrint.preview(200, 200, sp1, sp1.getPageFormat(0), 0));
          //WindowUtilities.visualize(StandardPrint.preview(200, 200, sp2, sp2.getPageFormat(0), 0));          
          WindowUtilities.setWindowCloseOnEscape(true);

Answer 1

Okay I have solved this, kind of.
I changed ColorGradient so that rather than extending BufferedImage it has a BufferedImage member (mIm)
then I added the following to get a Paint object from it. Hopefully this will prove a useful example to someone in the future :)
     public Paint getMyPaint() {
          return new MyPaint();
     public class MyPaint extends TexturePaint {
          TexturePaint mTP;
          public MyPaint() {
               super(ColorGradient.this.getImage(), new Rectangle(0, 0, mIm.getWidth(null), mIm.getHeight(null)));
               mTP = this;
          public PaintContext createContext(ColorModel cm,Rectangle deviceBounds, Rectangle2D userBounds, AffineTransform xform, RenderingHints hints) {
               //System.out.println("Create context: db: " + deviceBounds + " ub: " + userBounds);
               //picking userBounds arbitrarily
               if (userBounds.getWidth() > mIm.getWidth() || userBounds.getHeight() > mIm.getHeight()) {
                    mIm = new BufferedImage((int)Math.max(mIm.getWidth(), userBounds.getWidth()), (int) Math.max(mIm.getHeight(), userBounds.getHeight()), BufferedImage.TYPE_INT_RGB);
                    mTP = new TexturePaint(ColorGradient.this.getImage(), new Rectangle(0, 0, mIm.getWidth(null), mIm.getHeight(null)));
               setCenter((int) userBounds.getWidth() / 2, (int) userBounds.getHeight() / 2);
               render();
               if (mTP == this) return super.createContext(cm, deviceBounds, userBounds, xform, hints);
               return mTP.createContext(cm, deviceBounds, userBounds, xform, hints);
     }