A partir d’un fichier SWF Flash, vous pouvez charger d’autres fichiers SWF externes en tant qu’actifs. Il existe plusieurs raisons de charger des fichiers SWF externes :

  • Un projet pouvant être divisé en plusieurs animations, les fichiers SWF individuels sont de plus petites tailles. Les petits fichiers se chargent rapidement et gèrent la mémoire de manière plus efficace.  
  • Seul le contenu dont vous avez besoin se charge, en fonction de la façon dont l’utilisateur lit votre animation.
  • Vous pouvez afficher plusieurs fichiers SWF les uns après les autres, sans que le navigateur ne doive charger une autre page HTML. Le rechargement des pages n’est pas associé à la phase de pause ni d’actualisation.
  • Vous disposez ainsi d’une plus grande flexibilité dans l’organisation de vos actifs de projet.
  • Une interface utilisateur complexe peut être créée, qui ne repose pas sur un seul fichier SWF. Plusieurs fichiers SWF peuvent être combinés pour créer l’interface. La combinaison de fichiers SWF simplifie l’édition, car un seul fichier SWF, plus petit, peut être révisé sans affecter les autres parties de l’interface.
  • Plusieurs auteurs peuvent collaborer sur le même projet en travaillant sur des fichiers FLA séparés.

Le fait de placer le contenu dans un fichier SWF séparé est semblable à celui de placer le contenu dans son propre symbole de clip. La différence est que le contenu existe en dehors du fichier SWF principal. Vous pouvez également charger les fichiers d’image, comme JPG, PNG et GIF.

Pour charger un fichier SWF externe depuis un autre fichier SWF, utilisez l’une des méthodes suivantes :

  • La classe Loader d’ActionScript 3.0
  • La commande loadMovie d’ActionScript 2.0
  • La classe MovieClipLoader d’ActionScript 2.0

Utilisation de la classe Loader d’ActionScript 3.0

La classe Loader d’ActionScript 3.0 est une sous-classe de DisplayObject que vous pouvez utiliser pour charger et afficher du contenu externe. Pour charger le fichier SWF, utilisez la méthode load de la classe. La méthode load a un paramètre requis, une instance URLRequest contenant l’adresse URL du contenu à charger.

L’exemple de code suivant crée une instance Loader et charge un fichier SWF externe nommé myExternalMovie.swf.

var myLoader:Loader = new Loader();                     // create a new instance of the Loader class
var url:URLRequest = new URLRequest("ExternalSWF.swf"); // in this case both SWFs are in the same folder 
myLoader.load(url);                                     // load the SWF file
addChild(myLoader);                                     // add that instance to the display list, adding it to the Stage at 0,0

// (optional)
myLoader.x = 10;                                        // move the loaded SWF 10 pixels to the right (from the left edge)   
myLoader.y = 175;                                       // move the loaded SWF 175 pixels down from the top

// (optional) load a second external SWF file
var my2ndLoader:Loader = new Loader();
var url2:URLRequest = new URLRequest("ExternalSWF2.swf");
my2ndLoader.load(url2);
addChild(my2ndLoader);                                  // optionally, you could put the 2nd SWF beneath 
                                                        // the 1st by using addChildAt(my2ndLoader, 1);
                                                        // displacing the 1st SWF from position 1 to 2 in the display list

// (optional) scaling of the 2nd SWF file
my2ndLoader.scaleX = 2;                                 // scale the SWF horizontally by 200%
my2ndLoader.scaleY = 2;                                 // scale the SWF vertically by 200%

L’URL du fichier SWF chargé peut être relatif ou absolu. Voir Chemins relatifs ci-dessous pour plus d’informations sur la façon dont Flash Player gère les URL. Pour plus d’informations sur la classe Loader, voir Loader dans le Guide de référence ActionScript pour la plate-forme.

Les références à root, si disponibles, reflètent toujours l’objet d’affichage de plus haut niveau dans la portion de la structure de l’arbre de la liste d’affichage représentée par le fichier SWF. (Pour les images, la racine référence l’objet Bitmap.)

Remarque : dans ActionScript 3.0, il n’existe pas d’équivalent aux propriétés d’ActionScript 2.0 _lockroot ou _level. Voir Bases de la programmation de l’affichage dans le guide du développeur ActionScript 3.0.

Utilisation de la commande loadMovie d’ActionScript 2.0

La commande loadMovie charge un fichier SWF externe ou une image dans un MovieClip ou un autre niveau d’animation parente dans ActionScript 2.0.

La commande loadMovie a deux différentes formes :

  • Méthode MovieClip.loadMovie : la méthode MovieClip est utilisée pour le chargement de contenu externe dans une instance de clip spécifique.
  • Fonction Global loadMovie : la fonction globale loadMovie peut être utilisée pour charger le contenu dans des animations ou des niveaux. La version globale a deux variations, loadMovie et loadMovieNum. La première variation charge le contenu dans des animations ou niveau et la seconde (loadMovieNum) charge spécifiquement dans des niveaux.

MovieClip.loadMovie

Lors du chargement du contenu externe dans des instances d’animation, Adobe vous recommande d’utiliser la version de la méthode MovieClip de loadMovie. Cette version est appelée directement du clip dans lequel vous souhaitez charger le contenu et reçoit l’URL du contenu.

myMovieClipInstance.loadMovie("myExternalMovie.swf");  // here only the filename is given, indicating the SWF file 
                                                       // is in the same folder as the parent SWF.

L’URL du fichier chargé peut être relatif ou absolu. Voir Chemins relatifs ci-dessous pour plus d’informations sur la façon dont Flash Player gère les URL.

Une fois chargé, le contenu s’affiche dans le clip du conteneur. L’emplacement, ainsi que d’autres propriétés de base du clip du conteneur, sont retenus. Toutefois, toute propriété ou fonction personnalisée définie dans le clip du conteneur disparaît. Le nouveau contenu remplace tout le contenu précédent (y compris le code et les gestionnaires d’événements comme onRelease). Ainsi, toute tentative d’utiliser un gestionnaire d’événements onLoad pour le clip ne fonctionne pas. Dans ce cas, utilisez la classe MovieClipLoader (voir ci-dessous). Pour plus d’informations surMovieClip.loadMovie, voir MovieClip.loadMovie dans ActionScript 2.0 Language Reference.

loadMovie et loadMovieNum global

La commande loadMovie existe également en tant que fonction globale. Cette fonction a deux paramètres obligatoires, l’URL du contenu externe et la cible dans laquelle le contenu est chargé. Le paramètre cible peut être une chaîne ou une référence. Les lignes suivantes sont équivalentes au chargement de myExternalMovie.swf dans l’instance de clip nommée myContainer :

loadMovie("myExternalMovie.swf", myContainer);    // the target myContainer is an object reference
loadMovie("myExternalMovie.swf", "myContainer");  // the target "myContainer" is a string

loadMovie peut également charger du contenu dans divers niveaux de Flash Player. Les niveaux de Flash Player sont comme des calques de lecteur. Plusieurs animations peuvent être lues dans la même instance de Flash Player sans être imbriquées les unes dans les autres. Chaque niveau représente une racine unique où les animations peuvent être lues indépendamment des animations des autres niveaux (_lockroot n’est pas nécessaire).

Vous pouvez référencer les niveaux dans ActionScript à l’aide de _level suivi par un nombre représentant le numéro du niveau. La première animation changée dans Flash Player est sur _level0. Les autres niveaux peuvent être ajoutés au-dessus de ce niveau. L’appel suivant à loadMovie charge myExternalMovie.swf dans le niveau 1 au-dessus de l’animation en cours de lecture dans le lecteur.

loadMovie("myExternalMovie.swf", "_level1");

Une variation de la fonction loadMovie globale est loadMovieNum. Cette méthode ressemble loadMovie à ceci près qu’elle ne cible que les niveaux et qu’elle les cible par numéro et non par nom. Pour charger un fichier SWF dans le niveau 1 (_level1) par exemple, utilisez la méthode suivante :

loadMovieNum("myExternalMovie.swf", 1);

Lors du chargement en niveaux, Adobe vous recommande d’utiliser loadMovieNum sur loadMovie. Pour plus d’information, voir global loadMovie dans ActionScript 2.0 Language Reference.

Utilisez _lockroot pour empêcher les conflits_root

Quand vous chargez une animation externe dans une autre animation, la référence _root du clip chargé passe de son scénario principal au scénario de l’animation qui l’a chargé. En d’autres termes,  _root fait toujours référence au scénario de plus haut niveau dans la hiérarchie. Si vous ne souhaitez pas que _root fasse référence au scénario de plus haut niveau, définissez la propriété _lockroot du scénario principal du clip chargé sur true. Cette propriété indique à tous les enfants de ce scénario que lorsqu’ils référencent _root, ils doivent référencer ce scénario.

this._lockroot = true;     // add this code in the main timeline of the SWF file that will be loaded into another SWF

Remarque : la propriété _lockroot n’est disponible que pour la publication vers Flash Player 7 ou ultérieur.

 Utilisation de la classe MovieClipLoader d’ActionScript 2.0

La classe MovieClipLoader d’ActionScript 2.0 est conçue pour faciliter le processus de chargement du contenu externe dans les instances MovieClip. Comme mentionné ci-dessus, les variables et fonctions définies dans les clips sont supprimées quand le nouveau contenu est changé dans ces clips. Les rappels tels que onLoad sont impossibles. Toutefois, le MovieClipLoader contourne cette restriction en tant que substitut de tels événements. Vous créez des instances MovieClipLoader séparées afin de gérer le chargement du contenu dans un autre clip. Ainsi, l’effacement des variables et fonctions dans ce clip ne se produit pas.

Quand vous chargez du contenu dans un clip via la classeMovieClipLoader, vous devez d’abord créer une nouvelle instance de la classe. Utilisez ensuite loadClip pour charger le contenu dans un clip cible. Dans l’exemple suivant, le nouveau contenu est chargé dans le clip myContainer.

var myLoader:MovieClipLoader = new MovieClipLoader();
myLoader.loadClip("myExternalMovie.swf", myContainer);

Si vous souhaitez savoir que le contenu est chargé, utilisez un gestionnaire d’événements onLoadInit avec votre instance MovieClipLoader.

var myLoader:MovieClipLoader = new MovieClipLoader(); 
myLoader.addListener(this); 
myLoader.loadClip("myExternalMovie.swf", myContainer); 

function onLoadInit(mc:MovieClip) 
    { 
        trace("content has been loaded into "+mc); 
    }

Si vous souhaitez davantage de contrôle sur les informations concernant le chargement du contenu dans le clip, utilisez la classe MovieClipLoader à la place de MovieClip.loadMovie. (Utilisez par exemple ce gestionnaire d’événements quand vous souhaitez vérifier la progression du chargement.) Pour plus d’informations sur la classeMovieClipLoader voir MovieClipLoader dans ActionScript 2.0 Language Reference.

Remarque : la classe MovieClipLoader n’est disponible que pour la publication vers Flash Player 7 ou version ultérieure.

 Utilisation de chemins relatifs pour le chargement de contenu

L’utilisation de chemins relatifs avec Loader et loadMovie peut être déroutante. Le scénario des fichiers SWF ou clips pouvant effectuer une action loadMovie , demandez-vous : en lien avec quel scénario l’animation est-elle chargée ? Est-elle liée au scénario principal au niveau _level0 ? Ou est-elle liée au scénario ayant effectué l’action de chargement de l’animation ? La réponse est simple : les animations chargées sont toujours liées au scénario qui les a chargées. Voir Récupération des URL mal référencés | Flash (tn_04157) pour plus d’informations sur les chemins relatifs et des détails sur le chargement des fichiers SWF externes.

Considérations relatives à la fréquence d’images

Dans la plupart des cas, une animation chargée hérite de la fréquence d’images de l’animation parente. Ainsi, un fichier SWF dont la fréquence d’images est de 12 fps se lit à 24 fps lorsqu’elle est chargée dans une animation dont la fréquence d’images est de 24 fps. La seule exception à la règle se produit quand l’animation chargée contient un son dans le scénario dont la synchronisation est définie sur stream. C’est le seul cas pour lequel l’animation principale hérite de la fréquence d’images de l’animation chargée, afin d’assurer une lecture correcte du son.

Remarque : ActionScript 3.0 permet de modifier dynamiquement la fréquence d’images à l’aide de la propriété Stage.frameRate.

Mots clés : Flash Player ; load movie ; ActionScript ; script ; niveaux ; tell target ; variables ; cible ; instance ; SWF ; loadMovie ; tn_14190

Ce produit est distribué sous licence Creative Commons Attribution - Pas d’utilisation commerciale - Partage à l’identique 3.0 non transposé  Les publications Twitter™ et Facebook ne sont pas couvertes par les dispositions Creative Commons.

Mentions légales   |   Politique de confidentialité en ligne