repaint () qui redessine un composant de trop

Version imprimable

Bonjour, alors tout d'abord ceci vient d'un énoncé scolaire donc je dois bien faire 2 fenêtres différentes.
Le principe est de créer un "genre de billard", plutôt un flipper enfaite, avec des obstcales et où une balle est lancée, à chaque fois que la balle touche un obsctale, des points sont comptabiliser et afficher dans une autre fenêtre que la fenêtre principale.

Je vais essayer d'être clair en vous montrant mon code :

Ma classe Fenetre : la fenetre principale contenant le "billard" (flipper).

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
public class Fenetre extends JFrame
{
    private Container container;
    private Billard billard;
 
    public Fenetre (String titre)
    {
        super(titre);
 
        setBounds(100, 100, 485, 655); //Position x, position y (coin haut gauche), largeur, hauteur.
 
        MyWindowListener winListener = new MyWindowListener ();
        this.addWindowListener(winListener);
 
        this.billard = new Billard ();
 
        container = getContentPane ();
        container.setLayout(new BorderLayout());
        container.add(billard, BorderLayout.CENTER);
 
        FenetrePoints fenetrePoints = new FenetrePoints("Points", billard); // Créer la 2ème fenêtre censer afficher les points.
 
        this.setVisible(true);
    }

La classe fenetrePoints :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public class FenetrePoints extends JFrame {
 
    private Container container;
    private Billard billard;
 
    public FenetrePoints (String titre, Billard billard)
    {
        super(titre);
        this.billard = billard;
 
        //billard.setIgnoreRepaint(true); J'ai essayer cette méthode mais ça ne fonctionne pas.
 
        setBounds(800, 100, 200, 200);
 
        container = getContentPane();
        container.setLayout(new BorderLayout());
        container.add(new Compteur(this.billard));
 
        this.setVisible(true);
    }

La classe du compteur :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public class Compteur extends JPanel {
 
    private Billard billard;
    private ThreadPoints threadPoints;
 
 
    public Compteur (Billard billard)
    {
        this.billard = billard;
 
        threadPoints = new ThreadPoints(this);
        Thread t = new Thread(threadPoints);
        t.start();  
    }
 
    @Override public void paint (Graphics g)
    {
        g.drawString(" " + billard.getTotalPoints(), 20, 20);
    }  
}

Et enfin ma Thread qui réaffiche constamment les points.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class ThreadPoints implements Runnable {
 
    private Compteur compteur;
    private boolean continuer;
 
    public ThreadPoints (Compteur compteur)
    {
        this.compteur = compteur;
        continuer = true;
    }
 
    @Override public void run ()
    {
        while(continuer == true)
        {
            compteur.repaint();
        }
    }  
}

Bon maintenant mon problème c'est que les points s'affiche bien mais par contre un 2ème "billard" se dessine dans la 2ème fenêtre, or je ne l'ai jamais demandé..

J'ai remarqué en mettant la fonction repaint() à l'intérieur de la Thread en commentaire, que le paint() du compteur n'affiche pas le billard mais bien le repaint(), alors je me demande vraiment pourquoi..

Déjà merci d'avance pour vos réponses ! :/

Salut,

le contexte graphique utilisé pour dessiner (l'instance de classe Graphics) est recyclé : il est nécessaire de l'effacer pour dessiner à chaque paint(...), sinon tu peux avoir des reliquats de dessins faits dans d'autres composants.

Ceci est fait par défaut dans les composants Swing, à partir du moment ou ils sont opaque (sauf pour la JFrame).

Si tu ajoutes au début de la méthode paint(...) de ta classe Compteur un appel au super.paint(), ça devrait permettre justement d'exécuter le code par défaut du JPanel qui va effacer le contexte graphique avant que tu dessines ce que tu veux dans le panel Compteur :
Code:

1 2 3 4 5 6 7 8 9 10 11 public class Compteur extends JPanel { ... @Override public void paint (Graphics g) { super.paint(g); g.drawString(" " + billard.getTotalPoints(), 20, 20); } }
Ensuite tu ne dois pas appeler repaint() constamment, mais uniquement lorsque c'est nécessaire, donc pour ta classe Compteur, lorsque les points changent : sinon ton thread va consommer un max de cpu pour redessiner inutilement.

24/10/2013, 09h15
Gurdile

Oh oui, ça fonctionne maintenant, un grand merci pour ton explication. :)
Et je vais changer la façon dont mon Thread s'éxecute en y mettant un wait et un notify à chaque fois que des points y sont ajouté je pense, encore merci. :)
24/10/2013, 11h49
wax78

Tu pourrais faire ca, mais tu pourrais aussi supprimer carement le thread qui en l'état a mon avis ne sert a rien si ce n'est compliqué l'exercice inutilement. (C'est une boucle qui appelle un repaint sur le composant...)