codice:
fscommand("fullscreen", true);
// BLOCCO LA ROOT; SUPERFLUO IN QUESTO CASO, UTILE SE QUESTO SWF
// E' ALL' INTERNO DI UNA LATRO E CARICATO
this._lockroot = true;
// CREO IL CONTENITORE CHE E' UN MOVIECLIP CON NOME ISTANZA container DI DEFAULT
// A POSIZIONE X = 0 / Y = 0 , VISIBLE E ALPHA 100 con ROTATION 0
this.createEmptyMovieClip( 'container', this.getNextHighestDepth() );
// CREO IL GESTORE DI EVENTI, UN OGGETTO CON METODI DEDICATI
// COME LISTENER DEL MOVIECLIPLOADER ED ALTRI UTILI AL TUO SCOPO
var swfloader:Object = new Object();
// EVENTO LISTENER: onLoadInit
// Richiamato dal MovieClipLoader a MC caricato e disponibile
// [ esiste anche l' onLoadComplete, ma l' MC in quel caso non e' disponibile a keyframe 1 ]
swfloader.onLoadInit = function( mc:MovieClip ):Void {
// POSIZIONO L' SWF CARICATO AL PRIMO FRAME
_root['container'].gotoAndStop( 1 );
// LO RENDO VISIBILE
_root['container']._visible = true;
// ASSEGNO IL PATH PER RISALIRE ALL' OGGETTO
// swfloader QUANDO MI SERVIRA' ...
_root['container'].__path = this;
//DIMENSIONE CLIP 100%
_root['container']._width = Stage.width;
_root['container']._height = Stage.height;
//_root['container']._y = Math.floor( ( Stage.height / 2 ) - ( mc._height / 2 ) );
// INIZIO L' ONENTERFRAME:
// onEnterFrame e' un loop che ha latenza 1 fotogramma
// questo significa che quando e' invocato non parte immediatamente
// looppa priam sul primo keyframe del MovieClip sulla quale viene applicato
// poi passa al successivo o fa quello che gli viene detto di fare
// Nell' onEnterFrame il riferimento di default e' THIS, ovvero il MovieClip
// alla quale viene applicato.
_root['container'].onEnterFrame = function() {
// se il frame di questo MC e' un frame minore del totale frames disponibili ...
if( this._currentframe < this._totalframes ) {
// vado al frame successivo , ovvero questo frame + 1
this.gotoAndStop( ++this._currentframe );
}
// altrimenti sono a fine frames, ergo timeline finita
else {
// in questo caso controllo che il contenitore con tutti gli MC
// che e' una variabile interna all' oggetto swfloader che e' il path
// di riferimento della variabile __path di questo MC assegnata precedentemente
// ... se non esiste il prossimo filmato, basato sul fatto che l' array
// swfloader.__container sara' giunto al termine
if( this.__path.__container[ this.__path.__containerNum ] == undefined ) {
// allora reimposto la variabile swfloader.__containerNum a 0, cosi'
// da ricaricare il primo degli SWF disponibili
this.__path.__containerNum = 0;
}
// a questo punto sono sicuro che esistera' il valore contenuto nell' array
// swfloader.__container[ this.__path.__containerNum ]
// che per comodita' incremento di 1 per passare poi al controlo sul valore contenuto
// nel prossimo indice dell' array swfloader.__container
this.__path.loadMovie( this.__path.__container[ this.__path.__containerNum++ ] );
// qui elimino questo onEnterFrame perche' non mi serve piu' il LOOP su questo movieClip
delete this.onEnterFrame;
}
}
}
// EVENTO LISTENER: onLoadProgress
// Richiamato dal MovieClipLoader durante il caricamento del MovieClip
// ci rende noti i bytes caricati e quelli totali
swfloader.onLoadProgress = function( mc:MovieClip, bl:Number, bt:Number ):Void {
// creo la solita perc , magari la usi ma in locale questo metodo non
// funzionera' mai, o meglio, non te ne accorgi, solo online servira' a qualcosa
var p:Number = Math.floor( ( bl / bt ) * 100 );
if( p != NaN && p != infinity && p > 0 ) {
trace( mc + ', ' + p );
}
}
// EVENTO LISTENER: onLoadError
// Richiamato dal MovieClipLoader se e' impossibile caricare il file richiesto
// Rende noto l' errore generato
swfloader.onLoadError = function( mc:MovieClip, error:String ):Void {
trace( error );
}
// EVENTO PERSONALE, ASSEGNATO PER COMODITA': loadMovie
// Questo evento dell' oggetto swfloader altro on fa che eliminare
// il precedente MovieClipLoader per ricrearlo su una variabile interna
// quale e' __ML__ , allo stesso tempo esegue l' unloadMOvie sul MovieClip
// container della _root, probabilmente superfluo visto che un loadMovie su
// un movieClip che ha caricato qualcosa, scarica questo qualcosa in automatico
// ... ma imho sempre meglio fare le cose in modo ordinato
swfloader.loadMovie = function( swf:String ):Void {
// metto l' MC invisibile, cosi' durante il caricamento, nell' onLoadProgress
// sono sicuro che se l' SWF non ha STOP(); a inizio filmato tale filmato non mi parta per
// i fatti suoi frame dopo frame , a seconda di cosa carica
_root['container']._visible = false;
// se e' almeno la seconda volta che richiamo questo metodo __ML__ sara' definito
if( this.__ML__ != undefined ) {
// quindi scarico il MovieClip container e cancello la variabile __ML__ ....
_root['container'].unloadMovie();
delete this.__ML__;
}
// la quale viene riassegnata o creata come MovieClipLoader
this.__ML__ = new MovieClipLoader();
// per poi aggiungergli swfloader come listener, in modo da far gestire al MovieClipLoader
// glie eventi dedicati descritti sopra
this.__ML__.addListener( this );
// per poi dirgli cosa caricare e dove, in questo caso carica il testo contenuto
// in swf sul movieClip _root['container']
this.__ML__.loadClip( swf, _root['container'] );
}
// EVENTO PERSONALE, ASSEGNATO PER COMODITA': preload
// Questo metodo er' l' inizializzatore di tutto sto' sistemino di caricamento files
// altro non fara' che leggersi le informazioni sui nomi dei files che andranno a popolare
// l' array creato per gestire il loop, inizializzare, oltre l' array, una variabile
// numerica per controllare o sapere sempre a che punto dell' array sono e cosa devo
// caricare poi, tale variabile sara' swfloader.__containerNum , mentre l' array sara'
// swfloader.__container
swfloader.preload = function( txtFile:String ):Void {
// creo l' oggetto LoadVars con scope interno, perche' una volta usato non mi servira' piu'
var __lv__:LoadVars = new LoadVars();
// dico a questo oggetto il path di riferimento per creare o gestire variabili appartenenti a swfloader
// ovviamente essendo dentro un metodo di swfloader il path di riferimento sara' THIS, riferito a se stesso
__lv__.__path = this;
// scrivo cosa fare all' onLoad
__lv__.onLoad = function( s:Boolean ):Void {
// se trovo il file ...
if( s == true ) {
// creo la variabile swfloader.__container come nuovo Array
this.__path.__container = new Array();
// mi creo una variabile convenzionale per fare il loop delle informazioni nel file di testo
var a:Number = 0;
// finche' esiste 'fileN' dove N sara' incrementato di 1 in 1 ad ogni loop di questo ciclo ...
while( this['file'+String(a)] != undefined ) {
// aggiungi all' Array swfloader.__container il nome o il testo di questa variabile
// this['file'+String( a )] sara' esattamente this.file0 , this.file1, etc etc
// per comodita' incremento la a direttamente in assegnazione
this.__path.__container.push( this['file'+String( a++ )] );
}
// arrivati a this.fileN , inesistente , quindi undefined, quindi usciti dal ciclo precedente ...
// creo la variabile numerica swfloader.__containerNum facendola partire da 0 ... poi
// sara' questo applicativo stesso a gestirla, incrementarla o riresettarla
this.__path.__containerNum = new Number( 0 );
// bene, ho le informazioni sull' array, ho il primo elemento da caricare
// ... quale momento migliore per far partire il tutto ???
this.__path.loadMovie( this.__path.__container[ this.__path.__containerNum++ ] );
// per comodita' incremento di uno la variabile swfloader.__containerNum
// cosi' al prossimo controllo sull' array verifichero' che esista
// swfloader.__container[1] e non zero che gia' so di averlo usato e che quindi e' presente nell' array
}
else {
// impossibile caricare il file di testo
this.__path.onLoadError( _root, 'Impossibile caricare il file: ' + txtFile );
}
}
// effettuo il load del file specificato in txtFile
__lv__.load( txtFile );
}
// avvio l' ambaradan ...
swfloader.preload( 'file.txt' );
negli swf che carico devo mettere qualcosa o si adatteranno in automatico al monitor anche se lo stage ha dimensioni diverse?
Rispondi quotando
