objet Graphics qui n'en fait qu'à sa tête

Version imprimable

Bonjour,

mon applet simule l'avancée d'une réaction chimique grace à un graphique
l'utilisateur peut demarrer avec le bouton play. et il peut faire pause en appuyant dessus (le bouton play se tranforme en bouton pause)

le problème c'est que à la pause la ligne du graphique n'est plus visible, alors que ça aurait été utile à la pause de pouvoir l'observer

j'ai bien fait des trucs genre : graphics g =getGraphics....
g.repaint(); quand on est à la pause mais rien n'y fait

Code :

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
 
 /**
         * Actions du bouton START/PAUSE
         */
private void action_b_start() {
 
isMarche = true;
if (isPause) {
	// L'utilisateur a appuyer sur le bouton START
	isPause = false;
	if(premiere){
		simulation = new Simulation(app);
				app.getFenetreGraphe().getFenetreGrapheParam().getcb_tmax().setSelectedIndex(0);//forcage à Tmax =2H pour 
																								//chaque début de simu
				simulation.demarreSimulation();
				premiere = false;
			}
			simulation.setEnMarche(true);
			enableBoutonStop(true); // Sur la fenêtre principale
 
			// Transformation du bouton START en bouton PAUSE
			setIsPause(false); // Sur la fenêtre principale
 
		} else {
			// L'utilisateur a appuyer sur le bouton PAUSE
			isPause = true;
			simulation.setEnMarche(false);
			b_start.setEnabled(true);
			app.getFenetreGraphe().setVisible(true);
			// Transformation du bouton PAUSE en bouton START
			this.app.getPanneauBoutons().setIsPause(true); // Sur la fenêtre principale
			Graphics g= app.getFenetreGraphe().getGraphePh().getGraphics();
			app.getFenetreGraphe().getGraphePh().paint(g);
 
		}
	}

Fonction qui affiche des points :
Code :

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
 
/**
         * Affichage des nouveaux points dans le graphe : 
         * on affiche les points pour les pompes 
         * Appellée par PanneauCuveGeneral.majGraphePompe
         */
	public void afficherPoint() {
		Graphics g = this.getGraphics();
		boolean afficher = false;    // Si le point est à afficher (cela dépend de l'échelle)
 
 
		if(abcisseEnCours == 1) {
			abcisseEnCours++;
			indiceTab++;
		} 
 
else if (abcisseEnCours < ABCISSE_MAX) {
// On calcule si le point est à afficher (selon l'échelle)
if ( indiceTab%(1/(2.0/this.T_MAX)) == 0) {
afficher = true;
} else {
afficher = false;
}
 
if(afficher){
// Pour chacune des pompes on réalise l'affichage
for(int i = 11 ; i>=0; i--) {
boolean cuve_select = false;
// on regarde si on doit afficher la courbe correspondant à la cuve x
if(i>1 && i<7){
if(cuves[i] != null)
cuve_select = cuves[i].isSelected();
} else if(i>6 && i<12) {
if(cuves[i-5] != null)
cuve_select = cuves[i-5].isSelected();
} else if(i==0 && app.getModele()!=PanneauCuves.MODELE_1_CUVE_DECHRO){
cuve_select = true;
} else if(i==1 && app.getModele()!=PanneauCuves.MODELE_1_CUVE_DECYAN){
cuve_select = true;
}
 
if (cuve_select) { // On affiche les points que si nécessaire
if (i == 0) {
g.setColor(Color.blue);
}
else if (i == 1) {
g.setColor(Color.red);
}
else if (i-5>1)
g.setColor(new Color(223,37,186));
else
g.setColor(new Color(37,220,223));
 
double pas = 1/(2.0/this.T_MAX);
g.drawLine(abcisseEnCours-1+x, tab_coor[indiceTab-(int)pas][i],abcisseEnCours+x, tab_coor[indiceTab][i]);
 
 
	(jai coupé certains trucs qui n'avait pas d'interet)					
}
}    
 
abcisseEnCours++;
 
}
 
indiceTab++;
}

PS : si je passe une fenetre dessus il devient visible

Merci de votre aide !

22/05/2007, 20h36
Gfx

Il faut surcharger la méthode paintComponent(Graphics g) et dessiner dans cette méthode. Sinon ton dessin sera automatiquemen supprimé lors de la prochaine mise à jour de la fenêtre.
23/05/2007, 16h06
poulette3000

est ce que l'on peut faire cohabiter un paintComponent, et un paint dans la meme classe ?
et c koi la difference avec paintComponents ?
23/05/2007, 17h07
poulette3000

personne m'aide moi ....
:(
23/05/2007, 19h37
sinok

Pour la cohabitation entre paint et paintComponent c'est plutôt moyen:

Le rôle de la méthode paint en swing est d'appeler un ensemble de méthodes qui vont effectuer les opérations de dessin sur le composant Swing. Parmis ces méthodes se trouve la méthode paintComponent qui elle va effectuer le dessin du composant en lui même, ainsi que d'autres méthodes telles que paintBorder ou encore paintChildrens.

Donc pour faire du dessin sur un composant swing il faut redéfinir la méthode paintComponent et uniquement celle là.
Et toute les opérations sur les graphics doivent être réalisés à l'intérieur de cette méthode (ou de méthodes appelées par paintComponen).
Ceci afin d'assurer que le composant se dessine correctement.

Avec le code que tu utilises pour le moment, il est assuré que tu auras des résultats au mieux erratiques, voir aucun.

Pour te donner une idée de comment redéfinir l'apparence d'un composant:

http://www.developpez.net/forums/sho...75&postcount=6

Sinon dans ton cas le but est de stocké l'ensemble des élément à dessiner dans une collection, puis dans le paintComponent de dessiner tous les éléments contenus dans la collection.

Donc tu auras un composant Graphe héritant de JPanel, contenant une collection (une ArrayList par exemple) d'éléments à dessiner et dont la méthode paintComponent parcourre la collection et dessine chaque élément contenu dans l'arrayList.

Et si tu veux ajouter un élément à dessiner au fur et à mesure du temps, il te suffit d'ajouter un élément à la collection, et de demander le repaint de ton composant.
24/05/2007, 20h06
poulette3000

euh je suis un peu debutante en java...

mais en fait moi tu vois je faisais un g.drawLine(x1,x2,x3,x4);

ça va faire quoi ton ArrayList un collection de traits ? :aie:( je reconnais je suis nulle)

Je suppose que tu ne vas pas vouloir afficher qu'une ligne dans ta simulation (enfin peut être à tort).

Dans ton cas le plus simple serait d'avoir une collection de Line2D, classe héritant de l'interface shape, et que tu peux donc dessiner au moyen de la méthode draw(Shape s) de la classe Graphics2D

(Dans Swing les Graphics employés sont des Graphics2D donc tu peux faire le cast entre Graphics et Graphics2D sans le moindre problème)

Donc basiquement tu aurais quelquechose dans ce style

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
 
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.RenderingHints;
import java.awt.Shape;
import java.awt.geom.Line2D;
import java.awt.geom.Point2D;
import java.util.ArrayList;
import java.util.List;
 
import javax.swing.JFrame;
import javax.swing.JPanel;
 
public class MonGraphe extends JPanel{
 
    /**
     *
     */
    private static final long serialVersionUID = -3688001984319297948L;
    private List<Shape> shapes;
 
    public void addShape(Shape shape) {
         shapes.add(shape);
         repaint();
    }
 
    public void addLine(Point2D origine, Point2D destination) {
        shapes.add(new Line2D.Double(origine,destination));
        repaint();
    }
 
    public void addLine(double x1,double y1, double x2, double y2) {
        shapes.add(new Line2D.Double(x1,y1,x2,y2));
        repaint();
    }
 
    public MonGraphe() {
        // TODO Raccord de constructeur auto-généré
        super();
        shapes = new ArrayList<Shape>();
    }
 
    /* (non-Javadoc)
     * @see javax.swing.JComponent#paintComponent(java.awt.Graphics)
     */
    @Override
    protected void paintComponent(Graphics g) {
        // TODO Raccord de méthode auto-généré
        super.paintComponent(g);
        Graphics2D g2d = (Graphics2D) g;
 
        //Pour que le dessin soit un peu plus "joli"
 
        g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
 
        //Pour chaque forme de la collection
        for(Shape shape  : shapes) {
            //On dessine la forme
            g2d.draw(shape);
        }
 
    }
 
 
    public static void main(String[] args) {
        MonGraphe graphe = new MonGraphe();
        graphe.addLine(0, 0, 80, 100);
        graphe.addLine( 80, 100,200,150);
        graphe.addLine( 200,150,320,100);
        graphe.addLine( 320, 100,400,0);
        graphe.addLine( 0, 150,400,150);
        graphe.addLine( 50, 140,150,140);
        graphe.addLine( 250, 140,350,140);
        JFrame f = new JFrame();
        f.add(graphe);
        f.setSize(400,300);
        f.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
        f.setLocationRelativeTo(null);
        f.setVisible(true);
    }
}

C'est simple, facile à comprendre et çà marche