Affichage image fond fenetre

Version imprimable

hello a tous!

J'essaye d'afficher une image en fond de fenetre, bien disposer à l'aide d'un gridlayout sur un JPanel et je n'y arrive pas (et j'aimerai dailleur y faire figurer des icone dessus, mais plutard)...

Pourtant j'utilise le code qu'il y a ds la fac ...

voici mon code :

pr l'implementation de ce jcomponent:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
 
import javax.swing.*; 
import java.awt.*; 
import java.awt.image.*; 
 
public class JPanelImageBg extends JComponent
{
	private int mode;
	private TexturePaint texture; 
	private BufferedImage bufferedImage; 
 
	public static final int CENTRE = 0;
	public static final int TEXTURE = 1;
 
	JPanelImageBg( String fileName, int mode )
	{	this.mode = mode;
		this.bufferedImage = this.toBufferedImage(Toolkit.getDefaultToolkit().getImage(fileName));
		this.texture = new TexturePaint(bufferedImage,new Rectangle(0, 0, bufferedImage.getWidth(), bufferedImage.getHeight())); 
	} 
 
	public void paintComponent(Graphics g)
	{	switch( mode )
		{	case TEXTURE :
				Graphics2D g2d = (Graphics2D)g; 
				g2d.setPaint(texture);
				g2d.fillRect(0, 0, getWidth(), getHeight() );
				break;
			case CENTRE :
				g.setColor(this.getBackground());
				g.fillRect(0,0,getWidth(), getHeight() );
				g.drawImage(bufferedImage,(getWidth()-bufferedImage.getWidth())/2,(getHeight()-bufferedImage.getHeight())/2,null);
				break;
			default :
				super.paintComponents(g);
		}
	}
 
 
	private BufferedImage toBufferedImage(Image image)
	{	image = new ImageIcon(image).getImage(); 
 
		BufferedImage bufferedImage = new BufferedImage( image.getWidth(null), image.getHeight(null), BufferedImage.TYPE_INT_RGB); 
		Graphics g = bufferedImage.createGraphics(); 
 
		g.setColor(Color.white); 
		g.fillRect(0, 0, image.getWidth(null), 
		image.getHeight(null)); 
		g.drawImage(image, 0, 0, null); 
		g.dispose(); 
		return bufferedImage; 
	}
 
}

et pr son utilisation :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
import javax.swing.*;
 
public class JPanelImageBgTest extends JFrame
{
 
 
	JPanelImageBgTest(String titre, int mode )
	{	
		super(titre);
		this.setContentPane(new JPanelImageBg("butterfly.jpg",mode));
		this.getContentPane().add(new JButton("test"));
		setSize(500,500);
		this.setVisible(true);
	}
 
 
 
	public static void main( String[] argv )
	{	new JPanelImageBgTest("Centre",JPanelImageBg.CENTRE);
		new JPanelImageBgTest("Texture",JPanelImageBg.TEXTURE);
	}

voila lerreur :

Exception in thread "main" java.lang.IllegalArgumentException: Width (-1) and height (-1) cannot be <= 0
at java.awt.image.DirectColorModel.createCompatibleWritableRaster(Unknown Source)
at java.awt.image.BufferedImage.<init>(Unknown Source)
at agents.JPanelImageBg.toBufferedImage(JPanelImageBg.java:43)
at agents.JPanelImageBg.<init>(JPanelImageBg.java:18)
at agents.JPanelImageBgTest.<init>(JPanelImageBgTest.java:12)
at agents.JPanelImageBgTest.main(JPanelImageBgTest.java:21)

Merci de m'aider!!

englobe ton code contenu dans paintComponent par un

Code:

1
2
3
4
5
6
7
 
protected void paintComponent(Graphics g) {
 
   if(this.isShowing()) {
      ...
   }
}

qu'est-ce que c'est que ce mic-mac ;) :

Code:

1
2
3
 
private BufferedImage toBufferedImage(Image image)
	{	image = new ImageIcon(image).getImage();

Vu l'erreur que tu as :

Code:

1
2
3
4
 
Exception in thread "main" java.lang.IllegalArgumentException: Width (-1) and height (-1) cannot be <= 0
at java.awt.image.DirectColorModel.createCompatibleWritableRaster(Unknown Source)
at java.awt.image.BufferedImage.<init>(Unknown Source)

on pourrait penser que l'image n'est pas au bon emplacement physique.

En SWING pureTu peux faire un truc comme sa :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
 
import java.awt.Graphics;
import java.awt.Toolkit;
 
import javax.swing.JFrame;
 
public class Fenetre extends JFrame {
 
    private String image = "image.jpg";
 
    public Fenetre() {
        this.setSize(400,400);
        this.setLocationRelativeTo(null);
        this.setVisible(true);
        this.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
    }
 
    @Override
    public void paint(Graphics arg0) {
        arg0.drawImage(Toolkit.getDefaultToolkit().getImage(image),0,0,null);
    }
 
    /**
     * @param args
     */
    public static void main(String[] args) {
        new Fenetre();
    }
 
}

Sinon tu peux utiliser l'API swing X qui a un composant JXImagePanel qui te permet de creer un panel avec une image de fond tres facilement :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
 
// Création de notre panel
JXImagePanel imagePanel=new JXImagePanel();
Image image;
 
try {
 
    // récupération de l'image que l'on applique au panel
    image = ImageIO.read(getClass().getResource("image.jpg"));
    imagePanel.setImage(image);
} catch (IOException ex) {
    ex.printStackTrace();
}

Ok les gars merci pour toutes vos solutions, jen ai choisi une qui semble bien marcher...

La voici :

pr l'extension du jcomponent :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
 
import javax.swing.*; 
import java.awt.*; 
import java.awt.image.*; 
 
public class JPanelImageBg extends JComponent
{
	private int mode;
	private TexturePaint texture; 
	private BufferedImage bufferedImage; 
 
	public static final int CENTRE = 0;
	public static final int TEXTURE = 1;
 
	JPanelImageBg( String fileName, int mode )
	{	this.mode = mode;
		this.bufferedImage = this.toBufferedImage(Toolkit.getDefaultToolkit().getImage(fileName));
		this.texture = new TexturePaint(bufferedImage,new Rectangle(0, 0, bufferedImage.getWidth(), bufferedImage.getHeight())); 
	} 
 
	public void paintComponent(Graphics g)
	{	switch( mode )
		{	case TEXTURE :
				Graphics2D g2d = (Graphics2D)g; 
				g2d.setPaint(texture);
				g2d.fillRect(0, 0, getWidth(), getHeight() );
				break;
			case CENTRE :
				g.setColor(this.getBackground());
				g.fillRect(0,0,getWidth(), getHeight() );
				g.drawImage(bufferedImage,(getWidth()-bufferedImage.getWidth())/2,(getHeight()-bufferedImage.getHeight())/2,null);
				break;
			default :
				super.paintComponents(g);
		}
	}
 
 
 
	private BufferedImage toBufferedImage(Image image)
	{	image = new ImageIcon(image).getImage(); 
 
		BufferedImage bufferedImage = new BufferedImage( image.getWidth(null), image.getHeight(null), BufferedImage.TYPE_INT_RGB); 
		Graphics g = bufferedImage.createGraphics(); 
 
		g.setColor(Color.white); 
		g.fillRect(0, 0, image.getWidth(null), 
		image.getHeight(null)); 
		g.drawImage(image, 0, 0, null); 
		g.dispose(); 
		return bufferedImage; 
	}
 
}

et pr l'utilisation :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
 
import java.awt.GridLayout;
 
import javax.swing.*;
 
 
/*contient le frame du cercle + frame de la legende*/
 
 
public class FramePrincipal extends JFrame{
 
 
 
 
	FramePrincipal(String titre, int mode )
	{	
		super(titre);
		this.setSize(500,500);
		this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		this.setContentPane(new JPanelImageBg("D:/users/GeOxygene/GeOxygene/src/fr/ign/cogit/appli/carto/lucil/agents/couleurs_lumineuses.jpg",mode));
		this.setVisible(true); 
	}
 
 
 
	public static void main( String[] argv )
	{	new FramePrincipal("Visualisation agent",JPanelImageBg.CENTRE);
		//new JPanelImageBgTest("Texture",JPanelImageBg.TEXTURE);
	}
 
}

Mnt jai 2 pb :

1) jaimerai redimensionner l'image de facon proportionnelle a mon cadre
2) j'aimerai ke cette image soit disposer ds un gridlayout qui contient 3 colonne et kelle soit ds la colonne de gauche...

Merci pr vos aide!

17/04/2007, 11h04
benthebest

Un ptit UP :help: Please...

Fais attention à bien lire les règles (les up et ce genre de choses...): http://www.developpez.net/forums/ann...php?f=114&a=19

Sinon pour ton probléme

1) Pour que l'image se redimensionne en fonction de ton JPanel en ignorant ou pas son ratio:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
 
 
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.RenderingHints;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
 
import javax.imageio.ImageIO;
import javax.swing.JFrame;
import javax.swing.JPanel;
 
/*
 * Créé le 17 avr. 07
 *
 * Pour changer le modèle de ce fichier généré, allez à :
 * Fenêtre&gt;Préférences&gt;Java&gt;Génération de code&gt;Code et commentaires
 */
 
/**
 * @author secabane
 *
 * Pour changer le modèle de ce commentaire de type généré, allez à :
 * Fenêtre&gt;Préférences&gt;Java&gt;Génération de code&gt;Code et commentaires
 */
public class ImgPane extends JPanel {
 
    //Garder le ratio de l'image
    public static final int IGNORE_RATIO = 1;
    //redimensionner l'image sans prendre en compte son ratio
    public static final int KEEP_RATIO = 0;
 
    private BufferedImage im;
    private int ratioBehaviour;
 
    public ImgPane(BufferedImage im, int ratioBehaviour) {
        super();
        this.im = im;
        this.ratioBehaviour = ratioBehaviour;
        this.setPreferredSize(new Dimension(im.getWidth(), im.getHeight()));                
    }
 
 
 
 
    /* (non-Javadoc)
     * @see javax.swing.JComponent#paintComponent(java.awt.Graphics)
     */
    protected void paintComponent(Graphics arg0) {
        // TODO Raccord de méthode auto-généré
        super.paintComponent(arg0);
        Graphics2D g2d = (Graphics2D) arg0;
        //Pour respecter le ratio de l'image
        if(isShowing()) {                        
            g2d.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BILINEAR);
            g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
 
            if(ratioBehaviour == KEEP_RATIO) {
 
                //On garde le ratio
 
                //ratio largeur panel / largeur image            
                double widthRatio = ((double)this.getWidth())/ im.getWidth();
                //ratio largeur panel / largeur image
                double heightRatio = ((double)this.getHeight())/ im.getHeight(); 
                System.out.println("widthRatio = "+widthRatio+ " heightRatio = "+heightRatio);
                //on prend le plus petit des deux afin que l'image tienne dans le panel
                double tmpRatio = Math.min(widthRatio, heightRatio);
                //largeur de sortie
                int destWidth = (int) (im.getWidth()*tmpRatio);
                //hauteur de sortie
                int destHeight = (int)(im.getHeight()*tmpRatio);
                //position sur les x
                int verticalInset = 0;
                //position sur les y
                int horizontalInset = 0;
 
                //calcul des marges
                if(destWidth < this.getWidth()) {
                    horizontalInset = (this.getWidth() - destWidth) / 2; 
                }
                if(destHeight < this.getHeight()) {
                    verticalInset = (this.getHeight() - destHeight) / 2; 
                }            
 
                //dessin de l'image
                g2d.drawImage(im, horizontalInset,verticalInset,destWidth,destHeight,null);
            } else if(ratioBehaviour == IGNORE_RATIO) {
            //    On ignore le ratio
                g2d.drawImage(im, 0,0,this.getWidth(),this.getHeight(),null);
            }
        }
    }
 
 
    public static void main(String[] args) {
        JFrame f = new JFrame();
        try {
            BufferedImage im = ImageIO.read(new File("coverlow.jpg"));
            ImgPane pane = new ImgPane(im, ImgPane.KEEP_RATIO);
            f.add(pane);
            f.pack();
            f.setLocationRelativeTo(null);
            f.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
            f.setVisible(true);
        } catch (IOException e) {
            // TODO Bloc catch auto-généré
            e.printStackTrace();
        }
 
 
    }
 
}

2) Bah il suffit d'ajouter le JPanel contenant l'image à un JPanel possédant un GridLayout, je ne vois pas où est le problème
++

17/04/2007, 15h46
benthebest

Ok ca marche merci bcp!

Mais le pb c'est que je n'arrive pas a superposer des petites icones sur mon cercle (j'explique, en fait mon image de fond et un grand cercle de couleur et je dois y placer des petit rond en forme de smiley dessus et ki se deplace sur le cercle)

auriez vous une idee sur la facon de faire ceci?

d'avance merci.:)

Bah tu le fais dans ton paintComponent après avoir dessiné l'image.

Il te suffit d'avoir une Collection contenant les ronds à dessiner puis d'itérer dessus et de les dessiner

Ce qui te donnerait une classe smiley

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
 
 
public class Smiley {
 
        private BufferedImage im;
        private int x;
        private int y;
 
 
 
 
        public Smiley(BufferedImage im, int x, int y) {
             this.im = im;
             this.x = x;
             this.y = y;
        }
 
        /**
         * @return
         */
        public BufferedImage getIm() {
            return im;
        }
 
        /**
         * @return
         */
        public int getX() {
            return x;
        }
 
        /**
         * @return
         */
        public int getY() {
            return y;
        }
 
        /**
         * @param image
         */
        public void setIm(BufferedImage image) {
            im = image;
        }
 
        /**
         * @param i
         */
        public void setX(int i) {
            x = i;
        }
 
        /**
         * @param i
         */
        public void setY(int i) {
            y = i;
        }
 
        /**Dessine le simey sur des graphics
         * 
         * @param g
         */
        public void draw(Graphics g) {
            g.drawImage(im, x,y,null);
        }
    }

Puis dans ton paintComponent, après le dessin de l'image:

Code:

1
2
3
4
5
6
 
 
//dessin des smileys
for(int i = 0; i<smileys.size(); i++) {
    ((Smiley) smileys.get(i)).draw(g2d);
}

où smileys est une List de Smiley

A toi de te débrouiller pour bouger tes objets Smileys ensuite

17/04/2007, 17h21
benthebest

ok merci super ca marche!!!

Sinon (desole ms je suis ckon appel un "ultra debutant") pourrai tu me donner des pistes pr bouger mes ptits smiley? (faut il utiliser les threads?)

Merci encore.:P
17/04/2007, 18h29
sinok

Au choix, soit un thread global s'occupant de bouger tous tes smileys, soit un thead par smiley (dans les deux cas attention à la synchronisation et aux locks) ou sinon un Timer Swing