Paint from a paint(Component) method? Is it possible?

Question

Hi all
Here's my deal: I'd like to make a Paint (http://java.sun.com/javase/6/docs/api/java/awt/Paint.html) out of a component or even better, just something with a paint(Graphics) method. I looked into implementing my own Paint, but it looks very foreboding, esp the requirement to be able to get the Raster in the PaintContext object which I think I'd have to implement too.
Any advice?

Answer 1

Here's my attempt at it...
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Paint;
import java.awt.PaintContext;
import java.awt.Rectangle;
import java.awt.RenderingHints;
import java.awt.geom.AffineTransform;
import java.awt.geom.Rectangle2D;
import java.awt.image.BufferedImage;
import java.awt.image.ColorModel;
import java.awt.image.Raster;
import javax.swing.JComponent;
import javax.swing.JFrame;
import java.lang.reflect.Method;
public class ImagePaint implements Paint {
    Object paintable;
    Method paintMethod;
    BufferedImage paint;
    public ImagePaint(Object paintable) {
        this.paintable = paintable;
        try{
            paintMethod =
                    paintable.getClass().getMethod("paint",Graphics.class);
        }catch(java.lang.NoSuchMethodException e) {
            throw new IllegalArgumentException("Paintable object does " +
                    "not have paint method!");
    public java.awt.PaintContext createContext(ColorModel cm,
                                               Rectangle deviceBounds,
                                               Rectangle2D userBounds,
                                               AffineTransform xform,
                                               RenderingHints hints) {
        /*the bounds being passed to this method is the bounding rectangle
         *of the shape being filled or drawn*/
       paint = new BufferedImage(deviceBounds.width,
                                 deviceBounds.height,
                                 BufferedImage.TYPE_3BYTE_BGR);
           /*note: if translucent/transparent colors are used in the
            *paintable object's "paint" method then the BufferedImage
            *type will need to be different*/
        Graphics2D g = paint.createGraphics();
            /*set the clip size so the paintable object knows the
             *size of the image/shape they are dealing with*/
        g.setClip(0,0,paint.getWidth(),paint.getHeight());
        //call on the paintable object to ask how to fill in/draw the shape
        try {
            paintMethod.invoke(paintable, g);
        } catch (Exception e) {
            throw new RuntimeException(
               "Could not invoke paint method on: " +
                    paintable.getClass(), e);
        return new ImagePaintContext(xform,
                                     (int) userBounds.getMinX(),
                                     (int) userBounds.getMinY());
    public int getTransparency() {
        /*Technically the transparency returned should be whatever colors are
         *used in the paintable object's "paint" method.  Since I'm just
         *drawing an opaque cross with this aplication, I'll return opaque.*/
        return java.awt.Transparency.OPAQUE;
    public class ImagePaintContext implements PaintContext {
        AffineTransform deviceToUser;
        /*the upper left x and y coordinate of the where the shape is (in
         *user space)*/
        int minX, minY;
        public ImagePaintContext(AffineTransform xform, int xCoor,
                                                        int yCoor){
            try{
                deviceToUser = xform.createInverse();
            }catch(java.awt.geom.NoninvertibleTransformException e) {}
            minX = xCoor;
            minY = yCoor;
        public Raster getRaster(int x, int y, int w, int h) {
            /*find the point on the image that the device (x,y) coordinate
             *refers to*/
            java.awt.geom.Point2D tmp =
                    new java.awt.geom.Point2D.Double(x,y);
            if(deviceToUser != null) {
                deviceToUser.transform(tmp,tmp);
            }else{
                tmp.setLocation(0,0);
            tmp.setLocation(tmp.getX()-minX,tmp.getY()-minY);
            /*return the important portion of the image/raster in the
             * coordinate space of the device.*/
            return paint.getRaster().createChild((int) tmp.getX(),
                                                 (int) tmp.getY(),
                                                 w,h,x,y,null);
        public ColorModel getColorModel() {
            return paint.getColorModel();
        public void dispose() {
            paint = null;
    public static void main(String[] args) {
        /*as of java 1.6.10 d3d is enabled by default.  The fillRect
         * commands are significantly slower with d3d.  I think this is
         * a known bug.  Also, with d3d enabled I get all sort
         * weird painting artificats for this particular demonstration*/
        System.setProperty("sun.java2d.d3d","false");
        final ImagePaint paint = new ImagePaint(new Object() {
            public void paint(Graphics g) {
                Rectangle r = g.getClipBounds();
                g.setColor(Color.white);
                g.fillRect(r.x,r.y,r.width,r.height);
                //draw a red cross
                g.setColor(Color.red);
                g.fillRect(r.width/2-20,0,40,r.height);
                g.fillRect(0,r.height/2-20,r.width,40);
                g.dispose();
        JFrame f = new JFrame();
        f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        JComponent p = new JComponent() {
            public void paintComponent(Graphics g) {
                Graphics2D g2d = (Graphics2D) g;
                g2d.setPaint(paint);
                g2d.fillOval(getWidth()/3,getHeight()/3,
                             getWidth()/3,getHeight()/3);
                g2d.dispose();
        p.setPreferredSize(new Dimension(500,500));
        f.setContentPane(p);
        f.pack();
        f.setVisible(true);
}I don't think the unresponsiveness from larger areas is necessarily due to your code. For all of my GUI applications, resizing an
already large frame tends to be prety sucky while resizing an already small frame tends to be pretty smooth.