// SaveAsGIF.java
 
import java.awt.*;
import java.awt.event.*;
import java.io.*;
import javax.swing.*;
 
public class SaveAsGIF extends JFrame
{
    ButtonPanel buttonPanel;
    CanvasPanel canvasPanel;
 
    public static void main(String[] args) 
    {
        SaveAsGIF sag = new SaveAsGIF();
    }
 
 
    public SaveAsGIF()
    {
        this.setTitle("Save JPanel As GIF");
        this.setVisible(true);
        this.setSize(600, 600);
        this.setLayout(new BorderLayout());
        canvasPanel = new CanvasPanel(this);
        buttonPanel = new ButtonPanel(this, canvasPanel);
        this.add(buttonPanel, BorderLayout.NORTH);
        buttonPanel.setPreferredSize(new Dimension(600, 100));                
        this.add(buttonPanel, BorderLayout.NORTH);
        this.add(canvasPanel, BorderLayout.SOUTH);
        this.pack();
        this.setDefaultCloseOperation(EXIT_ON_CLOSE);
    }
 
 
    public void SaveJPanelAsGIF (JPanel jp)
    {
        // not sure what to do here.
    }
}

// ButtonPanel.java
 
import java.awt.*;
import java.awt.event.*;
import java.io.*;
import javax.swing.*;
 
 
public class ButtonPanel extends JPanel implements ActionListener
{
     JButton drawButton;
     JButton saveButton;
     CanvasPanel cp;
     SaveAsGIF savegif;
 
     public ButtonPanel(SaveAsGIF se, CanvasPanel canPanel)
     {
         savegif = se;
         cp = canPanel;
         this.setBackground(Color.RED);
         this.setPreferredSize(new Dimension(600, 100));
         LayoutManager lm = new GridLayout(1, 2);
         drawButton = new JButton ("Draw New Rectangle");
         saveButton = new JButton ("Save Canvas Panel as GIF");
         drawButton.addActionListener(this);
         saveButton.addActionListener(this);
         this.setLayout(lm);
         this.add(drawButton);
         this.add(saveButton);
     } 
 
     public void actionPerformed(ActionEvent e) 
     {
         Object obj = e.getSource();
         if (obj == drawButton)
             cp.NewDrawing();
         else if (obj == saveButton)
             savegif.SaveJPanelAsGIF(cp);
     }
}

// CanvasPanel.java
 
import java.awt.*;
import java.awt.event.*;
import java.io.*;
import javax.swing.*;
import java.util.*;
 
 
class CanvasPanel extends JPanel
{
    int x;
    int y;
    int length;
    int width;
    Random random;
    SaveAsGIF savegif;
 
 
    public CanvasPanel(SaveAsGIF se)
    {
        savegif = se;
        x = 100;
        y = 100;
        length = 200;
        width = 100;
        random = new Random();
        this.setBackground(Color.GREEN);
        this.setPreferredSize(new Dimension(600, 500));
    }
 
 
    public void paintComponent(Graphics g)
    {
        super.paintComponent(g);
        g.setColor(Color.BLACK);
        g.fillRect(x, y, width, length);
    }
 
 
    public void NewDrawing()
    {
        x = random.nextInt(100) + 50;
        y = random.nextInt(100) + 50;
        width = random.nextInt(100) + 50;
        length = random.nextInt(100) + 150;
        repaint();
    }   
}

public void actionPerformed(java.awt.event.ActionEvent e){
    try {
        File saveFile = new File(jobFile+"_colorscan@"+centerSampleIndex+".gif");
        Image img = createImage(getWidth(),getHeight());
        Graphics g = img.getGraphics();
        paint(g);
        ImageIO.write(toBufferedImage(img),"gif",saveFile);
        JOptionPane.showMessageDialog(null,"Image saved to "+saveFile.toString());
        g.dispose();
    } catch (Exception ex){
        ex.printStackTrace();
    }
}

// This method returns a buffered image with the contents of an image
private BufferedImage toBufferedImage(Image image) {
    if (image instanceof BufferedImage) {
        return (BufferedImage)image;
    }
 
    // This code ensures that all the pixels in the image are loaded
    image = new ImageIcon(image).getImage();
 
    // Determine if the image has transparent pixels; for this method's
    // implementation, see e661 Determining If an Image Has Transparent Pixels
    boolean hasAlpha = hasAlpha(image);
 
    // Create a buffered image with a format that's compatible with the screen
    BufferedImage bimage = null;
    GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();
    try {
        // Determine the type of transparency of the new buffered image
        int transparency = Transparency.OPAQUE;
        if (hasAlpha) {
            transparency = Transparency.BITMASK;
        }
 
        // Create the buffered image
        GraphicsDevice gs = ge.getDefaultScreenDevice();
        GraphicsConfiguration gc = gs.getDefaultConfiguration();
        bimage = gc.createCompatibleImage(
                image.getWidth(null), image.getHeight(null), transparency);
    } catch (HeadlessException e) {
        // The system does not have a screen
    }
 
    if (bimage == null) {
        // Create a buffered image using the default color model
        int type = BufferedImage.TYPE_INT_RGB;
        if (hasAlpha) {
            type = BufferedImage.TYPE_INT_ARGB;
        }
        bimage = new BufferedImage(image.getWidth(null), image.getHeight(null), type);
    }
 
    // Copy image to buffered image
    Graphics g = bimage.createGraphics();
 
    // Paint the image onto the buffered image
    g.drawImage(image, 0, 0, image.getWidth(null), image.getHeight(null), null);
    g.dispose();
 
    return bimage;
}    
// This method returns true if the specified image has transparent pixels
public static boolean hasAlpha(Image image) {
    // If buffered image, the color model is readily available
    if (image instanceof BufferedImage) {
        BufferedImage bimage = (BufferedImage)image;
        return bimage.getColorModel().hasAlpha();
    }
 
    // Use a pixel grabber to retrieve the image's color model;
    // grabbing a single pixel is usually sufficient
     PixelGrabber pg = new PixelGrabber(image, 0, 0, 1, 1, false);
    try {
        pg.grabPixels();
    } catch (InterruptedException e) {
    }
 
    // Get the image's color model
    ColorModel cm = pg.getColorModel();
    return cm.hasAlpha();
}