Für mein Verständnis

[kuehner]

Hallo,

Ich habe ein kleines Problem und brauche etwas Hife von einem Flash-Experten. Ich hoffe auch, dass ich meine Applikation nicht "standardmäss" aufbaue.

Ich habe eine Routine geschrieben, welche ein XML-File einliest. Meine Routine braucht 3 Frames dazu.

Mein "Symbol" (ein Tank mit einer Zahl drauf) füge ich im ersten Frame ein. Dieses Objekt (ein Movieclip) enthält eine Zahl, die sich ändern soll und ist mit einer As2-Klasse verbunden (class Tank). Diese enthält die Funktionen getTemperature() und setTemperature(). Im dritten Frame (also wenn die Zahlen geladen sind) mache ich:

Tank.setTemperature(datavale[1]);

Ein Trace in der Funktion setTemperature() zeigt mir, dass die Temperatur gespeichert wurde.

Wie kann ich nun diese As2-Klasse benutzen um den Text der Temperatur in meinem Movieclip-Symbol zu ändern?

Hat jemand von euch eine Idee? Da gibt es bestimmt Regeln dafür.

Danke!

P.S.:
Mein Movieclip "Tank" muss unbedingt im ersten Frame stehen, weil ich regelässig das XML-File überprüfen muss. Also "Loading XML" oder so was und dann der Clip wäre unzulässig.

[hazy fantazy]

Hier ist mal eine Lösung, bei der ich mit Kanonen auf Spatzen geschossen habe:

class MainClass{
 
    private static var instance:MainClass;
    
    public static function main( timeline:MovieClip){
        instance = new MainClass( timeline);
    }
    
 
    
    private var controller:ControllerClass;
    
    private function MainClass( timeline:MovieClip){
        initApplication(timeline);
        startApplication();
    }
    
    private function initApplication(timeline:MovieClip){
        var config:ConfigClass = new ConfigClass();
        config.addProperty("TIMELINE", timeline);
        config.addProperty("INTERVAL_MS", 1500);
        config.addProperty("URL", "test.xml");
 
        controller = new ControllerClass();
        controller.setConfig( config);
        
        ControlledUIComponent.setController( controller);
    }
    
    private function startApplication(){
        controller.startApplication();
    }
    
 
}
 
 
class ControllerClass{
    
    private var intervalId:Number = -1;
    private var data:DataClass;
    private var config:ConfigClass;
    
 
    public function ControllerClass( ){
        data = new DataClass();
        data.addEventListener("loadDataError", this);
        data.addEventListener("loadDataComplete", this);
    }
    
    public function startApplication(){
        loadDataAsynch();
    }
    
    private function loadDataAsynch(){
        data.loadDataAsynch( config.getString('URL'));
    }
    
    private function loadDataError( evt:Object){
        trace("Error loading xml: status: " + evt.target.status + " url:" + evt.url);
        waitAsynch();
    }
    
    private function loadDataComplete( evt:Object){
        waitAsynch();
    }
    
    private function waitAsynch(){
        clearInterval( this.intervalId);
        intervalId = setInterval( this, "loadDataAsynch", config.getNumber('INTERVAL_MS'));
    }
    
    private function waitComplete(){
        clearInterval( intervalId);
        intervalId = -1;
        loadDataAsynch();
    }
    
    //wird im onLoad des ControlledUIComponent Clips aufgerufen
    public function registerClip( clip:ControlledUIComponent){
        if( clip instanceof TankClass){
            registerTank( TankClass( clip));
        }
    }
    
    private function registerTank( tank:TankClass):Void{
        var d:DataClass = data;
        d.addEventListener("loadDataComplete", function(){
            tank.setTemperature( d.getTemperature());                                    
        });
    }
    
    public function setConfig( config:ConfigClass){
        this.config = config;
    }
    
    public function getConfig():ConfigClass{
        return config;
    }
    
 
    
}
 
import mx.events.EventDispatcher;
 
class DataClass{
    
    private var x:XML;
    
    public function DataClass(){
        EventDispatcher.initialize( this);
    }
    
    private function dispatchEvent( evt:Object){};
    public function addEventListener( type:String, listener:Object){};
    public function removeEventListener( type:String, listener:Object){};
    
    
    
    public function loadDataAsynch( url:String){
        var x:XML = new XML();
        x.ignoreWhite = true;
        
        var ref:DataClass = this;
        var evt:Object = new Object({target:x, url:url});      
        x.onLoad = function( success:Boolean):Void{
            if( ! success){
                evt.type = "loadDataError";
                ref.dispatchEvent(evt);
            } else {
                ref.x = this;
                evt.type = "loadDataComplete";
                ref.dispatchEvent(evt);
            }
        }
        x.load( url);
    }
    
    public function getTemperature():Number{
        var result:Number = parseFloat( 
            XMLUtil.getText( 
                XMLUtil.getNodeById( x, 'temperature')));
        return result;
    }
}
 
 
//Der MovieClip, der mit der TankClass verknüpft ist
//enthält ein dynamisches TextFeld namens tfTemperature
 
class TankClass extends ControlledUIComponent {
 
    
    public static var DEFAULT_TEMPERATURE:Number = 0;
 
    
    private var temperature:Number = DEFAULT_TEMPERATURE;
    private var tfTemperature:TextField;
 
    
    private function onLoad(){
        super.onLoad();
        update();
        
    }
    
    private function update(){
        trace("TankClass::update " + [temperature, this]);
        tfTemperature.text = temperature.toString();
    }
    
    public function setTemperature( v:Number){
        if( isNaN( v)) return;
        temperature = v;
        update();
    }
    
    public function  getTemperature():Number{
        return temperature;
    }
}
 
 
class ControlledUIComponent extends MovieClip {
    
    private static var controller:ControllerClass;
    
    public static function setController( c:ControllerClass){
        controller = c;    
    }
    
    private function onLoad():Void{
        controller.registerClip( this);
    }
 
}
 
 
class ConfigClass{
    
    private var data:Object;
 
    
    public function ConfigClass(){
        data = new Object();
    }
    
    public function addProperty( name:String, value:Object){
        data[name] = value;
    }
    
    public function hasProperty( name:String):Boolean{
        return data.hasOwnProperty( name);
    }
    
    public function getProperty( name:String):Object{
        return data[name];
    }
    
    public function getString( name:String):String{
        return data[name];
    }
    
    public function getNumber( name:String):Number{
        return data[name];
    }
}
 
 
 
class XMLUtil {
    
    public static function getNodeById( x:XML, id:String):XMLNode{
        var result:XMLNode;
        if( x.hasOwnProperty('idMap')){
            result = x['idMap'][id];
        } else {
            result = x[id];
        }
        return result;
    }
    
    public static function getText( node:XMLNode):String{
        return node.childNodes.join('');
    }
}
 
 
//test.xml sieht so aus
<data>
     <value id="temperature">123</value>
</data> 

Ok, fürs Verständnis nicht unbedingt hilfreich, aber hat trotzdem Spass gemacht.

mfg h

[kuehner]

Hallo,

Danke für Deine Hilfe. Deine Bazooka hat meinen Spatz wirklich abgeschossen. Deine Lösung hilft mir auf jeden Fall... vor allem, um etwas ActionScript zu lernen.

[bokel]

Jau, schönes Beispiel.
Dabei fällt mir ein, dass ich dringend mal eine Übersicht erstellen muss, über die Möglichkeiten andere Klassen oder Objekte zu referenzieren. Die Methode, mit der gemeinsamen Basisklasse ControlledUIComponent ist nicht schlecht.
mfg. r