Bonjour,

Dans le cadre d'un TP en Java où l'on me fournit le code d'une application graphique, je dois remplacer l'affichage passif actuel par un affichage actif. Cependant, même en faisant des recherches et pour le peu d'informations que j'ai trouvé, je ne vois pas la différence en termes de code.

Apparemment avec l'affichage passif, le rendu est effectué par l'OS où c'est lui qui redessine quand c'est nécessaire et fait l'appel à paint() tout seul après que le programmeur est fait l'appel à repaint() lors de la mise à jour. En affichage actif, le rendu est fait dans un boucle où on a le total contrôle sur ce qui doit être redessiné.

Globalement j'ai 2 classes :
- un modèle avec un run() qui contient l'appel à setChanged() et notifyObservers().
- une vue avec un update() qui contient l'appel à repaint() qui lui-même fait appel à paint() que je redéfinis et qui dessine les éléments graphiques de l'application.

La seule chose que j'ai compris pour le moment, c'est qu'à la place de faire appel à repaint() dans la mise à jour, je fais appel à une fonction myRenderingLoop() par exemple que je crée et qui doit contenir quelque chose comme ça d'après la documentation :

public void myRenderingLoop() {
    while (!done) {
        Graphics myGraphics = getPaintGraphics();
        // Draw as appropriate using myGraphics
        myGraphics.dispose();
    }
}

et où le contenu de la fonction devrait être le même que celui que je faisais dans paint(). En bref, j'ai pas trop compris comment ça marche... Quelqu'un pourrait-il m'expliquer en clair et également me donner un petit exemple d'implémentation de code que je devrais faire car je ne comprends pas

Première fois que je rencontre ces termes.
Je serai aussi intéressé par une définition.

je n'ai jamais entendu ces termes pour parler de ces deux modes d'affichages. mais en fait je n'ai jamais entendu de nom poir ces deux modes. donc c'est peut etre leur vrai nom.

en general en passif, le systeme (ici awt certainement) a un thread qui fait attention a ce qu'il faut redessinner. et qui appelle paint/repaint comme il faut. je n'ai aucune idee de comment desactiver ce mecanism.

Pareil, j'ai jamais entendu parler d'affichage actif/passif. Peut-être que le "actif" fait référence à une boucle infinie qui va appeler le repaint toutes les x millisecondes (avec attente active donc) et que le "passif" fait référence à un mécanisme d'observers ? Ça me parait plus vraisemblable comme explication que "paint manuel/paint par l'OS" car je pense pas que cette nuance existe en Java

Je vois pas comment une boucle infinie fonctionnerait en fait, malgré que ce soit comme ça apparemment que l'affichage actif se fait... je ne comprends tout simplement pas.

Dark-killer, c'est fait comme ca dnas les jeux video single thread. Tu as basiquement une boucle infini qui fait

while (1) {
  gather_input();
  update_physics();
  render();
}

En general c'etait un tout petit plus inteligent pour gerer le frame rate et cie. Mais la base est la. Apres comment integrer cette idee dans la boucle d'affichage de awt, aucune idee.

Je pense tout simplement qu'un affichage actif n'est défini que par le fait que l'appel à repaint() (qui elle-même appelle update() pour effacer les composants actuels et qui elle-même appelle paint() pour dessiner les nouveaux composants) ne se fasse pas à chaque tour de boucle et qu'il n'y a pas de façon type d'implémentation de la nouvelle méthode myRenderingLoop() que j'ai crée.

En d'autres termes je redéfinis bien moi-même la méthode d'affichage des composants, bien que la nouvelle méthode écrite contienne la même chose que paint() initialement utilisée, à la différence qu'il faille en plus appeler explicitement une méthode qui efface les composants, une substitution à update().

Merci tout de même de vos réponses