Adding Image to JPanel?

Question

Hi all,
I am new to Swing..
How to add the "Image" to JPanel.
if anyone knows please help me..
Thanks

Answer 1

Here's a long reply involving several classes, some obtained directly from Sun for reuse. These allow you to fill an image in a panel as the background to your frame. You can add components on top of this background image. If this isn't what you wanted, excuse my misunderstanding:
First, you need a panel for your frame:
<code>
public class FramePanel extends JPanel
* Initialized by the (first call to the) constructor. This
* Fill is used to paint the entire panel.
private static TiledFill tiledFill = null;
/*Constructors */
public FramePanel()
super();
setOpaque(true);
* Create a TiledFill object to draw the
* background from preferences properties file
public void getBackgroundImage()
setForeground(Color.BLACK);
setBackground(Color.WHITE);
if (tiledFill == null)
try
FileImageInputStream file = new FileImageInputStream(*your image's file location*);
BufferedImage image = ImageIO.read(file);
ImageFill fill = new ImageFill(image);
tiledFill = new TiledFill(fill, image.getWidth(), image.getHeight());
catch (IOException e)
e.printStackTrace();
JOptionPane pane = new JOptionPane("Could not retrieve image in FramePanel");
pane.setVisible(true);
* Paint the area within <code>g.getClipBounds()</code>
* making sure that the new tiles are aligned with a tileWidth
* by tileHeight grid whose origin is at 0,0.
public void paintComponent(Graphics g)
super.paintComponent(g);
getBackgroundImage();
/* To ensure that the tiles we paint are aligned with
* a tileWidth X tileHeight grid whose origin is 0,0 we
* enlarge the clipBounds rectangle so that its origin
* is aligned with the origin of a tile and its size
* is a multiple of the tile size.
Rectangle clip = g.getClipBounds();
int tw = tiledFill.getTileWidth();
int th = tiledFill.getTileHeight();
int x = (clip.x / tw) * tw;
int y = (clip.y / th) * th;
int w = (((clip.x + clip.width + tw - 1) / tw) * tw) - x;
int h = (((clip.y + clip.height + th - 1) / th) * th) - y;
Graphics gFill = g.create();
tiledFill.paintFill(this, gFill, new Rectangle(x, y, w, h));
gFill.dispose();
</code>
Now you need the fill and tiled fill classes size the image.
<code>
import java.awt.*;
public class Fill
public void paintFill(Component c, Graphics g, Rectangle r)
g.setColor(c.getBackground());
g.fillRect(r.x, r.y, r.width, r.height);
public void paintFill(Container c, Graphics g)
Insets insets = c.getInsets();
int x = insets.left;
int y = insets.top;
int w = c.getWidth() - (insets.left + insets.right);
int h = c.getHeight() - (insets.top + insets.bottom);
paintFill(c, g, new Rectangle(x, y, w, h));
public void paintFill(Component c, Graphics g, int x, int y, int w, int h)
paintFill(c, g, new Rectangle(x, y, w, h));
</code>
<code>
import java.awt.*;
import java.awt.image.*;
* Displays a single <code>BufferedImage</code>, scaled to fit the
* <code>paintFill</code> rectangle.
* <pre>
* BufferedImage image = ImageIO.read(new File("background.jpg"));
* final ImageFill imageFill = new ImageFill(image);
* JPanel p = new JPanel() {
* public c void paintComponent(Graphics g) {
*     imageFill.paintFill(this, g);
* </pre>
* Note that animated gifs aren't supported as there's no image observer.
public class ImageFill extends Fill
private final static int IMAGE_CACHE_SIZE = 8;
private BufferedImage image;
private BufferedImage[] imageCache = new BufferedImage[IMAGE_CACHE_SIZE];
private int imageCacheIndex = 0;
* Creates an <code>ImageFill</code> that draws <i>image</i>
* scaled to fit the <code>paintFill</code> rectangle
* parameters.
* @see #getImage
* @see #paintFill
public ImageFill(BufferedImage image)
this.image = image;
* Creates an "empty" ImageFill. Before the ImageFill can be
* drawn with the <code>paintFill</code> method, the
* <code>image</code> property must be set.
* @see #setImage
* @see #paintFill
public ImageFill()
this.image = null;
* Returns the image that the <code>paintFill</code> method draws.
* @return the value of the <code>image</code> property
* @see #setImage
* @see #paintFill
public BufferedImage getImage()
return image;
* Set the image that the <code>paintFill</code> method draws.
* @param image the new value of the <code>image</code> property
* @see #getImage
* @see #paintFill
public void setImage(BufferedImage image)
this.image = image;
for (int i = 0; i < imageCache.length; i++)
imageCache[i] = null;
* Returns the actual width of the <code>BufferedImage</code>
* rendered by the <code>paintFill</code> method. If the image
* property hasn't been set, -1 is returned.
* @return the value of <code>getImage().getWidth()</code> or -1 if
* getImage() returns null
* @see #getHeight
* @see #setImage
public int getWidth()
BufferedImage image = getImage();
return (image == null) ? -1 : image.getWidth();
* Returns the actual height of the <code>BufferedImage</code>
* rendered by the <code>paintFill</code> method. If the image
* property hasn't been set, -1 is returned.
* @return the value of <code>getImage().getHeight()</code> or -1 if
* getImage() returns null
* @see #getWidth
* @see #setImage
public int getHeight()
BufferedImage image = getImage();
return (image == null) ? -1 : image.getHeight();
* Create a copy of image scaled to width,height w,h and
* add it to the null element of the imageCache array. If
* the imageCache array is full, then we replace the "least
* recently used element", at imageCacheIndex.
private BufferedImage createScaledImage(Component c, int w, int h)
GraphicsConfiguration gc = c.getGraphicsConfiguration();
BufferedImage newImage = gc.createCompatibleImage(w, h, Transparency.TRANSLUCENT);
boolean cacheOverflow = true;
for (int i = 0; i < imageCache.length; i++)
Image image = imageCache;
if (image == null)
imageCache[i] = newImage;
cacheOverflow = false;
break;
if (cacheOverflow)
imageCache[imageCacheIndex] = newImage;
imageCacheIndex = (imageCacheIndex + 1) % imageCache.length;
Graphics g = newImage.getGraphics();
int width = image.getWidth();
int height = image.getHeight();
g.drawImage(image, 0, 0, w, h, 0, 0, width, height, null);
g.dispose();
return newImage;
* Returns either the image itself or a cached scaled copy.
private BufferedImage getFillImage(Component c, int w, int h)
if ((w == getWidth()) && (h == getHeight()))
return image;
for (int i = 0; i < imageCache.length; i++)
BufferedImage cimage = imageCache[i];
if (cimage == null)
break;
if ((cimage.getWidth(c) == w) && (cimage.getHeight(c) == h))
return cimage;
return createScaledImage(c, w, h);
* Draw the image at <i>r.x,r.y</i>, scaled to <i>r.width</i>
* and <i>r.height</i>.
public void paintFill(Component c, Graphics g, Rectangle r)
if ((r.width > 0) && (r.height > 0))
BufferedImage fillImage = getFillImage(c, r.width, r.height);
g.drawImage(fillImage, r.x, r.y, c);
</code>
Now it's just a simple matter of creating a frame and making the frame panel the frame's content pane:
<code>
import java.awt.BorderLayout;
import java.awt.HeadlessException;
import javax.swing.JComponent;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.UIManager;
public class ImageFrame extends JFrame
private FramePanel framePanel;
//start of constructors
public ImageFrame() throws HeadlessException
super();
init();
public ImageFrame(String title) throws HeadlessException
super(title);
init();
// end of constructors
void init()
try
UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
catch (Exception e)
System.out.println ("Unknown Look and Feel");
     framePanel = new FramePanel();
     this.getContentPane().add(framePanel, BorderLayout.CENTER);
     this.setContentPane(framePanel);
     ((JPanel)this.getContentPane()).setOpaque(false);
</code>