ATTENTION Cette explication est synonyme de prise de tête.

N’oubliez pas de prendre vos cachets avant pendant et après.
Je décline toute responsabilité en cas d’incident.

Avant d’aborder l’explication du chargement en AS3 de fichiers multiples il faut connaître un minimum de vocabulaire et de notion.
(Cette explication de texte est à destination de grand débutant ou de débutant en programmation)
I – occurrenceUne occurrence n’est rien d’autre qu’une copie d’un objet. Il est possible de distinguer 2 catégories d’objet. La première, sont les symboles que vous voyez dans votre bibliothèque (MovieClip, graphique, bouton, composant). La seconde, sont des objets virtuels de programmation, que vous ne voyez pas mais qui pourtant existe dans flash par exemple l’objet Loader.
II – boucleEn informatique une boucle c’est faire un nombre fini de fois quelque chose. Cela permet par exemple de demander à flash de charger X fichiers externes sans avoir à écrire et gérer 5 occurrences de l’objet Loader et URLRequest.
III – fonctionC’est une espèce de boite dans laquelle nous mettons des lignes de code qui peuvent être réutilisées autant de fois que besoin par un simple appel au nom de cette fonction. Cela permet de ne pas avoir à réécrire le même code x fois.
IV – asynchroneLe mode asynchrone dans flash c’est qu’entre le moment ou je demande quelque chose au serveur (l’hébergeur de mon site web) et le moment où cette chose est disponible il se passe un certain temps dont je n’ai pas la maitrise (fluctuation du débit internet).
Par exemple entre le moment ou je demande une image jpg et le moment ou je l’affiche, mon animation continue. Je dois donc être prévenu de la disponibilité de cette image par flash pour pouvoir agir dessus. Cela s’appelle un événement.
V – évènement et écouteur d’évènementLa programmation traditionnelle est linéaire c’est à dire que les instructions s’exécutent les unes derrière les autres. Cela oblige l’utilisateur à suivre le cheminement que le développeur lui impose.
La programmation évènementielle permet à l’utilisateur d’utiliser l’application que lui propose le développeur dans le sens qu’il souhaite.
Le problème c’est que le développeur doit pouvoir gérer des évènements c’est à dire des actions de l’utilisateur dans un ordre aléatoire. C’est pour cela que flash propose la notion d’évènement et d’écouteur d’évènement.
Un évènement dans flash c’est par exemple le fait que le fichier, dont je demande le téléchargement, devient disponible. Pour gérer cela, il faut que je programme une fonction qui va réagir a cet événement et que je mette en œuvre un écouteur (voyez un écouteur comme étant une oreille) qui déclenchera l’exécution de cette fonction dès que le fichier est disponible.
Vous êtes toujours là ?
VI – téléchargementLors du téléchargement d’un fichier externe, il se passe beaucoup de chose. Le chargement débute, il progresse, puis il se termine et enfin le fichier devient disponible. Mais il peut aussi y avoir un problème pendant le téléchargement comme une interruption de la connexion internet ou l’absence du fichier sur le serveur. Nous allons devoir prendre en considération chacune des étapes qui sont autant d’événement.
Bien après les préliminaires voyons comment architecturer un site Web statique en AS3
Principe :Il faut décomposer le site en petit bout pour ne pas avoir à imposer aux visiteurs des temps d’attente trop long et des barres de téléchargement. En effet l’un des reproches que j’entends le plus fréquemment quand je propose à mes clients un site full flash c’est et je cite :
Oui flash c’est le truc où il faut attendre avant de pouvoir regarder.
Une organisation possible est de créer par exemple un fichier swf qui contient « l’intelligence » du site c’est à dire la programmation puis un fichier swf avec le décor du site, un autre avec le menu du site et un fichier swf par page du site.
L’avantage c’est que nous allons pouvoir charger que les éléments que nous souhaitons sans imposer aux visiteurs le téléchargement du site complet.
L’inconvénient c’est qu’il faut le programmer en AS3
Dans cette explication je vous montre le principe mais à vous de l’adapter à vos besoin. Je ne compte pas assurer le SAV.
L’organisationLe premier fichier à créer c’est celui qui doit contenir l’intelligence du site et qui doit être le point d’entrée de votre site. Je le nomme par exemple : debut.swf
Dans ce fichier je mets en place un système de gestion basé sur la logique suivante :
Dans une variable tableau (Un tableau est une espèce d'armoire ou chaque étagère porte un numéro de 0 à x) je stocke le nom de l'ensemble des fichiers swf que je souhaite télécharger (1 par étagère).
Puis par une boucle j’appelle les fichiers les uns après les autres en créant à la volée une occurrence (copie) de l’objet loader (qui n'est pas autre chose qu'un MovieClip spécialisé dans le chargement de fichiers externes) et de l’objet URLRequest (qui permet d'indiquer l'URL du fichier à charger).
Chaque téléchargement doit être géré au minimum sur l’événement Event.INIT qui est celui m’indiquant que le fichier téléchargé est disponible.
Dès que cet évènement arrive, il devient possible d’afficher dans la liste d’affichage (addChild) le fichier swf.
Il est aussi intéressant de pouvoir indiquer à l’utilisateur que des chargements sont en cours. Pour cela il faut aussi gérer (mais ce n’est pas indispensable) la progression du téléchargement (ProgressEvent.PROGRESS)
Comme nous sommes en période de solde

, j’ai aussi pris en compte la gestion des évènements Event.OPEN début du téléchargement, Event.COMPLETE le fichier est complètement chargé et les erreurs IOErrorEvent.IO_ERROR
Je profite de l'événement Event.COMPLETE pour détruire les écouteurs afin d'économiser les ressources machine. C'est pas la peine d'écouter un événement qui est terminé.
Mais je le répète seul l’événement Event.INIT est obligatoire.
Je n’ai besoin, pour réaliser cela, que d’un calque et d’une image clé dans laquelle je vais écrire le code suivant :
Code :
//============================================================
/*Le système mis en place ici permet grâce à une boucle d'avoir un nombre de ligne de code
constant quel que soit le nombre de fichier à charger*/
//Liste des fichiers à charger au démarrage du site (le décor, le menu et éventuellement la page d'accueil)
var fichierscible:Array = new Array("decor.swf","menu.swf","page1.swf");
//boucle de chargement des fichiers
for (var i:int=0; i<fichierscible.length; i++) {
/* Lors de la création d'une occurrence de l'objet Loader, il est
possible de lui donner un nom unique permettant ainsi de le distinguer par la suite lors d'un chargement multiple*/
//Ici le nom du chargeur c'est le nom du fichier sans extension (decor, menu, page1)
var nomDuChargeur:String=fichierscible[i].substr(0,fichierscible[i].indexOf("."))
//appel à la fonction de chargement
chargeurGeneral(nomDuChargeur, fichierscible[i],desQueDisponible)
}
//chargeur(nomDuChargeur, URLfichierACharger,desQueDisponible)
function chargeurGeneral(nomDuChargeur:String,URLfichierACharger:String,desQueDisponible:Function):void {
/* Le principe de la classe loader
Chaque état du téléchargement est pris en charge par un écouteur et une fonction particulière.
Ensuite il suffit de créer une occurrence (copie) de la classe loader et URLRequest pour télécharger un fichier externe
*/
//Création du chargeur
var charger:Loader=new Loader();
//Nommer le chargeur
charger.name = nomDuChargeur;
//Construction de la requête
var atteindreURL = new URLRequest(URLfichierACharger);
//Lancement du chargeur
charger.load(atteindreURL);
/*Mise en place des écouteurs sur le chargeur;
L’événement open arrive en premier.
L’événement ioError ou securityError arrive ensuite s’il est impossible de charger le fichier
ou s’il se produit une erreur lors du processus de chargement.
Arrive ensuite l’événement progress qui est déclenché continuellement lors du chargement du fichier.
Le suivant est l’événement complete qui arrive lorsque le chargement d’un fichier est terminé,
mais AVANT QU'IL NE SOIT UTILISABLE.
Le dernier evénement est init qui arrive lorsque vous pouvez manipuler le fichier.
Cet événement arrive TOUJOURS avant le complete.
Dans les fichiers SWF en diffusion continue, l’événement init risque de se produire bien avant l’événement complete.
*/
//Début du téléchargement
charger.contentLoaderInfo.addEventListener(Event.OPEN, debutTelechargement);
//Lorsque le fichier est en coursde téléchargement;
charger.contentLoaderInfo.addEventListener(ProgressEvent.PROGRESS, telechargementEnCours);
//Lorsque le fichier est prêt à être utilisé mais pas complètement chargé
charger.contentLoaderInfo.addEventListener(Event.INIT,desQueDisponible );
//Lorsque le fichier est complètement chargé (de l'image 1 à l'image 10);
//Là il faut penser à détruire les ecouteurs
charger.contentLoaderInfo.addEventListener(Event.COMPLETE, finDuChargement);
//En cas d'erreur de téléchargement;
charger.contentLoaderInfo.addEventListener(IOErrorEvent.IO_ERROR, indiquerErreur);
}
//Les fonctions qui réagissent pendant le téléchargement
//Gestion du début de téléchargement (facultatif)
function debutTelechargement(evenement:Event):void {
trace("Début de téléchargement : " + evenement);
}
//Gestion de la progression du téléchargement (facultatif)
function telechargementEnCours(evenement:ProgressEvent):void {
trace("Progression: déjà disponible " + evenement.bytesLoaded + " sur un total de " + evenement.bytesTotal);
}
//Gestion de la fin du téléchargement la première image clé du fichier swf chargé est disponible (OBLIGATOIRE)
function desQueDisponible(evenement:Event):void {
trace("Première image clé disponible: " + evenement.currentTarget.name);
//ici la suite du code en fonction du nom du chargeur
//Récupération du nom du Loader ayant terminé sont boulot
var chargeurActif:Loader=evenement.target.loader
/*Affichage sur la scène.
soit directement soit dans un Sprite ou un MovieClip*/
addChild(chargeurActif);
//en fonction du chargeur nous agissons sur :
switch (chargeurActif.name) {
case "decor" :
//Position en x et y du décor du site sur la scène
chargeurActif.getChildAt(0).x= "ici la position en x"
chargeurActif.getChildAt(0).y= "ici la position en y"
break;
case "menu" :
//Position en x et y du menu du site sur la scène
chargeurActif.getChildAt(1).x= "ici la position en x"
chargeurActif.getChildAt(1).y= "ici la position en y"
//Ici appel à une fonction gérant les boutons du menu
// A vous de la faire
break;
case "page1" :
chargeurActif.getChildAt(2).x= "ici la position en x"
chargeurActif.getChildAt(2).y= "ici la position en y"
break
}
}
//Gestion fin du téléchargement le fichier est disponible pour utilisation (facultatif mais fortement conseillé)
function finDuChargement(evenement:Event):void {
trace("Fin de téléchargement : " + evenement.currentTarget.name);
//destruction des écouteurs
charger.contentLoaderInfo.removeEventListener(Event.OPEN, debutTelechargement);
charger.contentLoaderInfo.removeEventListener(ProgressEvent.PROGRESS, telechargementEnCours);
charger.contentLoaderInfo.removeEventListener(Event.INIT,desQueDisponible );
charger.contentLoaderInfo.removeEventListener(Event.COMPLETE, finDuChargement);
charger.contentLoaderInfo.removeEventListener(IOErrorEvent.IO_ERROR, indiquerErreur);
}
//Gestion des Erreur Entrée Sortie (facultatif)
function indiquerErreur(evenement:IOErrorEvent):void {
trace("Erreur Entrée Sortie : " + evenement);
}
stop()
Ensuite il ne vous reste plus qu'à programmer les boutons du menu pour qu'ils chargent les différentes pages du site à la demande du visiteur. Il faut aussi remplacer les trace de chaque fonction par un affichage écran à destination du visiteur.
Bon courage...........