Discussion :

[HNoury]

Bonjour,

Je sais que cette question revient souvent, mais là je ne trouve pas. La classe TracePlan calcule les coordonnées des points à tracer, puis donne l'ordre de les imprimer à l'écran :

Code java :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
class TracePlan extends AbstractAction{
public TracePlan (PlanC C1, ValTransfo[] TDP, int nT, Panneau pan)
        {this.C1 = C1;
        this.TDP = TDP;    //Tableaux de valeurs.
        this.nT = nT;    
        this.pan = pan;    //Le panneau où sera tracé le dessin.
        }
 
    public void actionPerformed (ActionEvent e)
        {NbrePts = C1.getNombrePoints();
        ZoomVal = C1.getZooming();
 
    /*etc., suite à cette récupération des valeurs vient une série de calculs
    de coordnnées des points à tracer*/
 
    Color ClT = new Color(TDP[k].getRedVal(), TDP[k].getGreenVal(), TDP[k].getBlueVal());//Va chercher les valeurs de la couleur de fond.
    Color Cfd = new Color (C1.getRougeP(), C1.getVertP(), C1.getBleuP());
    pan.FondPan(Cfd); //Couleur de fond.
 
if((0<=CoX) && (CoX<=800) && (0<=CoY) && (CoY<=550))//limites de l'écran.
            {pan.TracePt(CoX, CoY, ClT);
            }//ordonne de tracer le point.

Le Jpanel fait l'objet d'une classe à part, dont voici le code intégral :

Code java :

Sélectionner tout - Visualiser dans une fenêtre à part

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
class Panneau extends JPanel {
    public void paintComponent(Graphics g)
        {super.paintComponent(g);
        }
 
    public void FondPan(Color Cfd){
        this.Cfd = Cfd;
        setBackground(Cfd);
        }    
 
    public void TracePt(int CoX, int CoY, Color ClT){
        this.ClT = ClT;
        this.CoX = CoX;
        this.CoY = CoY;
        Graphics g = getGraphics();/*Si il n'y est pas, cela génère une exception.*/
        g.setColor(ClT); //Couleur du point.
        g.drawOval (CoX, (550-CoY),1,1);  //réglage du positionnement et de la largeur.
        g.fillOval(CoX, (550-CoY),1,1);
        g.dispose();
        super.paintComponent(g);//n'apporte rien!
        }    
    Color ClT, Cfd;
    int CoX, CoY;    
    Graphics g;    
}

Problème classique, les points s'affichent, mais ne résistent pas au redimensionnement des fenêtres. Mieux, si je change la couleur de fond, celle-ci se met sur le dessin, et je dois relancer la classe TracePlan pour revoir apparaitre le graphisme.

La méthode repaint, où qu'elle soit placée, efface les points à peine créés. J'ai essayé de tracer depuis TracePlan en rappelant Graphics g dans cette classe, le problème était le même!

Non, vraiment, je n'arrive pas à trouver. (Je ne pense pas avoir besoin de threads ici, il n'y a pas tant de points à tracer).

[Sanguko]

Problème classique ...

Reponse classique:
Tout le dessin doit se faire dans paintComponent(). En gros, le dessin fait dans TracePt() doit être fait dans paintComponent().

[bouye]

Et tu ne dois pas appeller getGraphics() ! Tu utilises le Graphics founis en parametre de paintComponent().

[HNoury]

Merci beaucoup, Sanguko et bouye pour vos réponses. Mon problème est que l'action de dessiner doit être impérativement lancée depuis un JMenu (ou un ActionEvent). La classe TracePlan servait à gérer cet actionEvent.

J'ai essayé de lancer le paintComponent en faisant : pan=new Panneau() comme réponse à l'actionEvent, cela n'a pas marché. En fait, c'est comment transformer un actionEvent() en paintCompoent(), mon problème.

[Sanguko]

Il faut conserver dans l'actionPerformed la liste des modifications, ou faire les modifications directement dans un structure, que tu reutiliseras ensuite dans paintComponent().
Pour appeler paintComponent(), il faut que tu appelles la methode repaint() sur ton composant (qui surchage paintComponent()), ou un de ses parents.
La methode repaint() est asynchrone. Tu postes une demande de redessin (qui sera traité un peu plus tard). Ca permet au systeme de regrouper en une seule plusieurs demandes de redessin.

[HNoury]

Merci une nouvelle fois Sanguko pour ta réponse.

Est-ce que ma classe "TracePlan" est ce genre de structure dont tu parles? Par ailleurs, pour l'instant, à chaque fois que j'ai implémenté repaint(), le dessin s'effaçait à peine créé! (que repaint() soit au début de TracePlan ou de Panneau).

Est-ce que je peux faire quelquechose comme :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class TracePlan extends AbstractAction{
public TracePlan (PlanC C1, ValTransfo[] TDP, int nT, Panneau pan)
        {this.C1 = C1;
        this.TDP = TDP;    //Tableaux de valeurs.
        this.nT = nT;    
        this.pan = pan;    //Le panneau où sera tracé le dessin.
        }
 
    public void actionPerformed (ActionEvent e){
         public void paintComponent(Graphics g)/*j'inclue le paintComponent dans le actionEvent*/
        {super.paintComponent(g);
         //calcul des coordonnées et commandes
         // de type g.drawOval, etc.
       }
}

}

Est-ce que cela marche?

[Sanguko]

Aucun chance que ca marche, paintComponent est une methode de JComponent, pas de AbstractAction.

Je te poste du code qui illustre ce que je voulais te dire.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
class Panneau extends JPanel {
 
	class MyPoint {
		int x;
		int y;
		Color color;
	}
	ArrayList<MyPoint> points = new ArrayList<MyPoint>();
 
	public void paintComponent(Graphics g) {
		super.paintComponent(g);
		for (int i=0;i<points.size();++i)
			tracePoint(g, points.get(i));
 
	}		
 
	public void addPoint( int ox, int oy, Color color) {
		MyPoint point = new MyPoint();
		point.x = ox;
		point.y = oy;
		point.color = color;
		points.add(point);		
		repaint();
	}
 
	private void tracePoint(Graphics g, MyPoint point) {					
		g.setColor(point.color);  
		g.drawOval (point.x, (550-point.y),10,10);  
		g.fillOval(point.x, (550-point.y),10,10);
	}
 
	public static void main(String[] args) {
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
 
		Panneau panneau = new Panneau();
		panneau.setPreferredSize(new Dimension(550,550));
		frame.getContentPane().add(panneau, BorderLayout.CENTER);
 
		JButton button = new JButton("Add Point");
		button.setAction(new TracePlan(panneau));
		frame.getContentPane().add(button, BorderLayout.WEST);
 
		frame.pack();
		frame.setVisible(true);
	}
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
class TracePlan extends AbstractAction {
	Panneau panneau;
	int x;
	int y;
	int icolor;
 
	static Color[] colors = {
		Color.blue,
		Color.red,
		Color.green
	};
 
	public TracePlan(Panneau panneau) {
		super("Add Point");
		this.panneau = panneau; 
	}
 
	public void actionPerformed(ActionEvent e) {
		x+=10;
		y+=10;
		icolor++;
		icolor%=colors.length;
		panneau.addPoint(x,y,colors[icolor]);		
	}
}

[HNoury]

Merci infiniment, Sanguko, j'essaie cela dès ce soir et je te tiens au courant.

[HNoury]

Merci beaucoup, Sanguko, ton code marche très bien. Je l'ai testé, et je l'ai adapté pour mon projet. Du coup, le dessin ne s'efface plus quand j'en fais un nouveau, mais j'ai quelque part la méthode adéquate.

Merci encore, je n'y aurais pas pensé tout seul.

[HNoury]

J'ai ajouté un petit .clear() au vecteur en début de actionEvent, et cela marche pile poil! En plus, c'est la première fosi que j'en utilisais un (vecteur). C'est aussi simple qu'un tableau en fait!

Merci encore.

[bouye]

Juste pour info : il peut etre preferable (mais pas obligatoire) d'utiliser un autre type de List (java.util.List) (LinkedList, ArrayList) plutot qu'un Vector :
- d'une part cette classe dispose d'acces synchronises (necessaire en cas de multi-thread), ce qui peut ralentir et ajouter un surcharge memoire inutile quand tu l'utilises dans un envirronement mono-treade (note : il est toujours possible de convertir un autre type de liste en liste synchronisee via Collections.synchronizedList())
- cette classe date des debuts de java et a ete modifiee pour etre adaptee a l'interface List. Des classes plus recentes comme celles mentionnees plus haut peuvent s'averer plus performantes.