Dans cette fiche...

<Retour>

Description de l'applet

Difficulté :
En fait, ce sont surtout les explications qui sont difficiles !

Résultat
Cette applet est une variante de Image2.class.

Elle charge 2 images (une image principale et une image de fond), et les affiche en superposition.
La nouveauté est l'utilisation du MediaTracker pour afficher les images une fois qu'elles sont complètement chargées, et non par morceaux.

 Votre navigateur n'est pas compatible Java !

Qu'est-ce que le MediaTracker ?

On l'a vu dans les exemples précédents : Java peut afficher des images alors que celles-ci ne sont pas encore complètement chargées via Internet. Dans ce cas, le lecteur de la page HTML voit les images apparaître par morceaux à l'écran, en fonction de leur arrivée. Dans certains cas, vous pouvez garder ce principe : votre lecteur patientera en voyant qu'il se passe quelque chose à l'écran.

Dans d'autres cas, vous aurez besoin d'afficher les images seulement lorsqu'elles sont arrivées sur l'ordinateur du lecteur. Une technique pour cela consiste à utiliser le MediaTracker.

Le MediaTracker est une sorte de surveillant : vous lui listez les images en cours de chargement, et en contrepartie il peut vous indiquer lesquelles sont arrivées, lesquelles ont provoqué une erreur, etc.
Vous pouvez ensuite, dans la méthode paint(), vérifier l'état du MediaTracker avant de lancer l'affichage.

J'ai supposé dans la suite que vous êtes familier de la syntaxe du langage C.
Si certains passages vous semblent confus, dites-le moi !

Listing de l'applet

// --------------------------------------------------
// Image3
// Utilisation du MediaTracker pour le chargement 
// d'images en Java
// --------------------------------------------------
import java.applet.*;
import java.awt.*;
public class Image3 extends Applet
{
	// Buffer pour l'image de fond
	Image fond;
	// Buffer pour l'image principale
	Image im;
	
	// MediaTracker, pour suivre le chargement des images
	MediaTracker mt=null;
	

	// --------------------------------------------------
	// INITIALISATION DE L'APPLET
	// --------------------------------------------------
	public void init()
	{
		// Couleur de fond de l'applet en blanc
		setBackground(Color.white);
		// Chargement de l'image de fond
		fond = getImage(getCodeBase(), "bkgGrisRelief.gif");
		// Chargement de l'image principale
		im = getImage(getCodeBase(), "smiley.gif");
		// Initialiser le MediaTracker
		mt = new MediaTracker(this);
		// Démarrer le suivi du chargement d'images
		mt.addImage(im, 0);
		mt.addImage(fond, 0);
	}

	// --------------------------------------------------
	// AFFICHAGE
	// --------------------------------------------------
	public void paint(Graphics g)
	{
		// Sortir si les images ne sont pas complètement chargées
		if (!mt.checkAll(true))
		{
			g.drawString("Chargement en cours...", 10, 20);
			repaint(100);
			return;
		}
		
		// Dessin de l'image de fond
		// Le fond est dessiné 3 fois pour couvrir l'applet
		g.drawImage(fond, 0, 0, this);
		g.drawImage(fond, 100, 0, this);
		g.drawImage(fond, 200, 0, this);
		// On dessine l'image en x=0 et y=0
		g.drawImage(im, 0, 0, this);
		// Idem, en x=130 et y = 20
		g.drawImage(im, 130, 20, this);
	}
}

Le listing en détail...

Les lignes non commentées ont déjà été traitées dans les exemples précédents.

// MediaTracker, pour suivre le chargement des images
MediaTracker mt=null;
On crée un objet MediaTracker, qu'on appelle mt (ce qui est aussi innovant que Médor pour un chien) et qu'on initialise à null. C'est cet objet à qui on va demander de suivre le chargement des images.
  
// Initialiser le MediaTracker
mt = new MediaTracker(this);
Le MediaTracker est initialisé.
Le paramètre this indique le composant sur lequel seront tracées les images. En l'occurrence, la zone d'affichage standard de l'applet.
  
// Démarrer le suivi du chargement d'images
mt.addImage(im, 0);
mt.addImage(fond, 0);
On ajoute les 2 images au MediaTracker, grâce à la méthode addImage(). Ainsi, le MediaTracker sera en mesure de suivre l'avancement du chargement de l'image principale et de l'image de fond.

La méthode addImage() reçoit 2 paramètres :

  • Une image à charger (un objet de type Image),
  • Une valeur numérique (de 0 à combien vous voulez !), qui indique l'importance de l'image (0 étant le plus important). Dans notre cas, nous donnons aux 2 images la même importance.
  
// Sortir si les images ne sont pas complètement chargées
if (!mt.checkAll(true))
{
	g.drawString("Chargement en cours...", 10, 20);
	repaint(100);
	return;
}
Au début de la méthode paint(), on vérifie l'état du MediaTracker (à savoir : est-ce que toutes les images sont arrivées ?).
La méthode checkAll() du MediaTracker renvoie true si c'est le cas, et false si les images sont encore en chargement.
Le true entre parenthèses indique qu'il faut éventuellement charger les images en attente.

Si certaines images ne sont pas arrivées, mt.checkAll(true) donne comme résultat false. Sa négation (par le point d'exclamation) est donc true. Limpide, non ?
Dans ce cas, on affiche simplement le message "Chargement en cours", on demande de redessiner l'applet, et on s'arrête (d'où le return;).
Le repaint(100) force Java à redessiner l'applet dans 100 millisecondes. Si vous l'oubliez, les images seront chargées correctement, mais le MediaTracker ne préviendra pas Java que tout est terminé.
En clair, il n'y aura pas de repaint() automatique, et le message "Chargement en cours" restera à l'écran.

Attention : la méthode checkAll() renvoie également true si le chargement des images a été interrompu, ou s'il y a eu des erreurs de chargement. Le MediaTracker possède d'autres méthodes plus fines qui permettent de détecter les erreurs (par exemple, isErrorAny(), qui vaut true si une erreur s'est produite).

Intégration de l'applet dans la page

Voici le code qui a été utilisé dans cette page HTML pour faire apparaître l'applet :

<applet code="Image3.class" width=250 height=90>
Votre navigateur n'est pas compatible Java !
</applet>

Pour plus de précisions sur l'intégration d'une applet, cliquez ici.