Externa SWF-filer kan läsas in som resurser från en Flash SWF-fil. Det finns flera skäl till att läsa in externa SWF-filer:

  • Ett projekt kan delas upp i flera mindre filmer eftersom de enskilda SWF-filerna då blir mindre. Mindre filer går fortare att läsa in och minneshanteringen blir mer effektiv.  
  • Du kan läsa in endast det innehåll som behövs, beroende på vad användaren gör i filmen.
  • Flera SWF-filer kan spelas upp efter varandra utan att webbläsaren behöver ladda upp ytterligare en HTML-sida. Sidorna drabbas inte av de pauser och omtagningar som förknippas med siduppdateringar.
  • Du får större flexibilitet vad gäller organiseringen av projektets resurser.
  • Ökade möjligheter att skapa avancerade gränssnitt som inte förlitar sig på en enda SWF-fil. Flera SWF-filer kan kombineras till ett och samma gränssnitt. Att kombinera SWF-filer förenklar redigering, eftersom en mindre SWF-fil kan ändras utan att övriga delar av gränssnittet påverkas.
  • Flera personer kan arbeta på samma projekt genom att arbeta i olika FLA-filer.

Att lägga in innehåll i en separat SWF-fil påminner om när man lägger innehåll i en separat filmklippssymbol. Skillnaden är att innehållet som sådant ligger utanför den överordnade SWF-filen. Du kan även läsa in andra bildfiler såsom JPG, PNG, GIF.

För att läsa in en extern SWF-fil från en annan SWF-fil använder du något av de följande:

  • ActionScript 3.0 Laddningsklass
  • ActionScript 2.0 loadMoviekommandot
  • ActionScript 2.0 MovieClipLoaderklass

Använda ActionScript 3.0 laddningsklass

 Laddningsklass i ActionScript 3.0 är en underklass till DisplayObject som används för att läsa in och visa externt innehåll. Inläsningen av SWF-filen sker med metoden load. Metoden load har en obligatorisk parameter: en instans av URLRequest med URL-adressen till innehållet som ska läsas in.

Följande kodexempel skapar en instans av Loader och läser in en extern SWF-fil med namnet "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%

URL-adressen till SWF-filen kan vara relativ eller absolut. Mer information om hur Flash Player hanterar URL-adresser finns i avsnittet Relativa sökvägar nedan. Mer information om klassen Loader finns i avsnittet Loader i respektive plattforms språkreferens för ActionScript.

När det förekommer hänvisningar till root avses alltid det översta visningsobjektet i den del av visningslistans struktur som motsvaras av aktuell SWF-fil. (När det gäller bilder hänvisar root till bitmappsobjektet.)

Obs! I ActionScript 3.0 finns ingen motsvarighet till egenskaperna _lockroot och _level ActionScript 2.0. Se Grunderna i visningsprogrammering i Utvecklarhandbok för ActionScript 3.0.

Använda ActionScript 2.0-kommandot loadMovie

Kommandot loadMovie läser in en extern SWF-fil eller bild i ett filmklipp eller på annan nivå i den överordnade filmen i ActionScript 2.0.

Kommandot loadMovie har två olika former:

  • MovieClip.loadMovie: Metoden MovieClip används för att läsa in externt innehåll i en specifik filmklippsinstans.
  • loadMovie: Den globala funktionen loadMovie kan användas för att läsa in innehåll i filmer eller nivåer. Även den globala versionen har två varianter: loadMovie och loadMovieNum. Den förstnämnda läser in innehåll i filmer eller nivåer och den andra (loadMovieNum) läser in specifikt i nivåer.

MovieClip.loadMovie

När du läser in externt innehåll i filmklippsinstanser rekommenderar Adobe att du använder MovieClip-varianten av loadMovie. Den varianten anropas direkt från det filmklipp du vill läsa in innehållet i och tar emot innehållets URL direkt.

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

URL-adressen till innehållet kan vara relativ eller absolut. Mer information om hur Flash Player hanterar URL-adresser finns i avsnittet Relativa sökvägar nedan.

När innehållet är inläst visas det inuti det anropande filmklippets behållare. Filmklippets behållare ligger kvar på samma plats och behåller sina övriga grundläggande egenskaper. Eventuella särskilt inställda inställningar och funktioner i filmklippets behållare har dock försvunnit. Det nya innehållet ersätter helt och hållet behållarens tidigare innehåll, inklusive kod och händelsehanterare som onRelease. Det går alltså inte att använda händelsehanterare som onLoad tillsammans med filmklippet längre. Om du behöver använda denna funktion, välj klassen MovieClipLoader istället (se nedan). Mer information om MovieClip.loadMovie finns i avsnittet MovieClip.loadMovie i språkreferensen för ActionScript 2.0.

Globala loadMovie och loadMovieNum

Kommandot loadMovie finns även som en global funktion. Den här funktionen har i sin tur två obligatoriska parametrar: URL till det externa innehållet och till målet där innehållet ska läsas in. Målparametern kan vara antingen en sträng eller en referens. Följande kodexempel läser in filen "myExternalMovie.swf" i filmklippsinstansen myContainer:

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

loadMovie kan även läsa in innehåll i olika nivåer av Flash Player. Nivåer i Flash Player fungerar som lager. Flera filmer kan spelas upp i samma instans av Flash Player, utan att nästas i varandra. Varje nivå utgör en unik rotnod där filmer kan spelas upp, oberoende av filmerna i övriga lager (kommandot _lockroot behövs inte).

Du kan hänvisa till nivåer i ActionScript med kommandot _level följt av en siffra som motsvarar nivåns nummer. Den första inlästa filmen i Flash Player är ligger på nivå _level0. Ovanpå detta kan sedan ytterligare nivåer läggas till. Följande anrop till loadMovie läser in "myExternalMovie.swf" på nivå 1, ovanför den film som för närvarande spelas upp i spelaren.

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

En variant av den globala loadMovie-funktionen är loadMovieNum. Den här metoden fungerar precis som loadMovie men fungerar endast på nivåer och går efter nummer, inte namn. Om du till exempel vill läsa in en extern SWF-fil på nivå 1 (_level1) använder du följande kommando:

loadMovieNum("myExternalMovie.swf", 1);

Om du läser in på nivåer rekommenderar Adobe loadMovieNum framför loadMovie. Mer information finns i avsnittet om globala funktioner, loadMovie, i språkreferensen för ActionScript 2.0.

Använd _lockroot för att förhindra konflikter med _root.

När du läser in en extern film i en annan film ändras _root-hänvisningen i det inlästa filmklippet, från sin egen tidslinje till det överordnade klippets tidslinje. Beteckningen _root hänvisar med andra ord alltid till tidslinjen överst i hierarkin. Om du inte vill att _root ska hänvisa till den översta tidslinjen, ska du ställa in det inlästa filmklippets huvudtidslinjes egenskap _lockrootsann. Egenskapen talar om för alla underordnade tidslinjer att hänvisningar till _root ska peka till den angivna huvudtidslinjen.

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

Obs! Egenskapen _lockroot är bara tillgänglig i Flash Player 7 och senare utgåvor.

 Använda ActionScript 2.0-klassen MovieClipLoader.

Klassen MovieClipLoader i ActionScript 2.0 är utformad för att förenkla inläsningen av externt innehåll i MovieClip-instanser. Som tidigare nämnts tas variabler och funktioner som definierats i enskilda filmklipp bort när nytt innehåll läses in i samma filmklipp. Callback-funktioner som onLoad kan inte användas. Med MovieClipLoader kan den här begränsningen emellertid kringgås, då den fungerar som ett surrogat för dessa händelser. Du skapar då separata instanser av MovieClipLoader för att hantera inläsningen av innehåll i ett annat filmklipp. Därmed påverkas inte variabler och funktioner inuti filmklippet.

Om du vill läsa in innehåll i ett filmklipp med hjälp av klassen MovieClipLoader måste du först skapa en instans av klassen. Därefter läser du in innehåll i målfilmklippet med loadClip. I följande kodexempel blir nytt innehåll inläst i filmklippet myContainer.

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

Om du vill veta att innehållet blir inläst använder du händelsehanteraren onLoadInit tillsammans med instansen av 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); 
    }

Om du vill ha mer kontroll över informationen angående hur innehåll läses in i ett filmklipp använder du klassen MovieClipLoader istället för MovieClip.loadMovie. (Använd denna händelsehanterare om du vill kunna kontrollera hur inläsningen fortgår.)Mer information om klassen MovieClipLoader finns i avsnittet MovieClipLoader i språkreferensen för ActionScript 2.0.

Obs! MovieClipLoader-klassen är bara tillgänglig i Flash Player 7 och senare utgåvor.

Använda relativa sökvägar vid inläsning av innehåll

Det kan vara förvirrande att använda relativa sökvägar tillsammans med Loader och loadMovie. Eftersom tidslinjen till samtliga SWF-filer och filmklipp kan utföra en loadMovie-åtgärd måste man fråga sig "I förhållande till vilken tidslinje läses filmen in?" Förhåller den sig till huvudtidslinjen på nivå _level0? Eller förhåller den sig till den tidslinje som utförde inläsningsåtgärden? Svaret är enkelt: Inlästa filmer relaterar alltid till den tidslinje som utförde inläsningsåtgärden. I artikeln Felaktig hänvisning till relativa URL:er | Flash (tn_04157) finns en diskussion om relativa sökvägar som är relevant även för inläsning av externa SWF-filer.

Viktigt om bildrutehastighet

I de flesta fall ärver en inläst extern film den överordnade filmens bildrutehastighet. En SWF-fil med bildrutehastigheten 12 fps spelas upp med hastigheten 24 fps om den läses in i en film som har 24 fps som hastighet. Det enda undantaget är om tidslinjen till filmen som läses in innehåller ljud som har synkroniseringsinställningen "stream". Detta är enda gången som den överordnade filmen ärver sin bildrutehastighet från den inlästa filmen, för att säkerställa att ljudet spelas upp korrekt.

Obs! I ActionScript 3.0 kan du ändra bildrutehastighet dynamiskt med egenskapen Stage.frameRate.

Nyckelord: Flash Player, läs in film; ActionScript; skriptning; nivåer; definiera mål; variabler; mål; instans; SWF; loadMovie; tn_14190

Denna produkt är licensierad enligt en Creative Commons Erkännande-Ickekommersiell-Dela Lika 3.0 Unported-licens  Twitter™- och Facebook-inlägg omfattas inte av villkoren i Creative Commons-licensen.

Juridiska meddelanden   |   Onlinesekretesspolicy