Discussion :

[Mayhem]

Bonjour,
je vais essayer de faire simple : j'ai une classe qui est dérivée de JFrame dans laquelle je redéfinis la méthode Paint(). J'aimerais créer une autre classe qui serait un Thread et qui, en quelque sorte, écouterait la méthode Paint() de ma JFrame dérivée. Est-ce possible de faire cela?
Peut-être y-a-t-il mieux à faire?

Merci à vous

a+

[spekal]

Peut-être y-a-t-il mieux à faire?

Pour faire quoi ? J'ai l'impression que ton objectif est un peu fumeux, pourrais-tu l'exprimer en termes banaux, et non en termes de threads et de paints ?

[Scorpyosis]

Pour le "y a t'il mieux a faire ?" ça dépend de ce que tu veux faire !
Sinon le plus simple pour ce que tu veux faire, c'est d'utiliser Observer/Observable

[Pierre Maurette]

Bonjour,
Je suis noob en Java, mais je suis en plein dans les écoutes. Il n'y a aucun problème pour écouter une méthode paint(). En revanche, ce n'est peut-être pas une bonne idée, puisque cette méthode, si j'ai bien compris, va être appelée par l'OS "quand il veut". Il faudrait peut-être écouter une méthode en amont qui modifie les "données" à afficher. Sinon, il suffit me semble-t-il de faire comme ça:
D'abord, le thread de surveillance (j'ai fait une classe runnable à part, ce n'est qu'un exemple) :

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
package votrepackage;
 
public class testSpy implements Runnable {
 //**** Déclaration des variables private ****
 private Thread thisThread_;
 private Object synchro_;
 
 public testSpy(Object o) {
   synchro_ = o;
 }
 
 public synchronized void run() {
   Thread thisThread = Thread.currentThread();
   try {
     while (thisThread == thisThread_) {
       System.out.println(
           "Passé dans le thtread testSpy ------------------------ ");
       synchronized (synchro_) {
         synchro_.wait();
 
       }
     }
   }
   catch (Exception exception) {
     exception.printStackTrace();
   }
 }
 
 public void start() {
   thisThread_ = new Thread(this);
   thisThread_.start();
 }
}

Ensuite, vous modifiez votre paint():

Code :

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

1
2
3
4
5
6
7
8
9
public synchronized void paint(Graphics g) {
    testSpy ts = null;
    if(ts == null){
      new testSpy(this).start();
    }
 
    /* blah */
 
    notify();

Vous pouvez lancer testSpy dans paint() ou ailleurs, ce qui serait peutêtre mieux étant donné qu'il vaut mieux optimiser les paint(). Enfin, je pense.
Voilà, j'espère que ce n'est pas trop idiot, en tout cas ça marche.

Pierre

[Mayhem]

En fait, je dessine sur ma JFrame quelques petites choses, et j'ai un thread à côté qui doit dessiner sur la même JFrame d'autres petites choses.
Le problème est que la méthode Paint de ma JFrame est appelé à chaque mouvement de souris, et donc tout est redessiné à ce moment là. Or il faudrait évidement qu'à ce moment là, mon thread redessine aussi sa collection d'objets.

J'espere avoir été plus clair

Pierre Maurette, merci pour ta solution, je vais étudier cela de plus près.

[Pierre Maurette]

En fait, je dessine sur ma JFrame quelques petites choses, et j'ai un thread à côté qui doit dessiner sur la même JFrame d'autres petites choses.
Le problème est que la méthode Paint de ma JFrame est appelé à chaque mouvement de souris, et donc tout est redessiné à ce moment là. Or il faudrait évidement qu'à ce moment là, mon thread redessine aussi sa collection d'objets.

Ce n'est certainement pas la bonne solution. Votre paint() utilise des objets (pas nécessairement au sens POO) persistants, en fait le plus souvent des propriétés de la classe dérivant JFrame et contenant paint(). En fait, redessin oblige, ces objets doivent être d'accès rapide, prémâchés, c'est à dire que s'ils sont déduits par des calculs d'autres données, ces calculs doivent être menés hors de la méthode paint().
Votre thread doit donc modifier ces objets, tout comme la procédure d'affichage principale. Bien sûr, chaque modification se termine par un appel direct à paint(), pour que le modification soit prise en compte immédiatement.