[AS3] Loader SWF

[alistar]

Ciao a tutti,
sono da poco passato da as2 ad as3, e sto incontrando qualche difficoltà nel riscrivere alcuni progetti....

Dovendo caricare un swf (test.swf) dentro main.fla, mi sono scritto una classetta con un loader e tutto funziona.
A questo punto, in test.swf, devo caricare un altro swf (test2.swf).

Il problema del giorno è il seguente:
test2.swf assume proprietà di x e y relative non a test.swf, ma a main....
Quindi se io setto la x di test.swf a 100 e da qui carico test2.swf con x a 0, vedo test2.swf con x a 0 su main. VVoVe:

Lo so che il discorso è molto contorto, ma non so in quale altro modo spiegarlo....
Non vorrei aver sbagliato qualcosa nella classe che carica....

Avete quanche soluzione da propormi?????

[and80]

verificherei che il loader che carica il secondo filmato sia effettivamente figlio del primo, o meglio che sia figlio di primo_loader.content

[alistar]

Dal tuo consiglio deduco che non ho capito come funziona il loader in as3
Io ho scritto una classe movieLoader.as cosi strutturata:

package {
    import flash.display.Loader;
    import flash.display.Sprite;
    import flash.net.URLRequest;
    import flash.events.*;

    public class movieLoader extends Sprite {
        var loader:Loader = new Loader();

        public function movieLoader(re:Object, id) {

            configureListeners(loader.contentLoaderInfo);
            var request:URLRequest = new URLRequest(re[id]['modulepath']);
            loader.load(request);
            addChild(loader);

            function configureListeners(dispatcher:IEventDispatcher):void {
                dispatcher.addEventListener(Event.OPEN, openHandler);
                dispatcher.addEventListener(IOErrorEvent.IO_ERROR, ioErrorHandler);
                dispatcher.addEventListener(ProgressEvent.PROGRESS, progressHandler);
                dispatcher.addEventListener(Event.COMPLETE, completeHandler);
            }

            function completeHandler(event:Event):void {
            }

            function ioErrorHandler(event:IOErrorEvent):void {
            }

            function openHandler(event:Event):void {
            }

            function progressHandler(event:ProgressEvent):void {
            }
        }
    }
} 

Mentre nel main.fla ho scritto:

for (var i in result) {
    var mc:movieLoader = new movieLoader(result, i);
    mc.name = i;
    trace(mc.name);
    mc.x = result[i]['position']['x'];
    mc.y = result[i]['position']['y'];
    stage.addChild(mc);
} 

dove result è un oggetto risultato di una chiamata ad un servizio amfphp che contiene le path e le proprietà di una serie di swf che dovrei caricare.

Ho scritto enormi cavolate o può andare?
Dal punto di vista pratico questa parte di codice funziona (nel senso che visualizzo bene tutto)....

[and80]

la classe va bene, apparte la dichiarazione delle funzioni che potevi lasciare fuori dal costruttore e dicharare come private, io avrei fatto così:

package {
    import flash.display.Loader;
    import flash.display.Sprite;
    import flash.events.*;
    import flash.net.URLRequest;
    public class MovieLoader extends Sprite {
        private var __r:URLRequest;
        private var __l:Loader;
        public function MovieLoader (u:String) {
            __r = new URLRequest(u);
            __l = new Loader();
            __l.load(__r);
            __listeners__(__l.contentLoaderInfo);
            addChild(__l);
        }
        private function __listeners__(d:IEventDispatcher):void {
            d.addEventListener(Event.OPEN, __open__);
            d.addEventListener(IOErrorEvent.IO_ERROR, __ioerror__);
            d.addEventListener(ProgressEvent.PROGRESS, __progress__);
            d.addEventListener(Event.COMPLETE, __complete__);
        }
        private function __complete__ (e:Event):void {
            dispatchEvent(e);
        }
        private function __ioerror__ (e:IOErrorEvent):void {
            dispatchEvent(e);
        }
        private function __open__ (e:Event):void {
            dispatchEvent(e);
        }
        private function __progress__(e:ProgressEvent):void {
            dispatchEvent(e);
        }
        public function get loader ():Loader {
            return __l;
        }
    }
} 

e anche il primo codice è ok, quello che non mi è chiaro è invece il codice che carica "test2.swf" in "test.swf" e dove viene richiamato (in quale timeline)

[alistar]

Intanto grazie mille per i consigli
Per quanto riguarda test2.swf, questo viene caricato da test.swf attraverso una classe simile alla precendente, quindi test2.swf viene richiamato nella timeline di test.swf...

Spero di essere stato abbastanza chiaro.
In as2 lo facevo tranquillamente, ora non so perchè non va.

Hai qualche consiglio?

[and80]

se test2.swf viene caricato dalla timeline di test.swf, non dovresti riscontrare questo problema di coordinate, avevo pensato che tentassi il caricamento di test2.swf da main, per poi inserirlo come child di test.swf
se ti va, puoi mandarmi i file così che ne possa vedere il comportamento

[edit] ho fatto un test con la classe, ma caricando un'immagine su test.swf

quindi:

// main.swf
var loadSWF:MovieLoader = new MovieLoader("test.swf");
loadSWF.x = 100;
loadSWF.y = 100;
addChild(loadSWF);

// test.swf
var loadImage:MovieLoader = new MovieLoader("test.jpg");
addChild(loadImage); 

funziona come ci si aspetta, ossia su main.swf il filmato viene posizionato a x100-y100

[alistar]

Scusa ma ho potuto collegarmi solo ora....
Non so il perchè, ma funziona!

Potrebbe aver influito il fatto che io avevo scritto stage.addChild() invece del semplice addChild()?

Non mi è ancora chiara la funzione di stage e root in as3...
Ad esempio, in test2.swf, come faccio richiamare una funzione presente su main e viceversa?

Scusa se ti faccio tutte queste domande, ma vorrei capire bene le dinamiche di questo "nuovo" linguaggio...

[and80]

Stage è l'elemento principale del filmato, quello che contiene la definizione dell'istanza della classe di visualizzazione che contiene tutto il resto

la classe principale è una estensione della classe MovieClip e sulla timeline prende nome di root e può essere richiamata con "this"

se sulla timeline principale fai

trace(this);
trace(root);
trace(stage);
trace(root is MovieClip); 

ottieni

[object MainTimeline]
[object MainTimeline]
[object Stage]
true 

this e root coincidono in MainTimeline che è la classe principale creata automaticamente da flash ed estende la classe MovieClip, e come MovieClip è "dynamic", il che significa che puoi assegnargli nuove variabili senza dover estendere la classe, quindi ad esempio sulla timeline this.prova="ciao" crea una proprietà "prova" nell'istanza della classe MainTimeline

ne consegue che ogni swf conterrà tale classe dinamica e perciò le variabili appartenenti alla MainTimeline di ogni swf potranno essere rintracciate, trovando la giusta MainTimeline

nel caso di un filmato esterno caricato in un Loader, è possibile rintracciarne "root" attraverso la proprietà "content" del loader, ad esempio consideriamo di avere due filmati, "main.swf" e "ext.swf"
definiamo in "ext" una variabile sulla timeline principale (var prova="ciao") e su "main" un Loader in cui carichiamo "ext"
possiamo da Loader recuperare la variabile definita in ext richiamandola nell'evento Event.INIT

var loader:Loader = new Loader();
loader.load(new URLRequest("ext.swf"));
loader.contentLoaderInfo.addEventListener(Event.INIT, initHandler);
function initHandler (event:Event) {
    trace(event.target.loader.content.prova); // output: ciao
} 

[alistar]

Grazie per l'ottima guida

Ora la domanda è questa:
avendo nel mio main.fla

for (var i in result) {
        var loadSW:movieLoader = new movieLoader(result[i]['modulepath']);
        loadSWF.name = i;
        trace(loadSWF.name);
        loadSWF.x = result[i]['position']['x'];
        loadSWF.y = result[i]['position']['y'];
        addChild(loadSWF);
} 

che utilizza la classe che mi hai modificato, come faccio a richiamare in un secondo momento il loader che mi interessa e quindi utilizzare il content?

Ad esempio, nell'oggetto result sono presenti un numero variabile di swf da caricare...
Come faccio ad utilizzare il content di uno invece di quello di un altro?

[and80]

io registrerei i movieLoader dentro un array, quindi invece di fare come ora, faresti:

var loaderContainer:Array = new Array();
for (var i in result) {
        loaderContainer.push(new movieLoader(result[i]['modulepath']));
        loaderContainer[loaderContainer.length-1].name = i;
        loaderContainer[loaderContainer.length-1].x = result[i]['position']['x'];
        loaderContainer[loaderContainer.length-1].y = result[i]['position']['y'];
        addChild(loaderContainer[loaderContainer.length-1]);
} 

così in questo modo avrai a disposizione tutti i movieLoader di questa operazione, come indici dell'array loaderContainer e ne potrai estrarre le proprietà a piacimento, a patto però che il contenuto di questi risulti caricato (Event.COMPLETE o Event.INIT)