Charger un media, ou un fichier de donnée, ou des variables

Charger un SWF dans un autre SWF

Voici un tutorial sur le chargement d'un SWF depuis un autre SWF au travers d'un petit exemple de "preloader" avec la gestion des évènements Event.COMPLETE et ProgressEvent.PROGRESS (progression du chargement). Vous aurez aussi un aperçu de l'utilisation du Timer de flash.

output

Alternative content

Get Adobe Flash player

Les explications sont dans les commentaires directements :

package;

import flash.display.Loader;
import flash.events.Event; 
import flash.events.ProgressEvent; 
import flash.events.TimerEvent;
import flash.Lib; 
import flash.net.URLLoader;
import flash.net.URLRequest;  
import flash.system.ApplicationDomain;
import flash.system.LoaderContext; 
import flash.utils.Timer;
import haxe.Log;
import flash.display.Sprite;

      class Main
      {
            private var pleaseWait:Timer;
            private var loader:Loader;
            private var container:Sprite;
      		static function main()
      		{
      			new Main();
      		}
      		public function new()
      		{
      		    load("mySwf.swf");
      		}
      		public function load(url:String)
      		{
      		    /*
      		        On crée un nouveau loader en y ajoutant deux écouteurs d'évènement
      		        Event.COMPLETE > détecter la fin du chargement
      		        ProgressEvent.PROGRESS > détecter la progression du chargement
      		        
      		        On charger notre SWF externe en utilisant la méthode load() du loader
      		        en lui passant en paramètre l'url du SWF
      		    */
      		    var request = new URLRequest(url);
      		    loader = new Loader();
      		    loader.contentLoaderInfo.addEventListener(Event.COMPLETE, loadingComplete);
      		    loader.contentLoaderInfo.addEventListener(ProgressEvent.PROGRESS, progress);
      		    
      		    loader.load(request);
      		}
      		
      		
      		private function loadingComplete(e:Event)
      		{
      		
      		    /*
      		        A la fin du chargement on créé un nouveau Timer (flash.utils.Timer)
      		        1000 correspond au temps en milliseconde que dure un cycle du timer
      		        4 correspond au nombre de répetition (boucle) du timer
      		        
      		        On y ajoute deux écouteurs d'évènements TimerEvent.TIMER_COMPLETE et TimerEvent.TIMER
      		        L'un exécute la fonction timerOver() lorsque le timer est terminé
      		        L'autre exécute la fonction wait() à chaque cycle
      		        
      		        On lance le timer en utilisant sa méthode start();
      		    */
      		    cleanLoader();
      		    
      		    pleaseWait = new Timer(1000, 4);
      		    pleaseWait.addEventListener(TimerEvent.TIMER_COMPLETE, timerOver);
      		    pleaseWait.addEventListener(TimerEvent.TIMER, wait);
      		    pleaseWait.start();
      		}
      		private function progress(e:ProgressEvent)
      		{
      		    /*
      		        Ici on affiche la progression en pourcentage du 
      		        chargement du SWF.
      		        Pour cela on divise le nombre de bytes chargés (e.currentTarget.bytesLoaded)
      		        par le nombre de bytes total à charger (e.currentTarget.bytesTotal)
      		        Le tout multiplié par 100 pour avoir le résultat en pourcentage
      		    */
      		    trace("Chargement..."+(Std.int((e.currentTarget.bytesLoaded/e.currentTarget.bytesTotal)*100))+" %");
      		}
      		private function wait(e:TimerEvent)
      		{
      		    /*
      		        On a vu qu'on pouvait utiliser la fonction trace() pour afficher du texte à l'écran
      		        Il est possible d'effacer le texte de l'écran en utilisant la fonction clear() (haxe.Log.clear())
      		        
      		        A chaque cycle du timer on affiche le nombre de seconde restante avant d'exécuter notre prochaine action
      		        
      		    */
      		    Log.clear();
      		    trace((pleaseWait.repeatCount - pleaseWait.currentCount) + " sec ...");
      		}
      		private function timerOver(e:TimerEvent)
      		{
      		    /*
      		        A la fin du timer, on stope le timer
      		        On retire les écouteurs d'évènements
      		        
      		        Et on ajoute notre loader sur la scène
      		    */
      		    pleaseWait.stop();
      		    pleaseWait.removeEventListener(TimerEvent.TIMER_COMPLETE, timerOver);
		        pleaseWait.removeEventListener(TimerEvent.TIMER, wait);
		        
		        addLoader();		        
      		}
      		private function addLoader()
      		{
      		    /*
      		        on créé un sprite vide dans lequel on y ajoute notre loader
      		        on le rend invisible en initialisant son alpha à 0
      		        
      		        on le rajoute sur la scène
      		        
      		        on applique un écouteur d'évènement Event.ENTER_FRAME 
      		        qui va exécuter à chaque frame la fonction makeAppearLoader()
      		    */
      		    container = new Sprite();
      		    container.addChild(loader); 
      		    container.alpha = 0;
      		    
      		    Lib.current.addChild(container);
      		    
      		    container.addEventListener(Event.ENTER_FRAME, makeAppearLoader);
      		}
      		private function makeAppearLoader(e:Event)
      		{  
      		    /*
      		        Tant que l'alpha de notre sprite est strictement infèrieur à 1
      		        
      		        On lui incrémente 0.02
      		        
      		        dans le cas où l'alpha atteint la limite fixée, on initialise bien l'alpha à 1
      		        et on supprime l'écouteur d'évènement du sprite conteneur
      		    */
      		    if(e.currentTarget.alpha<1)
      		    {
      		         e.currentTarget.alpha += 0.02;
      		    }
      		    else
      		    {
      		         e.currentTarget.alpha = 1; 
      		         container.removeEventListener(Event.ENTER_FRAME, makeAppearLoader);
      		    }
      		    
      		}
      		private function cleanLoader()
	        { 
	            /*
	                On nettoie le loader de ses écouteurs d'évènements
	            */
		        loader.contentLoaderInfo.removeEventListener(Event.COMPLETE, loadingComplete);
		        loader.contentLoaderInfo.removeEventListener(ProgressEvent.PROGRESS, progress);
          	}
      }
(35 fois )