Create an image from a non-visible AWT Component?

Question

I'm trying to create an image (screen-shot) of a non-visible AWT component. I can't use the Robot classes' screen capture functionality because the component is not visible on the screen. Trying to use the following code:

BufferedImage image = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
Graphics2D g = image.createGraphics();
component.paintAll(g);

Works sometimes, but does not work if the component contains things such as a text box or button, or some sort of OpenGL / 3D component (these things are left out of the image!). How can I take a proper screenshot of the whole thing?

Answer 1

Excellent question, I've thought about this myself from time to time!

---

As you already have written, that rending heavy weight components such as 3D and AWT onto an image is a big problem. These components are (almost) directly transferred to the graphic card so they cannot be re-rendered to an image using the normal paintComponent stuff, you need help from the operative system or doing your own rendering of these components.

---

1. Making your own to image renderer

For each component that does not have a to image rendering method you need to create your own. For example using jogl you can take a off-screen screenshot using this method (SO post).

---

2. Rendering onto a virtual screen

Prerequisites:

1. Can you start the program/component in a headless environment?
2. Are you using Linux?

Then you can use Xvfb to render the whole program onto a virtual screen and then taking a screenshot from that virtual screen like this:

Xvfb :1 &
DISPLAY=:1 java YourMainClass
xwd -display :1 -root -out image.xwd

Maybe you need to tweek Xvfb a little bit by passing the size of the program you want to render to it (-screen 0 1024x768x24).

Answer 2

(disclamer: woops.. this doesn't seem to work for AWT )-:

I can't believe no one has suggested SwingUtilities.paintComponent or CellRendererPane.paintComponent which are made for this very purpose. From the documentation of the former:

Paints a component to the specified Graphics. This method is primarily useful to render Components that don't exist as part of the visible containment hierarchy, but are used for rendering.

---

Here is an example method that paints a non-visible component onto an image:

import java.awt.*;
import java.awt.image.BufferedImage;

import javax.swing.*;

public class ComponentPainter {

    public static BufferedImage paintComponent(Component c) {

        // Set it to it's preferred size. (optional)
        c.setSize(c.getPreferredSize());
        layoutComponent(c);

        BufferedImage img = new BufferedImage(c.getWidth(), c.getHeight(),
                BufferedImage.TYPE_INT_RGB);

        CellRendererPane crp = new CellRendererPane();
        crp.add(c);
        crp.paintComponent(img.createGraphics(), c, crp, c.getBounds());    
        return img;
    }

    // from the example of user489041
    public static void layoutComponent(Component c) {
        synchronized (c.getTreeLock()) {
            c.doLayout();
            if (c instanceof Container)
                for (Component child : ((Container) c).getComponents())
                    layoutComponent(child);
        }
    }
}

Here is a snippet of code that tests the above class:

JPanel p = new JPanel();
p.add(new JButton("Button 1"));
p.add(new JButton("Button 2"));
p.add(new JCheckBox("A checkbox"));

JPanel inner = new JPanel();
inner.setBorder(BorderFactory.createTitledBorder("A border"));
inner.add(new JLabel("Some label"));
p.add(inner);

BufferedImage img = ComponentPainter.paintComponent(p);

ImageIO.write(img, "png", new File("test.png"));

And here is the resulting image:

                      

Answer 3

Component has a method paintAll(Graphics) (as you already have found). That method will paint itself on the passed graphics. But we have to pre-configure the graphics before we call the paint method. That's what I found about the AWT Component rendering at java.sun.com:

When AWT invokes this method, the Graphics object parameter is pre-configured with the appropriate state for drawing on this particular component:

• The Graphics object's color is set to the component's foreground property.
• The Graphics object's font is set to the component's font property.
• The Graphics object's translation is set such that the coordinate (0,0) represents the upper left corner of the component.
• The Graphics object's clip rectangle is set to the area of the component that is in need of repainting.

So, this is our resulting method:

public static BufferedImage componentToImage(Component component, Rectangle region)
{
    BufferedImage img = new BufferedImage(component.getWidth(), component.getHeight(), BufferedImage.TYPE_INT_ARGB_PRE);
    Graphics g = img.getGraphics();
    g.setColor(component.getForeground());
    g.setFont(component.getFont());
    component.paintAll(g);
    g.dispose();
    if (region == null)
    {
        return img;
    }
    return img.getSubimage(region.x, region.y, region.width, region.height);
}

This is also the better way instead of using Robot for the visible components.

---

EDIT:

A long time ago I used the code I posted here above, and it worked, but now not. So I searched further. I have a tested, working way. It is dirty, but works. The Idea of it is making a JDialog, put it somewhere out of the Screen bounds, set it visible, and then draw it on the graphics.

Here is the code:

public static BufferedImage componentToImageWithSwing(Component component, Rectangle region) {
    BufferedImage img = new BufferedImage(component.getWidth(), component.getHeight(), BufferedImage.TYPE_INT_RGB);
    Graphics g = img.createGraphics();

    // Real render
    if (component.getPreferredSize().height == 0 && component.getPreferredSize().width == 0)
    {
        component.setPreferredSize(component.getSize());
    }

    JDialog f = new JDialog();
    JPanel p = new JPanel();
    p.add(component);
    f.add(p);
    f.pack();
    f.setLocation(-f.getWidth() - 10, -f.getHeight() -10);
    f.setVisible(true);
    p.paintAll(g);
    f.dispose();
    // ---

    g.dispose();
    if (region == null) {
        return img;
    }
    return img.getSubimage(region.x, region.y, region.width, region.height);
}

So, this will work also on Windows and Mac. The other answer was to draw it on a virtual screen. But this doesn't need it.

Answer 4

The Screen Image class shows how this can be done for Swing components. I've never tried it with AWT components, buy I could guess the concept would be the same.

Answer 5

How about something like this. The JFrame that holds all of the components is not visible.

import java.awt.Color;
import java.awt.Component;
import java.awt.Container;
import java.awt.Dimension;
import java.awt.Graphics2D;
import java.awt.Rectangle;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import java.util.Arrays;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.imageio.ImageIO;
import javax.swing.JButton;
import javax.swing.JComponent;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JTextArea;


/**
 * Captures an invisible awt component
 * @author dvargo
 */
public class ScreenCapture
{

private static List<String> types = Arrays.asList( ImageIO.getWriterFileSuffixes() );

/**
 * Build GUI
 * @param args
 */
public static void main(String [] args)
{
    JFrame invisibleFrame = new JFrame();
    invisibleFrame.setSize(300, 300);
    JPanel colorPanel = new JPanel();
    colorPanel.setBackground(Color.red);
    colorPanel.setSize(invisibleFrame.getSize());
    JTextArea textBox = new JTextArea("Here is some text");
    colorPanel.add(textBox);
    invisibleFrame.add(colorPanel);
    JButton theButton = new JButton("Click Me");
    colorPanel.add(theButton);

    theButton.setVisible(true);
    textBox.setVisible(true);
    colorPanel.setVisible(true);

    //take screen shot
    try 
    {
        BufferedImage screenShot = createImage((JComponent) colorPanel, new Rectangle(invisibleFrame.getBounds()));
        writeImage(screenShot, "filePath");
    } 
    catch (IOException ex)
    {
        Logger.getLogger(ScreenCapture.class.getName()).log(Level.SEVERE, null, ex);
    }

}


/**
 *  Create a BufferedImage for Swing components.
 *  All or part of the component can be captured to an image.
 *
 *  @param  component component to create image from
 *  @param  region The region of the component to be captured to an image
 *  @return image the image for the given region
 */
public static BufferedImage createImage(Component component, Rectangle region) {
    //  Make sure the component has a size and has been layed out.
    //  (necessary check for components not added to a realized frame)

    if (!component.isDisplayable()) {
        Dimension d = component.getSize();

        if (d.width == 0 || d.height == 0) {
            d = component.getPreferredSize();
            component.setSize(d);
        }

        layoutComponent(component);
    }

    BufferedImage image = new BufferedImage(region.width, region.height, BufferedImage.TYPE_INT_RGB);
    Graphics2D g2d = image.createGraphics();

    //  Paint a background for non-opaque components,
    //  otherwise the background will be black

    if (!component.isOpaque()) {
        g2d.setColor(component.getBackground());
        g2d.fillRect(region.x, region.y, region.width, region.height);
    }

    g2d.translate(-region.x, -region.y);
    component.paint(g2d);
    g2d.dispose();
    return image;
}

public static void layoutComponent(Component component) {
    synchronized (component.getTreeLock()) {
        component.doLayout();

        if (component instanceof Container) {
            for (Component child : ((Container) component).getComponents()) {
                layoutComponent(child);
            }
        }
    }
}

/**
 *  Write a BufferedImage to a File.
 *
 *  @param   image image to be written
 *  @param   fileName name of file to be created
 *  @exception IOException if an error occurs during writing
*/
public static void writeImage(BufferedImage image, String fileName)
    throws IOException
{
    if (fileName == null) return;

    int offset = fileName.lastIndexOf( "." );

    if (offset == -1)
    {
        String message = "file suffix was not specified";
        throw new IOException( message );
    }

    String type = fileName.substring(offset + 1);

    if (types.contains(type))
    {
        ImageIO.write(image, type, new File( fileName ));
    }
    else
    {
        String message = "unknown writer file suffix (" + type + ")";
        throw new IOException( message );
    }
}

}