Version imprimable
Bjr à tous,
cela fait un petit moment que je manipule des JPanel, et je l'ai toujours fait selon le schéma suivant:
- surcharge de paintComponent(Graphics) pour dessiner dans le panel
- appel a repaint() pour mettre à jour le panel
Cependant, je vois que beaucoup de monde utilise aussi les méthodes paint() et update() pour réaliser le même travail que moi....
Quelqu'un peut-il m'expliquer la différence entre les deux manières de procéder ?
:merci:
:wink:
A l'époque , j'avais vu un petit schéma avec quelle méthode appelle quoi et dans quel ordre, quoi mettre où et quelle méthode appeler... Ca serait une super contribution si un volontaire... :mrgreen:
Bonjour à tous,
Bon si je me rappelle bien, voilà comment tout ça fonctionne :
la methode Paint d'un composant appelle les deux methodes suivantes :
- paintComponent qui dessine le composant.
- paintChildren qui appelle la methode paint de tous les composants contenus dans ce container (si c'en est un.)
La methode repaint appelle simplement paint, la methode update est une alternative à cette methode pour certains composants genre les JFrame.
toujours surcharger la méthode paint() elle a l'avantage de marcher aussi bien sur les composants awt que swing c'est pour ca que beaucoup n'utilisent pas le paintComponent() de swing.
architecture de l'affichage graphique:
- paint() (invoqué implicitement par le constructeur d'une Frame, Canvas, ...)
- update()
- paint()
- update()
- paint()
- update()
- paint()
update() n'est pas obligée d'etre surchargée (réécrite par le soin du programmeur) mais si c'est le cas elle permet quelques possibilités comme le nettoyage approprié d'une zone de clipping, etc...
exemple d'une méthode pour limiter le clipping sur des applications peu gourmandes en process graphique:
cependant meme si l'architecture impose l'appel a la méthode update() on ne l'appelle jamais nous meme, elle est appelée directement par le process Java (sinon il peut y avoir des bugs! ou des plantages!)Code:
2
3
4
ce qui donne cette architecture de programmation :
- affichage par le paint() invoqué implicitement par le constructeur (setVisible = true ) sur le composant
- repaint()
- repaint()
- repaint()
- repaint()
donc finalement cela revient au même, de dessiner avec paint ou paintComponent et de mettre a jour avec repaint ou update? (bon a part le truc awt/swing, mais je fais que du swing donc voilà)
maintenant tu me dis (narko) qu'il ne faut pas appeler soi-même la méthode update sous peine de plantage... est-ce la même chose avec repaint ? quoi appeler lorsque l'on a des mise a jour à faire ?
Le prophete, tu as dis que repaint appelle paint ? peut-être, mais elle appelle aussi paintComponent, car cela marche très bien selon mon architecture... ou bien est-ce paint qui appelle paintComponent ?
moi j'utilisais toujours paintComponent car c'est comme cela que c'est expliqué dans mon livre (Programmer en java 2ème edi.)... D'ailleurs il n'aborde nulle part l'utilisation de paint et update...
en tout cas, :merci:
:wink:
Bon c'est vrai que j'ai pas été très clair , je vais essayer d'être un peu plus précis.
La méthode paint d'un composant appelle dans l'ordre :
- paintComponent qui dessine effectivement ce composant
- paintBorder qui dessine les bordures
- paintChildren qui dessine les composants contenus dans ce container (si c'en est un) en appelant leur méthode paint.
Donc en gros, si tu as un composant c1 qui contient deux composants c2 et c3, c1.paint() donne :
- c1.paintComponent(g);
- c1.paintBorder(g);
- c1.paintChildren(g)
et c1.paintChildren(g) donne :
- c2.paint(g) => c2.paintComponent(g) et c2.paintBorder(g);
- c3.paint(g) => c3.paintComponent(g) et c3.paintBorder(g);
La méthode repaint appelle la méthode paint, donc les trois methodes decrites ci-dessus. C'est donc normal que ton architecture marche tres bien.
En ce qui concerne les mises a jour, le mieux est de toujours appeler la méthode repaint, de toute façon elle appelera paint (donc ça marchera aussi bien avec swing que avec awt), mais elle a l'avantage de passer par un RepaintManager qui se charge de "scheduler" (désolé pour ce barbarisme) l'affichage. Perso, je me suis jamais soucié de la méthode update() et j'ai jamais eu de problèmes.
Maintenant, en ce qui concerne les méthodes que tu redéfinis pour dessiner, tu peux surcharger paintComponent (ça marchera que pour les composants swing, comme le disait narkotik) ou paint (qui marchera pour les deux), ça dépend des composants que tu utilises.
Toutes (ou presque ! ) les subtilités des paints et updates sont expliquées à Painting in AWT and Swing.
Lorsque tu l'auras lu, s'il y a encore des points obscurs, à ta dispo :frenchy:
OK je cerne mieux les dépendances maintenant :wink:
:merci:
Le Prophète a dit ceci:
Il a oublié d'ajouter qu'il est impératif de comprendre ça si on veut faire la 2D!Citation:
La méthode paint d'un composant appelle dans l'ordre :
- paintComponent qui dessine effectivement ce composant
- paintBorder qui dessine les bordures
- paintChildren qui dessine les composants contenus dans ce container (si c'en est un) en appelant leur méthode paint.
Donc en gros, si tu as un composant c1 qui contient deux composants c2 et c3, c1.paint() donne :
- c1.paintComponent(g);
- c1.paintBorder(g);
- c1.paintChildren(g)
et c1.paintChildren(g) donne :
- c2.paint(g) => c2.paintComponent(g) et c2.paintBorder(g);
- c3.paint(g) => c3.paintComponent(g) et c3.paintBorder(g);
La méthode repaint appelle la méthode paint, donc les trois methodes decrites ci-dessus. C'est donc normal que ton architecture marche tres bien.
Et Merci encore je crois que ce sujet a bien sa place ici... #generationForum
Citation:
Attention: Peut-être c'est faux!! :mur: