richiama classeXML da classeMain

[ehijon]

avendo la classe LeggiXML.as

package {

import vari...

	public class LeggiXML extends MovieClip {

		public function LeggiXML() {
			var requesta:URLRequest= new URLRequest('file.xml');
			var loader:URLLoader= new URLLoader();
			loader.addEventListener(Event.COMPLETE,legge);

			try {
				loader.load(requesta);
			} catch (error:Error) {
				trace('Il documento non è stato caricato.');
			}
		}
		
		private function legge(es:Event) {
			var loader:URLLoader=URLLoader(es.target);
			var paginaXML:XML=new XML(loader.data);
		}

	}
}

poi nella Document Class istanzio la sudetta per richiamare il file xml.
come faccio?

così non funziona:

var leg:LeggiXML = new LeggiXML();
testo.text=leg.paginaXML;

vi prego è urgente! help please!!

[and80]

al posto tuo imposterei la classe in maniera diversa e se non ti serve che sia un elemento di visualizzazione, puoi estendere la classe EventDispatcher al posto di MovieClip
intanto devi comunque fare attenzione al fatto che il dato che vuoi estrarre non sarà comunque disponibile fino al caricamento avvenuto, di conseguenza non puoi comunque recuperare la variabile "paginaXML", se non facendoti restituire un undefined o null

io la scriverei così:

package {
    import flash.events.Event;
    import flash.events.EventDispatcher;
    import flash.events.ErrorEvent;
    import flash.events.IOErrorEvent;
    import flash.net.URLLoader;
    import flash.net.URLRequest;
    public class LeggiXML extends EventDispatcher {
        private var __r:URLRequest;
        private var __l:URLLoader;
        private var __x:XML;
        public function LeggiXML () {
            __r = new URLRequest("file.xml");
            __l = new URLLoader(__r);
            __l.addEventListener(IOErrorEvent.IO_ERROR, __error__);
            __l.addEventListener(Event.COMPLETE, __complete__);
        }
        private function __error__ (e:IOErrorEvent) {
            dispatchEvent(e);
        }
        private function __complete__ (e:Event) {
            __x = new XML(e.target.data);
            dispatchEvent(e);
        }
        public function get xml ():XML {
            return __x;
        }
    }
} 

in questo modo nel fla puoi agire così:

var l:LeggiXML = new LeggiXML();
l.addEventListener(Event.COMPLETE, complete);
function complete (e:Event) {
    testo.text = l.xml;
} 

come vedi, devi comunque attendere l'evento Event.COMPLETE per accedere alla variabile "xml"
se facessi un trace prima di allora, avresti un valore "null"

[ehijon]

ciao and80! t ringrazio ma da quando hai postato mi sono letto il malloppone riguardo al dispatchEvent() ma ho ancora dei dubbi/problemi

inizio coi dubbi:

1) mi son letto la parte riguardante il dipatchEvent()http://livedocs.adobe.com/flash/9.0_...ispatchEvent() ma volevo conferma. quindi questo metodo della classe EventDispatcher lo utilizzo (nel caso della funzione __complete__) per dire all'evento Event.COMPLETE che la funzione è stata lanciata correttamente restituendo true in LeggiXML?

2) perchè estendi EventDispatcher? perchè è necessario estendere qualcosa in questa classe?


il problemuccio invece è che il secondo listato che hai inserito, cioè quello che legge la funzione get xml dall'istanza di LeggiXML, io non ce l'ho nel .fla ma in un altra classe che posto qui sotto.
in pratica questa sarebbe la DC che alla pressione di un tasto (visualizza_bt) sullo Stage lancia leggi e alla fine mette il file xml in un campo di testo "testo"... quindi a questo punto ho agganciato il tuo listato ma temo d'aver combinato qualche casino logico..

package {
    import flash.display.*;
    import flash.net.URLLoader;
    import flash.net.URLRequest;
    import flash.text.TextField;
    import flash.events.*;
    
    public class GestioneXML extends Sprite{
        
        public function GestioneXML() {
            visualizza_bt.addEventListener(MouseEvent.MOUSE_DOWN,leggi);
        }

        private function leggi(e2:MouseEvent) {
            var leg:LeggiXML=new LeggiXML();
            leg.addEventListener(Event.COMPLETE, caricata)
        } 
             
        private function caricata(e3:Event){
            testo.text=leg.getXML;
            }
            
    }
} 

se non mi fossi spiegato posso allegare il file..
ma forse chiedo troppo...??
GRAZIE!

[and80]

se hai cambiato la funzione che restituisce la variabile xml, allora il codice va bene, altrimenti "getXML" non è una cosa che ho scritto io

per quanto riguarda i tuoi dubbi, sono connessi tra loro, infatti il metodo dispatchEvent esiste solo per le classi che estendono la classe EventDispatcher (tutti gli InteractiveObject ad esempio) ed è per questo che estendo la classe EventDispatcher su LeggiXML, perchè in questa maniera posso sfruttare il modello ad eventi anche su questa classe scritta da noi
ho un dubbio però sul fatto che la classe GestioneXML, la tua document class, non riesca a trovare il pulsante, in tal caso però avresti dovuto rilevare degli errori in fase di pubblicazione :master:

[ehijon]

grazie and80!
sei davvero gentile ma ho ancora lo stesso problema.

qui c'è uno zip con i file , mi faresti un piacere enorme a darci un occhiata..

sono insistente probabilmente, se sto abusando della tua pazienza/tempo capisco, ma sono giorni che ho questa faccia qui

[and80]

non so perchè hai gestito la cosa in quel modo, per cui ho messo apposto a modo mio, sperando che possa andarti bene, provo a spiegarti cosa ho fatto

1. ho eliminato il movieclip dalla libreria
2. ho inserito nello spazio della document class il nome della classe "RichiamaClasse"
3. ho modificato la classe RichiamaClasse che dava errori in pubblicazione, perchè non rilevava i due elementi presenti sullo stage (il SimpleButton e il TextField) e li ho richiamati tramite root e la sintassi delle parentesi quadre, così non crea problemi per rintracciarli (altrimenti dovresti mettere una riga in cui dici che root è un MovieClip e allora potresti accedere agli oggetti come se fossero proprietà di root, ma è una cosa non necessaria e ho preferito lasciare così)
4. sempre nella classe "RichiamaClasse" ho modificato la funzione "caricata" sfruttando il parametro che gli viene passato, che contiene la proprietà "target" che ci aiuta a rintracciare l'istanza della classe "Classe3" senza bisogno di dichiararla esternamente rispetto alla precedente funzione (anche questo altrimenti darebbe errore)

la classe:

package {
    import flash.display.*;
    import flash.events.Event;
    import flash.events.MouseEvent;
    import flash.text.TextField;

    public class RichiamaClasse extends MovieClip {
        public function RichiamaClasse() {
            root['classe3_bt'].addEventListener(MouseEvent.MOUSE_DOWN, c3);
        }
        private function c3(e:MouseEvent) {
            var cl = new Classe3();
            cl.addEventListener(Event.COMPLETE, caricata);
        }
        private function caricata(e:Event) {
            root['testo'].text = e.target.xml;
        }
    }
} 

[ehijon]

GRAZIE! grande Andrea!

funziona e ho capito quasi tutto, domani a mente fresca lo analizzo un po meglio..
mi avevano anche suggerito col dispatchEvent di creare un evento personalizzato per gestire l'errore, ma anche questo lo riguardo domani..

maaa..

4. sempre nella classe "RichiamaClasse" ho modificato la funzione "caricata" sfruttando il parametro che gli viene passato, che contiene la proprietà "target" che ci aiuta a rintracciare l'istanza della classe "Classe3" senza bisogno di dichiararla esternamente rispetto alla precedente funzione (anche questo altrimenti darebbe errore)

maaaa... perchè dovrebbe dare errore se al posto di utilizzare l'evento passato (cl.target.xml) utilizzo l'istanza della classe (e.target.xml)? il parametro e non contiene cl ?






ps: bello il v2online.it/2005 ... anche il /2008 ..ho un debole per i layer liquidi

[and80]

il 2008 è solo un abbozzo e sono quasi certo che lo cambierò al più presto, non appena avrò il tempo e l'ispirazione per comporlo

per quanto riguarda la questione del dispatchEvent, puoi tranquillamente creare un evento personalizzato, ma non è molto diverso da quello che ti ho proposto io, che sfrutta direttamente un evento conosciuto (Event.COMPLETE), quindi puoi tranquillamente evitare

per quanto riguarda invece la questione del punto 4, se usi "cl" fuori dal punto in cui l'hai dichiarato, questo non esisterà, quindi a meno che tu non lo crei prima della dichiarazione del costruttore, questo non sarà visibile dentro la funzione "caricata()"
il parametro che viene passato automaticamente alla funzione che viene aggiunta come evento, consente di evitare questo passaggio grazie al suo parametro "target" che contiene un puntatore all'oggetto che ha spacciato l'evento, quindi in questo caso a "cl"
è una semplificazione che evita errori dovuti al flusso dei file caricati esternamente ecc
ti accorgerai sicuramente del suo potenziale quando dovrai gestire un'azione su più pulsanti, ad esempio assegnandoli in un ciclo for evitando di ripetere l'assegnazione delle funzioni (metti un rollover/rollout uguale per tutti i pulsanti di un menù)

[ehijon]

mmmm.. capito.

mi sono appena sparato il malloppone sulla creazione di un evento personalizzato... e alla fine mi è venuto un dubbio cruciale su una banalità, appunto l'Event.COMPLETE ma in rete non ho trovato chiarimenti precisi.

        private function c3(e:MouseEvent) { 
            var cl = new Classe3(); 
            cl.addEventListener(Event.COMPLETE, caricata);   <-------- 
         altraFunzione();
        } 
        private function caricata(e:Event) { 
            root['testo'].text = e.target.xml; 
        } 

nel punto indicato, se la l'istanza cl della classe non ha ancora COMPLETato la lettura/esecuzione della Classe3, viene lanciata ugualmente altraFunzione()?

oppure la lettura del codice si interrompe finquando Classe3 non è stata eseguita totalmente?

se fosse il primo caso, che differenza c'è tra COMPLETE e OPEN...




ps. cmq nel /2008, a me il gioco del riflesso della scritta e il cambio colore piace un sacco!

[and80]

gli eventi in flash vengono assegnati e attivati in maniera asincrona rispetto a quando sono stati richiamati, cosa che viene fatta secondo interazione dell'utente o disponibilità dei file esterni, quindi il programma non si ferma nella lettura del codice fino a che un evento non è stato attivato, ma prosegue leggendo riga per riga tutto il listato
di conseguenza la tua funzione verrà eseguita immediatamente dopo che l'evento è stato assegnato, ma non dopo che si è concluso

"se fosse il primo caso, che differenza c'è tra COMPLETE e OPEN..."

non è che abbia capito molto di questa affermazione, comunque OPEN viene eseguito nel momento in cui si apre la richiesta di caricamento e complete quando il caricamento è completato