Preloading - The Definitive Guide

[bokel]

Hinweis
Die LoaderClass hat mittlerweile einige Updates erfahren. Obwohl ich versuche, das Tutorial hier auf dem aktuellen Stand zu halten, solltet ihr euch auf jeden Fall die letzte Version und Dokumentation (im letzten Posting des Threads) anschauen.



Preloading - The Definitive Guide - Teil I

Wie Colin Moock, der Auto des Buches Actionscript - The definitive guide neulich feststellte, ist das Preloaden nach wie vor eins der groessten Probleme für viele Flasher. Macromedia macht diese Sache aber auch alles andere als einfach. Die unterschiedlichen Schnittstellen zu den verschiedenen Arten von Files (SWF, XML, Text, Sound), das asynchrone Verhalten der Ladefunktionen und die unvollständige Fehlerbehandlung, das alles laesst die Lernkurve steil ansteigen.

Deshalb hat Moock eine Petition gestartet und ein neues Interface für die Behandlung von Ladevorgängen vorgestellt. Auf Basis dieser neuen Schnittstelle habe ich eine Klasse Loader entwickelt, die das Preloaden extrem vereinfacht und und für alle Arten von Dateien vereinheitlicht.

Alle Theorie ist grau, deshalb möchte ich hier ein paar Beispiele vorstellen, die die neue Klasse Loader in der Praxis zeigen. Zum Ausprobieren brauchst du nur Flash MX und die Include-Datei mit der Definition der Klasse, die du hier herunterladen kannst.

Falls du Fragen oder Anregungen habt, dann poste die bitte in diesem Thread.

Als erstes ein sehr einfaches Beispiel: Wir laden eine SWF in einen vorhandenen MovieClip

// Ohne diese include-Datei geht gar nichts
#include "com.qlod.LoaderClass.as"
 
// Wir erzeugen einen neuen Loader
meinLoader = new com.qlod.LoaderClass();
 
// Wir laden die SWF "meinFilm.swf"
// Der MovieClip ziel_mc muss sich bereits auf der Bühne befinden
meinLoader.load(ziel_mc, "meinFilm.swf"); 

Hier sieht man schon die wichtigsten Teile eines Preloaderscriptes. Als erstes muss die neue Klasse "LoaderClass" verfuegbar gemacht werden. Das erreichen wir durch das #include. Diese Anweisung macht nichts anderes, als Flash mitzuteilen, dass es beim Uebersetzen des Films den Text der angegebenen Datei an dieser Stelle einfuegen soll. Auf die Art muss man nicht immer wieder den ganzen Sourcecode von Fla zu Fla kopieren, sondern es reicht, die .as-Datei ins gleiche Verzeichnis wie die Fla zu legen.
Als nächstes erzeugen wir ein neues Loader-Objekt. Das ist die Basis unseres Preloaders.
Zum Schluss starten wir das Laden durch den Aufruf von load.

Dieser Preloader macht allerdings noch nicht viel mehr, als ein einfacher Aufruf von loadMovie. Im Unterschied zu loadMovie kann man allerdings hier genausogut einen Sound, eine XML-Datei oder eine LoadVars-Datei laden. Du musst dann natürlcih anstatt eines MovieClips das entsprechende Objekt also z.B. ein Soundobjekt übergeben. Wenn man als ersten Parameter eine Zahl übergibt, kann man auch MovieClips direkt auf das entsprechende Level laden. Ausserdem kann man auch direkt mehrere Ladevorgänge starten, die dann nacheinander abgearbeitet werden. Aber dazu später mehr.

Um den Preloader etwas attraktiver zu machen, fügen wir mal eine Anzeige für den Ladevorgang hinzu, den beliebten Ladebalken. Der Ladebalken ist ein einfacher MovieClip auf der Bühne, der durch Skalieren zwischen 0 und 100 anzeigt, wieviel Prozent des Films geladen sind.

// Ohne diese include-Datei geht gar nichts
#include "com.qlod.LoaderClass.as"
 
// Wir erzeugen einen neuen Loader
meinLoader = new com.qlod.LoaderClass();
 
// Der Balken bekommt einen Handler zugewiesen, 
// der automatisch vom Loader regelmäßig aufgerufen wird
// und als Parameter die geladenen Bytes bekommt.
balken_mc.onLoadProgress = function( loaderObj){
    // Wir holen uns die Prozente
    var prozent = loaderObj.getPercent();
    // Die Prozentzahl benutzen wir, um den Balken   
                // entsprechend in der Breite zu skalieren
    this._xscale = prozent;
}
 
// Wir teilen dem Loader mit, dass der Balken an 
// Informationen zum Ladevorgang interessiert ist. 
// Der Loader fungiert hier als Sender (Broadcaster), 
// den Zuhörer (Listener) abonnieren können. 
meinLoader.addListener(balken_mc)
 
// Wir laden die SWF "meinFilm.swf"
// Der MovieClip ziel_mc muss sich bereits auf der Bühne befinden
meinLoader.load(ziel_mc, "meinFilm.swf"); 

Das sieht schon besser aus. Auch hier gilt wieder: Alle anderen Dateitypen können auf genau die gleiche Weise geladen und deren Ladefortschritt angezeigt werden. Mehrfache Aufrufe von load werden schön geordnet hintereinander weg ausgeführt und angezeigt.

Im nächsten Posting geht es weiter ...

[bokel]

Preloading - The Definitive Guide - Teil II

Als nächstes würden wir gerne eine Funktion ausführen, wenn die Datei fertig geladen ist. Nichts einfacher als das. Das Prinzip ist das gleiche wie bei der Balkenanzeige. Wir teilen dem Loader mit, dass wir daran interessiert sind, wann der Film fertig geladen ist und er ruft uns dann automatisch zum richtigen Zeitpunkt auf.

// Ohne diese include-Datei geht gar nichts
#include "com.qlod.LoaderClass.as"
 
// Wir erzeugen einen neuen Loader
meinLoader = new com.qlod.LoaderClass();
 
// Der Balken bekommt einen Handler zugewiesen, 
// der automatisch vom Loader regelmäßig aufgerufen wird
// und als Parameter die geladenen Bytes bekommt.
balken_mc.onLoadProgress = function( loaderObj){
    var prozent = Math.floor(loaderObj.getPercent());
    // Die Prozentzahl benutzen wir, um den Balken
                // entsprechend in der Breite zu skalieren
    this._xscale = prozent;
}
 
// Wir teilen dem Loader mit, dass der Balken an 
// Informationen zum Ladevorgang interessiert ist. 
// Der Loader fungiert hier als Sender (Broadcaster), 
// den Zuhörer (Listener) abonnieren können. 
meinLoader.addListener(balken_mc);
 
// Diese Funktion wird aufgerufen, wenn die Datei 
// fertig geladen ist
// Sie gibt eine Meldung in das Ausgabefenster aus. 
function onLoadComplete( success, loaderObj){
    if(success){
          trace("Ja prima, alles fertig geladen.");
    } else {
          trace("Och schade, das Laden von " + 
                                loaderObj.getUrl() + " in " + loaderObj.getTarget() + " hat nicht geklappt.");
    }     
}
 
// Die Funktion onLoadComplete ist auf der aktuellen Timeline 
// definiert, deshalb melden wir die aktuelle Timeline als Listener an
meinLoader.addListener(this);
 
// Wir laden die SWF "meinFilm.swf"
// Der MovieClip ziel_mc muss sich bereits auf der Bühne befinden
meinLoader.load(ziel_mc, "meinFilm.swf"); 

Neben onLoadComplete und onLoadProgress gibt es noch die Events onLoadStart, dass beim Start eines Ladevorgangs aufgerufen wird, onLoadTimeout, das aufgerufen wird, wenn der Ladevorgang nicht innerhalb von 15 Sekunden angefangen hat, onQueueStart, das beim Start einer ganzen Reihe von Ladevorgängen augerufen wird und onQueueStop, das das Ende dieser ganzen Reihe von Ladevorgängen signalisiert.

Bisher haben wir immer nur den Ladevorgang von geladenen Filmen angezeigt. Manchmal möchte man aber auch den Hauptfilm preloaden. Auch das geht mit der neuen Loaderklasse. Dazu gibt es die Methode observe (target, url). Die Methode observe funktioniert ähnlich wie load, nur dass kein Ladevorgang gestartet wird, sondern ein laufender Vorgang beobachtet werden kann. Hier ist ein Beispiel, bei dem zuerst der Hauptfilm und dann ein MovieClip preloaded wird.

// Ohne diese include-Datei geht gar nichts
#include "com.qlod.LoaderClass.as"
 
// Wir erzeugen einen neuen Loader
meinLoader = new com.qlod.LoaderClass();
 
// Der Balken bekommt einen Handler zugewiesen, 
// der automatisch vom Loader regelmäßig aufgerufen wird
// und als Parameter die geladenen Bytes bekommt.
balken_mc.onLoadProgress = function( loaderObj){
    var prozent = Math.floor(loaderObj.getPercent());
    // Die Prozentzahl benutzen wir, um den Balken 
                // entsprechend in der Breite zu skalieren
    this._xscale = prozent;
}
 
// Wir teilen dem Loader mit, dass der Balken an 
// Informationen zum Ladevorgang interessiert ist. 
// Der Loader fungiert hier als Sender (Broadcaster), 
// den Zuhörer (Listener) abonnieren können. 
meinLoader.addListener(balken_mc);
 
// Wir wollen zuerst den Hauptfilm vorladen
meinLoader.observe(_root, _root._url);
 
// Anschliessend laden wir die SWF "meinFilm.swf"
// Der MovieClip ziel_mc muss sich bereits auf der Bühne befinden
meinLoader.load(ziel_mc, "meinFilm.swf"); 

So das war es für heute. Jetzt haben wir schon eine ganze Menge von Möglichkeiten der neuen Loaderklasse kennengelernt. Sie erleichtert und vereinheitlicht das Programmieren von Preloadern enorm. Damit gewinnen wir alle wieder mehr Zeit, uns um die kreativen Dinge zu kümmern.

Viel Spass,
Ralf Bokelberg

[bokel]

Preloading - The Definitive Guide - Teil III

Und jetzt noch ein paar Schmankerl zum Thema.

1. Anzeige von Kilobytes anstatt Bytes

bar_mc.onLoadProgress = function( loaderObj){
    //geladene kilobytes
    var kbLoaded = loaderObj.getKBLoaded();
    var kbTotal = loaderObj.getKBTotal();
    trace(kbLoaded + "kb von " + kbtotal + " geladen.");
} 

2. Anzeige der Downloadgeschwindigkeit
Neben den heruntergeladenen Bytes und der Gesamtgroesse in Bytes bekommt der onLoadProgress-Handler als letzten Parameter auch die Zeit mitgeliefert. Damit kann man auf einfache Weise die aktuelle Downloadgeschwindigkeit berechnen:

bar_mc.onLoadProgress = function( loaderObj){
    var downloadGeschwindigkeit = Math.floor( loaderObj.getSpeed());
    trace(downloadGeschwindigkeit);
} 

3. Eine gemeinsame Anzeige für mehrere geladene Filme
Manchmal muss man mehrere Filme laden, aber man möchte eine Prozentzahl anzeigen, die zur gesamten Menge aller Bytes in Relation steht. Dazu muss man nicht viel machen. Das einzige was man vorab benötigt, ist eben diese Gesamtzahl, da Flash die nicht selbst ermitteln kann, ohne die Dateien zu laden.

// Die Variable gesamtAnzahlBytes muss man vorher mit dem entsprechenden Wert füllen
bar_mc.gesamtAnzahlBytes = 123467;
bar_mc.bisherGeladen = 0;
 
bar_mc.onLoadProgress = function( loaderObj){
    var prozent = (loaderObj.getBytesLoaded() + this.bisherGeladen) * 100 / this.gesamtAnzahlBytes;
    trace(prozent);
}
 
// wenn das Target geladen ist, addieren wir dessen Groesse auf
bar_mc.onLoadComplete = function( success, loaderObj){
                 this.bisherGeladen += loaderObj.getBytesLoaded();
} 

4. Laden mehrerer verschiedener Dateitypen hintereinander.
Falls sich jemand wundert, ob das wirklich funktioniert, hier ist ein Beispiel das kreuz und quer verschiedene Files lädt.

#include "com.qlod.LoaderClass.as"
 
// Diesmal erzeugen wir den bar_mc mit AS
createEmptyMovieClip("bar_mc", 1);
 
bar_mc.onLoadProgress = function( loaderObj){
        trace("onLoadProgress " + arguments);
        //
        var percent = loaderObj.getPercentLoaded();
        //
        // wir zeichnen eine Linie zur Anzeige der Prozente
        this.clear();
        this.lineStyle(10,0x000000);
        this.lineTo(100,0);
        this.lineStyle(10, 0xff0000);
        this.moveTo(0,0);
        this.lineTo(percent, 0);
}
 
bar_mc.onLoadComplete = function(success, loaderObj){
    trace("onLoadComplete " + [success, loaderObj.getUrl()]);
}
 
var meinLoader = new LoaderClass();
meinLoader.addListener(bar_mc);
 
//wir beginnen mit der Hauptzeitleiste
meinLoader.observe(this, this._url);
 
//dann laden wir eine XML-Datei
x = new XML();
meinLoader.load(x, "meinxml.xml");
 
//dann laden wir ein paar Variablen aus einem Textfile
l = new LoadVars();
meinLoader.load(l, "meintxt.txt");
 
//dann laden wir ein jpg auf level 7
meinLoader.load(7, "meinpic.jpg");
 
//dann laden wir ein swf in einen MovieClip
createEmptyMovieClip("mc", 123);
meinLoader.load(mc, "meinmovie.swf");
    
//und zuguterletzt laden wir einen Sound
s = new Sound();
meinLoader.load(s, "meinsound.mp3"); 

mfg r.

[Thorsten [Flash4all]]

fragen? diskussion? danksagung?

hier bitte: [Genial + THX] Preloading - The Definitive Guide



T.

[bokel]

Preloading - The Definitive Guide - Teil IV

Updates

Loader -> LoaderClass
Die Klasse heisst jetzt LoaderClass um Verwechselungen mit instanzen zu vermeiden. Wegen der Änderung des Namens hat sich auch der Dateiname geändert. Der Link oben ist aber schon korrigiert.

watch -> observe
Die Methode watch heisst jetzt observe. Die "Engländer" fanden das treffender

Neue Eigenschaft: minSteps
Man kann jetzt festlegen, wie wieviele Stufen der Preloaderanimation mindestens angezeigt werden sollen. Damit vermeidet man, dass ein Preloader erscheint und sofort wieder verschwindet. Ausserdem kann man so die Preloader auch offline testen. Standardmaessig ist 1 eingestellt.

Hier ist ein Beispiel für die Änderungen

#include "com.qlod.LoaderClass.as"
 
// Das wird unser Balkendisplay
createEmptyMovieClip("balken_mc", 1);
//
balken_mc.onLoadProgress = function( loaderObj) {
    var percent = Math.floor(loaderObj.getPercent());
    //
    // Linie zeichnen
    this.clear();
    this.lineStyle(10, 0x000000);
    this.lineTo(100, 0);
    this.lineStyle(10, 0xff0000);
    this.moveTo(0, 0);
    this.lineTo(percent, 0);
};
 
myLoader = new com.qlod.LoaderClass();
 
// es sollen mindestes 5 Schritte angezeigt werden
myLoader.setMinSteps(5);
 
// listener anmelden
myLoader.addListener(balken_mc);
 
// wir beobachten die Hauptzeitleiste
myLoader.observe(_root);
 
// und laden anschliessend einen swf 
myLoader.load( target_mc, "myMovi.swf"); 

mfg r.

[bokel]

Preloading - The Definitive Guide - Teil V

Inzwischen hat es einige Updates gegeben, die die Klasse noch etwas handlicher machen.

Download
http://www.helpqlodhelp.com/stuff/lo...erclass1.0.zip

Am wichtigsten finde ich den neuen Parameterstil für die Callbacks (onLoadProgress, onLoadComplete, etc.).
Alle Callbacks kriegen jetzt ein Objekt als Parameter. Über dieses Objekt kann man sich dann die Informationen holen, die man braucht.

Hier ist ein kleines Beispiel:

// so sieht der neue "Objekt"-Stil aus
// Man bekommt lediglich ein Objekt übergeben und muss 
// sich die Infos dann daraus besorgen.
onLoadProgress = function( loaderObj){
 var percent = loaderObj.getPercent();
 var speed = loaderObj.getSpeed();
 var kbLoaded = loaderObj.getKbLoaded();
 trace("Percent, Speed, kbLoaded: " + [percent, speed, kbLoaded]);
} 

Neue Getter
Dazu gibt es jede Menge neue Getter, unter anderem für die Downloadgeschwindigkeit, die geschätzte Dauer des Downloads, die geladenen Bytes in KiloBytes, etc. pp. Hier ist eine komplette Liste der verfügbaren Getter:

* isLoading()
* getBytesLoaded()
* getBytesTotal()
* getPercent()
* getStepBytesLoaded()
* getStepPercent()
* getKBLoaded()
* getKBTotal()
* getTime()
* getSpeed()
* getEstimatedTotalTime()
* getTarget()
* getTargetObj()
* getUrl()

Man muss also jetzt nicht mehr selbst herumrechnen, sondern die Klasse übernimmt das komplett. Natürlich kann man auch weiterhin einfach nur die Bytes abfragen und eigene Berechnungen damit anstellen.

disableTimeout()
Ausserdem ist jetzt die Möglichkeit dazugekommen, das Timeout auszuschalten. Ein Anwender hat für jedes zu ladende Objekt einen eigenen Loader gestartet. Dabei hat er festgestellt, dass bei manchen Systemen nur 2 Downloads gleichzeitig gestartet wurden, während die anderen warten mussten. Dabei konnte es dann vorkommen, dass ein Timeout-Error erzeugt wurde, weil das Laden länger als 10 Sekunden gedauert hat. Dieses Problem kann man jetzt umgehen, indem man die Timeoutüberprüfung mit disableTimeout() abschaltet.

Sonstiges
Dazu habe ich die ganze Klasse ein wenig aufgeraeumt. Die komplette Api und ein längeres Beispiel ist jetzt oben zu finden, während unten im Code nur noch Implementation folgt.

Probleme ?
Weitere Anregungen oder Probleme könnt ihr an meine E-Mail bokel.ff@helpQLODhelp.com schicken.

MfG,
r.

[bokel]

Preloading - The Definitive Guide - Teil VI

Und damit das ganze nicht so trocken bleibt, folgt hier ein komplettes Anwendungsbeispiel für die LoaderClass: Ein Bilderwechsler, der eine Liste von Bildern hintereinander lädt und beim Übergang eine Überblendung macht.

// Die Klasse braucht den Code der LoaderClass
#include "com.qlod.LoaderClass.as"
 
// Erzeuge Instanz der Klasse 
o = _global.PictureChangerClass = function(){
    if(arguments[0] == 'NO_INIT') return;
    this.init.apply( this, arguments);
}
//
o = o.prototype; 
//
// initialisiere die Instanzeigenschaften
// und den Loader
o.init = function( showtimeMs, fadeStepMs, fadeStep){
    this.showtimeMs = showtimeMs;
    this.fadeStepMs = fadeStepMs;
    this.fadeStep = fadeStep;
    //
    this.ui = null;
    this.actPic = 0;
    this.picList = null;
    //
    this.loader = new com.qlod.LoaderClass();
    this.loader.setMinSteps(5);
    this.loader.addListener( this);
}
//
// erzeuge die Movieclips für die Anzeige
o.createUI = function( base, name, depth, x, y){
    this.ui = base.createEmptyMovieClip( name, depth);
    this.ui.createEmptyMovieClip("pic0", 0);
    this.ui.createEmptyMovieClip("pic1", 1);
    this.setPos( x, y);
}
//
// positioniere die Anzeige
o.setPos = function( x, y){
    this.ui._x = x;
    this.ui._y = y;
}
//
// intialisiere die Bilderliste
o.setPicList = function( picList, directory){
    this.picList = picList;
    this.directory = directory;
    this.actPic = 0;
}
//
// liefere den Mc, der aktuell sichtbar ist
o.getActPicMc = function(){
    return this.ui["pic" + this.actPic % 2];
}
//
// liefere den Mc, der aktuell unsichtbar ist
o.getNextPicMc = function(){
    return this.ui["pic" + ((this.actPic + 1) % 2)];
}
//
// wird vom Loader aufgerufen, wenn das Laden beginnt
// das neue Bild soll zunächst unsichtbar sein
o.onLoadStart = function( loaderObj){
    this.getNextPicMc()._alpha = 0;
}
//
// wird vom Loader während des Ladens aufgerufen
// zeigt eine feine rote Linie als Ladeanzeige
o.onLoadProgress = function( loaderObj){
    this.ui.clear();
    this.ui.moveTo(0,-1);
    this.ui.lineStyle(0, 0xff0000);
    this.ui.lineTo( Math.floor(loaderObj.getStepPercent()), -1);
}
//
// wird vom Loader aufgerufen, wenn das Laden endet
// die rote Linie wird gelöscht und die Blende gestartet
o.onLoadComplete = function( loaderObj){
    this.ui.clear();
    this.startCrossFade();
}   
//
// starte die Anzeigeschleife
o.start = function(){
    this.loadNextPic();
}
//
// stoppe die Anzeigeschleife
o.stop = function(){
    clearInterval( this.interval);
}
//
// starte die Überblendung
o.startCrossFade = function(){
    this.interval = setInterval( this, "onCrossfade", this.fadeStepMs);
}
//
// wird im Interval aufgerufen
// blende die Clips langsam ineinander über
o.onCrossfade = function(){
    var ap_mc = this.getactPicMc();
    var np_mc = this.getNextPicMc()
    ap_mc._alpha -= this.fadeStep;
    np_mc._alpha += this.fadeStep;
    if( ap_mc._alpha <= 0 || np_mc._alpha >= 100){
        ap_mc._alpha = 0;
        np_mc._alpha = 100;
        clearInterval( this.interval);
        this.interval = setInterval( this, "onShow", this.showtimeMs);
    }
}
//
// wird im Interval aufgerufen
// zeige das nächste Bild
o.onShow = function(){
    clearInterval( this.interval);
    this.loadNextPic();
}
//
// lade das nächste Bild
o.loadNextPic = function(){
    this.actPic++;
    if( this.actPic >= this.picList.length) this.actPic = 0;
    this.loader.load( this.getNextPicMc(), this.getPicUrl());
}
//
// liefere die komplette Url des nächsten Bilds
o.getPicUrl = function(){
    var url = this.directory + this.picList[ this.actPic];
    return url;
}
//
delete o;
//
// Das Hauptprogramm
// Erzeuge eine Instanz der neuen Klasse, 
// initialisiere sie und starte die Bilderschleife
function main(){
    pc = new PictureChangerClass( 3000, 50, 10);
    pc.setPicList(["1.swf", "2.swf", "3.swf", "4.swf"], 
"http://www.deineDomain.de/bilder/");
    pc.createUI( _root, "PictureChanger_mc", 1, 200, 150);
    pc.start();
}
//
main(); 

Um das Script zum Laufen zu bringen, musst du
- das Script auf den ersten Frame einer neuen Fla kopieren und die Fla speichern.
- die Includedatei herunterladen (rechte Maustaste, "Ziel speichern unter" auswaehlen) und im gleichen Verzeichnis wie die Fla unter dem Name "com.qlod.LoaderClass.as" speichern.
- in der Funktion main die Liste der Bilder und den Pfad des Bilderverzeichnisses angeben, und los gehts.

Achtung Mac-Benutzer:
Wenn du mit einem Mac arbeitest, dann musst du der Include-Datei einen kürzeren Namen geben, z.B. LoaderClass.as und die Zeile mit dem #include im Script ensprechend ändern. Macs sind leider nicht in der Lage mit Dateinamen länger als 32 Zeichen umzugehen. (Dankeschön an e2e4 für den Hinweis)

Diskussion
Hier ist ein Thread, in dem ihr über den Bilderwechsler diskutieren könnt: http://www.flashforum.de/forum/showt...444#post582444

Probleme ?
Falls ihr ein unerwartetes Problem mit dem Code oder Anregungen für Verbesserungen habt, könnt ihr die an bokel.ff@helpQLODhelp.com schicken.



Viel Spass damit,
mfg r.

[bokel]

Preloading - The Definitive Guide - Teil VII

Eine neue Beta ist draussen. Folgende Änderungen gibt es

Neue Methoden zur Verwaltung der Queue
- clear() löscht alle gespeicherten Ladevorgänge
- removeCurrent() löscht den aktuellen Ladevorgang
- remove( id) löscht den angegebenen Ladevorgang

Damit letzteres funktioniert, liefern load und observe jetzt eine id

id = ldr.load(mc, "movie.swf");
ldr.remove( id); 

setParamStyleObject() ist nicht mehr nötig
Die Umschaltung habe ich entfernt, es gibt jetzt nur noch den ParamStyle Object, d.h. die Callbacks bekommen jetzt immer ein Objekt als Parameter. Die alten Callbacks gibt es nicht mehr.

// So sehen die Callbacks jetzt aus
onLoadProgress = function( loaderObj){
       var percent= loaderObj.getPercent();
}
 
onLoadComplete = function( success, loaderObj){
       if( success){
             trace("Fertig: " + loaderObj.getUrl());    
       }
} 

..Step.. getter gibt es nicht mehr
Die getter, die gesteppte Werte geliefert haben, wenn man setMinSteps eingestellt hatte, gibt es nicht mehr. Stattdessen liefern die normalen getter jetzt diese Werte.

//Es sollen mindestens 5 Schritte des 
//Ladebalkens angezeigt werden
loader.setMinSteps( 5);
 
onLoadProgress = function( loaderObj){
       //Alte Version 
       //var percent= loaderObj.getStepPercent();
       //Neue Version 
       var percent= loaderObj.getPercent();
} 

Namespace
Die Klasse liegt jetzt nicht mehr in global sondern in _global.com.qlod. Der Konstruktor wird also jetzt so aufgerufen:

// Alte Version
loader = new LoaderClass();
//Neue Version
loader = new com.qlod.LoaderClass() 

Dateiname
Der Dateiname entspricht dem Namespace und ist kürzer, so dass er auch auf Macs funktioniert.

#include "com.qlod.LoaderClass.as" 

mfg r.

[bokel]

Preloading - The Definitive Guide - Teil VII

Endlich ist sie fertig: Hier ist die Version 1.0 komplett mit Dokumentation.

Dokumentation:
http://www.helpqlodhelp.com/stuff/lo...Class.doc.html

Download:
http://www.helpqlodhelp.com/stuff/lo...erclass1.0.zip


mfg r.