loadMovie: 

loading parts as needed, rather than all at at the beginning

As your Flash movies have more assets like sounds and video they may become too large for a reasonable download time. But you can handle this by breaking the movie up into parts so they can be loaded as needed rather than at the beginning. This way, the user experiences load times only for the parts they are seeing as they see them.

The simplest example of this is loading a JPEG image into an existing movieClip. Here is the code to do this:

_root.aClip.loadMovie("swfs/img_0418.jpg");

Note that this code replaces the movieClip in the instance called "aClip", and replaces it with the JPEG. The instance retains whatever properties and scripts that instance already had, but nothing that was inside the old movieClip is retained.

Whev using loadmovie(), the URL to the image or .swf file to be loaded is relative to the location of the HTML page that contains the loading movie. So even though the load_movie.swf is in the same swfs directory as the "IMG_0418.jpg", the HTML page that contains load_movie.swf is one level up. So the URL must be relative to this HTML page, as "swfs/img_0418.jpg".

See also the loadSound() method for sound objects (book page 780), which allows you to load MP3 files and stream them.

loading a .swf

The loadMovie() method can also be used to load an external .swf into the current movie. Usually, the new swf is loaded in place of an existing movieClip, replacing the contents of the instance as described above. The code is similar to the above:

_root.aClip.loadMovie("swfs/preloader.swf");

Note that any code in the new .swf must observe the same target paths for movieClips as the movieClip it replaces. For example, if the .swf made a reference to _root that worked when the loaded .swf was played on its own, that _root reference would no longer work, because it would refer to _root of the movie that loaded it, not its own top level.

It's also possible to replace the entire contents of the current movie. This is accomplished by replacing the _root target:

_root.loadMovie("swfs/preloader.swf");

load_movie.fla

adapted from ActionScript, The Definitive Guide, page 654 (MovieClip._framesloaded)

It is usually a good idea to provide the user with an indication of how much of a movie is loaded. It's also good practice to make sure code does not run that depends on parts of the movie that have not loaded yet. There are many approaches to preloaders, and the textbook has a good one. This code checks to see how many bytes (rather than frames) of the .swf have loaded, and displays this graphically by adjusting the scale of a graphic in proportion to the percentage of bytes loaded.

preloader.fla

Here's the code:

onClipEvent(load) {
    // start the width of the load bar to be 0
    this._xscale = 0;
}
onClipEvent(enterFrame) {
    // Measure how many frames have loaded
    loaded = _root._framesloaded;
    // if all the frames have finished loading...
    if (loaded == _root._totalframes) {
        // ...play the rest of the movie
        _parent.gotoAndStop("beginMovie");
    }
    // determine the percentage of bytes that have loaded
    percentDone = Math.floor((_root.getBytesLoaded() / _root.getBytesTotal()) * 100);
    // display the percentage of loaded bytes in the text field loadStatus
    _parent.loadStatus = percentDone + "% complete";
    // set the size of our loadBar clip
    this._xscale = percentDone;
}

This code is attached to a loading bar graphic in the first frame of the .swf. Note that for this to look right, the loading bar should have its registration point on the far left side. The code assumes a dynamic text variable called "loadStatus" at the same level as the loading bar. When the code determines that the entire .swf has loaded, it sends the parent timeline to a frame labeled "beginMovie".

Testing the preloader

The testing of preloaders can be tricky because when loading the file locally, there is not enough delay to see the preloader work. You can test what the actual behavior will look like by using the Flash's "Show Streaming" feature. After the initial testing of the swf (CONTROL>TEST MOVIE), in the menu for the SWF select VIEW>SHOW STREAMING. To set the streaming rate (i.e. connection speed) use the DEBUG menu and select the connection speed.

all materials on this web site © copyright 2003, Philip van Allen