Discussion :

[Cbonniot]

Bonjour, j'ai juste une petite question à propos de la chaine d'appel de paint() que fait le système.

Si par exemple, on a un système de menu qui contiennent des boutons qui contiennent à leur tour des animations (tous des Container).
Si chacune de ces classes ont une fonction paint() dans laquelle les dessins sont fait ainsi qu'un appel à super.paint().
Est ce que pour mettre tout à jour, il faut appeler la fonction repaint() dans chacune des classes (menu, bouton, animation) ou alors un appel à repaint() dans l'animation suffit ?

En gros ma question c'est, est ce que le système fait des appels de lui même à des paint() qui ne sont pas dans la classe de départ ou alors il ne redessine que l'objet appelant.

Je pense qu'il remonte effectivement ces appels de lui même mais c'est pour être sur et je n'arrive pas à tester ca correctement.

Est ce que l'inverse est vrai ? C'est à dire, est ce que si l'appel à repaint vient d'un composant père, il va être retransmis au composant fils.

Si j'ai besoin de savoir ca, c'est par soucis d'optimisation afin d'effectuer le moins d'appel à paint() possible.

Merci d'avance de votre aide.

[uhrand]

on a un système de menu qui contiennent des boutons qui contiennent à leur tour des animations (tous des Container).

Les composants légers sont dessinés de l'arrière plan vers l'avant plan, avec prise en charge de la transparence. Un "Container" doit faire appel à "super.paint" dans sa méthode "paint" pour permettre aux enfants légers de se dessiner. Quand notre programme appelle la méthode "repaint" sur un composant, le système remonte l'hiérarchie des composants pour trouver le composant-père lourd et redessine tous ce qui se trouve en dessous. Pour optimiser le processus de dessin, on peut utiliser la méthode "repaint" avec les arguments qui définissent le rectangle à redessiner et ne dessiner que ce qui chevauche le rectangle "clip" dans la méthode "paint" (Graphics#getClipBounds).

[sinok]

Pourquoi cherches tu à limiter les appels à paint?

Si c'est car tu as des animations, alors tu as un problème de conception. Une animation ne doit pas être controlée en fonction des exécutions de paint, mais par rapport au temps.

De fait il faut prendre en considération le fait que la méthode paint ne va s'occuper que des régions considérées comme dirty dans l'interface. C'est le rôle du repaintManager.

Un peu de lecture: http://java.sun.com/products/jfc/tsc/articles/painting/

[uhrand]

Dans AWT, des "repaint" multiples peuvent être consolidés en un seul appel. Il y a donc déjà un automatisme en place permettant de réduire le nombre d'appels à la méthode "paint". Si on a besoin d'optimiser encore plus les composants avec affichage compliqué, c'est surtout à l'intérieur de la méthode "paint" qu'on peut le faire en ne dessinant que ce qui chevauche le rectangle "clip". Ceci suppose également l'emploi de la méthode "repaint" avec les arguments qui définissent le rectangle à redessiner.

[Cbonniot]

Bonjour, merci pour vos réponses.

J'utilise effectivement la fonction repaint uniquement sur le rectangle qui m'interesse. Mes animations ne se font pas par rapport à paint mais elles appellent paint lorsqu'elles changent, elles sont donc dépendante du temps.

La raison pour laquelle je veux limiter les appels à paint, c'est parce que je travaille sur des platines de lecture Blu-Ray et qu'elles n'ont pas toutes les mêmes performances et certaines d'entres elles ne peuvent pas afficher suffisamment rapidement ce que je veux et alors j'obtiens des clignotements (j'utilise le double buffering). Je voulais donc savoir a quel endroit je devais appeler repaint pour être sur que tout ce que je veux soit redessiner et en même temps ne faire qu'un appel.

http://java.sun.com/products/jfc/tsc/articles/painting/

J'avais déja lu ce lien, il est très bien merci.

Donc si je fais l'appel depuis le composant père lourd ca fonctionne mais si c'est le composant père léger ?

Si je pose la question ce n'est pas parce que j'ai la flemme d'essayer, c'est parce que les lecteurs ne réagissent pas tous de la même manière (du fait qu'ils ne suivent pas tous la norme de la même manière) et donc j'ai besoin d'être sûr que la méthode est bonne.

Merci.

[sinok]

Le truc c'est que tes animations elles déclenchent l'appel à paint, ce qui est le problème.

Le concept de base est que l'appel à paint devrait être fait de fonction régulière (toutes les X millisecondes) et que les animations ne fassent que préparer les éléments du paint en fonction d'une Timeline. Donc qu'il y ait une désynchronisation entre les animations et l'exécution du paint. Le truc qu'il faut c'est que l'animation sache quoi dessiner en fonction d'un temps. C'est à dire qu'à un moment T donné l'animation sache exactement à quelle position et de quelle couleur elle doit dessiner par exemple. Donc un code en fonction d'un intervalle de temps.

En procédant de cette façon celà te permet de garder un taux de repaint constant tout en ayant plusieurs animations tournant en parallèle.

Pour bien faire, il faut que les animations ne soient pas responsables de l'appel à paint, mais que l'appel à paint soit régulé au niveau du temps.

[Cbonniot]

Donc en fait que, par exemple, je remplisse un tableau d'images avec des coordonnées et que toutes les X millisecondes j'appelle paint qui va se charger d'afficher ce qu'il y a dans ce tableau ?

Merci.

[Cbonniot]

J'ai modifié ma gestion des animations, merci.

Si par exemple je veux afficher un menu qui contient des boutons et des animations, mais je ne veux pas que ca se déroule comme ceci : j'ajoute le menu, il se dessine, j'ajoute les boutons, ils se dessinent, et enfin idem pour les animations. Je voudrais que ca soit j'ajoute tout, et ensuite, à partir du menu je lance le dessin.
Va t-il tout afficher ?
Si oui comment puis-je faire ca car l'appel à "setVisible(true)" provoque automatiquement un appel à paint, et si je ne met pas cette ligne, rien ne se dessinera car il ne sera pas en état visible.

Merci.

[uhrand]

J'ai du mal à imaginer ton interface et ton implémentation. Peux-tu faire un court exemple indépendant et compilable pour nous permettre de proposer des solutions concrètes?

Merci.

[Cbonniot]

Bonjour,

Je dois vous parler du projet que je fais, je fais une généralisation de la création de Blu-Ray vidéo pour avoir le moins possible la nécessité de coder lors de cette création. Les animations seront réalisées par l'utilisateur. Je les récupère grace à un classLoader, les classes chargées devront étendre Animatable.

Ne faites pas attention aux petites erreurs de code et excusez moi pour celles ci, j'ai tout réécris à la main.
Les "bounds" sont bien définis.

Voila le plus succinct que je puisse faire. Il va surement manquer des choses donc si vous avez des questions.

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
 
public class Menu extends Container
{
   private ArrayList imagesList_;
   private ArrayList buttonsList_;
 
// ... le Constructeur initialise la liste d'image et la liste de boutons et ajoute le menu au composant père lourd
 
   private activeMenu() {
      this.setVisible(true);
      this.drawButtons();
   }
 
   private drawButtons() {
      // Boucle sur la liste de boutons buttonsList_ et appel de la méthode draw de chacun des boutons
   }
 
   public void paint(Graphics g){
      // Une boucle ou l'on dessine toutes les images qu'il y a dans la liste imagesList_.
   }
}

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
 
public class Button extends Container {
   private ArrayList imagesList_;
   private Animatable animation_;
 
   // Le constructeur initialise la liste d'images et ajoute le bouton au composant Menu.
   // Gestionnaire d'évènement
 
   private void someEvent(Event e){
       Thread t = new Thread(this.animation_);
       t.start();
   }
 
   public void draw() {
      this.setVisible(true);
   }
 
   public void paint(Graphics g) {
      // Boucle sur la liste d'image et affichage de celles ci
   }
}

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
 
public abstract class Animatable extends Container implements Runnable {
 
// Les animations sont à faire par l'utilisateur
   public void run(){
      while (this.loop_) { // loop_ est un booléen qui me permet d'arrêter l'animation, je pourrait très bien mettre un Timer ici, mais mon problème reste le même.
         doAnimation();
         this.getParent().repaint(damagedZone.x, damagedZone.y, damagedZone.width, damagedZone.height); // damagedZone est un rectangle mis à jour dans doAnimation qui donne le rectangle à redessiner.
// C'est le seul repaint que je fais, j'ai essayé de faire l'appel sur un composant qui est de type HScene qui est en fait le heavyweight de l'application mais ca ne marche pas, l'affichage n'est pas mis à jour.
      }
   }
 
   public abstract void doAnimation();
   public abstract void setDamagedZone(Rectangle damagedZone);
}

C'est à peu près tout, mon problème c'est lorsque je fais les setVisible(true), il appelle forcément les fonctions paint des objets et ca multiplie donc ces appels, je voudrais que le dessin ne soit appelé qu'une seule fois lors de l'activation du menu,et à chaque fois que l'animation modifie le contexte graphique. J'ai essayé de changer de place les setVisible(true) et de les mettre après le dessin des sous composants, mais tout ne s'affiche pas si je fais ca.

Il faut savoir que les platines de lecture Blu-Ray (mis à part la PS3) sont, pour la plupart peu performantes, n'ont pas beaucoup de mémoire et ont un faible taux de rafraichissement, c'est pour ca que je dois limiter un maximum les repaint. En ce qui concerne les update(), je ne peux pas trop les utiliser car je ne connais pas à l'avance comment l'arborescence du disque et des menus est faite.

Voila j'espère que j'ai été clair et si vous avez des questions.

Merci beaucoup pour votre aide.