function-zugriffs-konflickte

[TheFreeman]

Hi, Leute.

Ich habe auf _Level0 eine function liegen, auf die drei Schaltflächen zugreifen, wenn man mit der Maus darüberrollt.
Diese function soll die Farbwerte der jeweiligen Schaltfläche dynamisch und mit fließendem Übergang verändern.

Wenn ich über eine Schalfläche rolle, dann geht alles glatt.
Rolle ich aber schnell über mehrere Schaltflächen, dann kommt die function durcheinander mit den Farbwerten und es gibt ein heilloses durcheinander.

Wie kann ich es schaffen, daß es kein Durcheinander gibt?
Mit einer Klasse, oder sowas? Wie stelle ich das an?

[ludabruda]

hmm, machst du das in einer Rekursion?
Wie übergibst du die Refernz für das aktuelle Objekt?

Möglicherweise überschreibst du beim schnellen Drüberfahren immer wieder die Objektreferenz, sodass immer ein anderes Objekt angesprochen wird.

Könntest du die Funktion mal posten?

Grüße
Sascha

[TheFreeman]

Also hier ist die Funktion, die von den Schaltflächen aufgerufen wird:

// Farbwechsel für die Schaltflächen
function fwechsel1(co,sc,nc,st){
        cnt=0;
        this.startColor = sc;
        this.newColor = nc;
        this.col = new Color(_root[co]); // Farb-Objekt
        this.col.setRGB(parseInt(this.startColor,16));  // setzen des Startwerts
        this.steps = st;
        this.r = parseInt(this.startColor.substr(0,2),16); // ermitteln der einzelnen Komponenten des Startwerts
        this.g = parseInt(this.startColor.substr(2,2),16);
        this.b = parseInt(this.startColor.substr(4,2),16);
        
        this.newR = parseInt(this.newColor.substr(0,2),16); // ermitteln der einzelnen Komponenten des Endwerts
        this.newG = parseInt(this.newColor.substr(2,2),16);
        this.newB = parseInt(this.newColor.substr(4,2),16);
        
        this.diffR = (this.r - this.newR) / this.steps; // Berechnung der Differenzen
        this.diffG = (this.g - this.newG) / this.steps;
        this.diffB = (this.b - this.newB) / this.steps;
 
    this.onEnterFrame = function(){
            cnt++;
            if(cnt < this.steps+1) {
                this.rgb = this.col.getRGB().toString(16); // aktuelle Farbe auslesen
                this.r = parseInt(this.rgb.substr(0,2),16);
                this.g = parseInt(this.rgb.substr(2,2),16);
                this.b = parseInt(this.rgb.substr(4,2),16);
                this.newR = Math.floor(this.r-this.diffR).toString(16);
                this.newG = Math.floor(this.g-this.diffG).toString(16);
                this.newB = Math.floor(this.b-this.diffB).toString(16);
                if(this.newR.length == 1) this.newR = "0" + this.newR;
                if(this.newG.length == 1) this.newG = "0" + this.newG;
                if(this.newB.length == 1) this.newB = "0" + this.newB;
                this.newColString = this.newR + this.newG + this.newB;    // neue Farbe zusammensetzen und zuweisen
                this.col.setRGB(parseInt(this.newColString,16));
            }else{
                cnt=0;
                delete this.onEnterFrame;   
            }
    }
} 

Und hier ist der Aufruf von einer Schalfläche:

send.onRollOver = function(){
    fwechsel1("send", _root.Farbe1, _root.Farbe2, _root.Stufen);
} 

Vielen Dank für Deine schnelle Antwort.

[HAY]

hi
so wie ich das sehe überschreibst du die varablen und den onenterframe bei jedem onrollover.

[ludabruda]

Du verwendest in deiner Funktion die Referenz auf this.
Da diese Funktion auf der HZL liegt, ist this in diesem Fall immer _root. resp. _level0....

Du willst aber doch sicherlich das auslösende Objekt als Referenz nehmen.
Übergib sinnvollerweise nicht den Namen "send" des Objekts, sondern das Objekt selbst:

send.onRollOver = function() {
fwechsel1(this, _root.Farbe1, _root.Farbe2, _root.Stufen);
}

In der Funktion arbeitest du dann nicht mit this, sondern mit co, also deiner Objekt-Referenz.

So, wie es jetzt ist, bekommt auch immer _level0 den onEnterFrame, nicht die Instanz...daher das Kuddelmuddel.-..

Grüße
Sascha

PS: hab mir den restlichen Code jetzt nicht weiter angesehen, check das vielleicht erstmal.

[TheFreeman]

Geschrieben von HAY
hi
so wie ich das sehe überschreibst du die varablen und den onenterframe bei jedem onrollover.

Ja, das weiß ich. Deswegen frage ich nach einer eleganten Lösung.

Geschrieben von ludabruda
Du verwendest in deiner Funktion die Referenz auf this.
Da diese Funktion auf der HZL liegt, ist this in diesem Fall immer _root. resp. _level0....

Du willst aber doch sicherlich das auslösende Objekt als Referenz nehmen.
Übergib sinnvollerweise nicht den Namen "send" des Objekts, sondern das Objekt selbst:

send.onRollOver = function() {
fwechsel1(this, _root.Farbe1, _root.Farbe2, _root.Stufen);
}

Das funzt aber nicht so wie vorgesehen, da Flash dann den Haupfilm in die Farben setzt.

Geschrieben von ludabruda
In der Funktion arbeitest du dann nicht mit this, sondern mit co, also deiner Objekt-Referenz.

So, wie es jetzt ist, bekommt auch immer _level0 den onEnterFrame, nicht die Instanz...daher das Kuddelmuddel.-..

Das funzt auch nicht richtig.

Kann ich das nicht mit Klassen lösen, oder so?

[HAY]

hi
wen du das weißst dann must du machen
änder mal die ganzen "this" in "this[co]"

this[co].cnt=0;
        this[co].startColor = sc;
        this[co].newColor = nc;
        this[co].col = new Color(this[co]); // Farb-Objekt
        this[co].col.setRGB(parseInt(this[co].startColor,16));  // setzen des Startwerts
        this[co].steps = st;
        this[co].r = parseInt(this[co].startColor.substr(0,2),16); // ermitteln der einzelnen Komponenten des Startwerts
        this[co].g = parseInt(this[co].startColor.substr(2,2),16);
        this[co].b = parseInt(this[co].startColor.substr(4,2),16);
        
        this[co].newR = parseInt(this[co].newColor.substr(0,2),16); // ermitteln der einzelnen Komponenten des Endwerts
        this[co].newG = parseInt(this[co].newColor.substr(2,2),16);
        this[co].newB = parseInt(this[co].newColor.substr(4,2),16);
        
        this[co].diffR = (this[co].r - this[co].newR) / this[co].steps; // Berechnung der Differenzen
        this[co].diffG = (this[co].g - this[co].newG) / this[co].steps;
        this[co].diffB = (this[co].b - this[co].newB) / this[co].steps;
        
        this[co].onEnterFrame = function(){ 

bis hier und dann

send.onRollOver = function(){
            fwechsel1("send", _root.Farbe1, _root.Farbe2, _root.Stufen);
} 

[ludabruda]

wieso, geht doch?!

function fwechsel1(co,sc,nc,st){
        cnt=0;
        co.startColor = sc;
        co.newColor = nc;
        co.col = new Color(_root[co._name]); // Farb-Objekt
        co.col.setRGB(parseInt(co.startColor,16));  // setzen des Startwerts
        co.steps = st;
        co.r = parseInt(co.startColor.substr(0,2),16); // ermitteln der einzelnen Komponenten des Startwerts
        co.g = parseInt(co.startColor.substr(2,2),16);
        co.b = parseInt(co.startColor.substr(4,2),16);
        
        co.newR = parseInt(co.newColor.substr(0,2),16); // ermitteln der einzelnen Komponenten des Endwerts
        co.newG = parseInt(co.newColor.substr(2,2),16);
        co.newB = parseInt(co.newColor.substr(4,2),16);
       
        co.diffR = (co.r - co.newR) / co.steps; // Berechnung der Differenzen
        co.diffG = (co.g - co.newG) / co.steps;
        co.diffB = (co.b - co.newB) / co.steps;
            
        co.cnt = 0;
        co.onEnterFrame = function(){
                this.cnt++;
                if(this.cnt < this.steps+1) {
                        this.rgb = this.col.getRGB().toString(16); // aktuelle Farbe auslesen
                        this.r = parseInt(this.rgb.substr(0,2),16);
                        this.g = parseInt(this.rgb.substr(2,2),16);
                        this.b = parseInt(this.rgb.substr(4,2),16);
                        this.newR = Math.floor(this.r-this.diffR).toString(16);
                        this.newG = Math.floor(this.g-this.diffG).toString(16);
                        this.newB = Math.floor(this.b-this.diffB).toString(16);
                        if(this.newR.length == 1) this.newR = "0" + this.newR;
                        if(this.newG.length == 1) this.newG = "0" + this.newG;
                        if(this.newB.length == 1) this.newB = "0" + this.newB;
                        this.newColString = this.newR + this.newG + this.newB;    // neue Farbe zusammensetzen und zuweisen
                        this.col.setRGB(parseInt(this.newColString,16));
                }else{
                        this.cnt=0;
                        delete this.onEnterFrame;
                }
        }
}
 
send.onRollOver = function(){
        fwechsel1(this, _root.Farbe1, _root.Farbe2, _root.Stufen);
} 

Grüße
Sascha

[TheFreeman]

Die Lösung von hudabruda geht nicht, weil sich da immer _level0 angesprochen fühlt.

Und die Lösung von Hay sollte eigentlich funktionieren, tut sie aber nicht.
Ich habe nun folgendes gemacht:

movieClip.prototype.fwechsel1 = function(co,sc,nc,st){
    trace(this[co]);
        this[co].cnt=0;
        this[co].startColor = sc;
        this[co].newColor = nc;
        this[co].col = new Color(this[co]); // Farb-Objekt
        this[co].col.setRGB(parseInt(this[co].startColor,16));  // setzen des Startwerts
        this[co].steps = st;
        this[co].r = parseInt(this[co].startColor.substr(0,2),16); // ermitteln der einzelnen Komponenten des Startwerts
        this[co].g = parseInt(this[co].startColor.substr(2,2),16);
        this[co].b = parseInt(this[co].startColor.substr(4,2),16);
        
        this[co].newR = parseInt(this[co].newColor.substr(0,2),16); // ermitteln der einzelnen Komponenten des Endwerts
        this[co].newG = parseInt(this[co].newColor.substr(2,2),16);
        this[co].newB = parseInt(this[co].newColor.substr(4,2),16);
        
        this[co].diffR = (this[co].r - this[co].newR) / this[co].steps; // Berechnung der Differenzen
        this[co].diffG = (this[co].g - this[co].newG) / this[co].steps;
        this[co].diffB = (this[co].b - this[co].newB) / this[co].steps;
 
    this[co].onEnterFrame = function(){
            this.cnt++;
            if(this.cnt < this.steps+1) {
                trace(this);
                this.rgb = this.col.getRGB().toString(16); // aktuelle Farbe auslesen
                this.r = parseInt(this.rgb.substr(0,2),16);
                this.g = parseInt(this.rgb.substr(2,2),16);
                this.b = parseInt(this.rgb.substr(4,2),16);
                this.newR = Math.floor(this.r-this.diffR).toString(16);
                this.newG = Math.floor(this.g-this.diffG).toString(16);
                this.newB = Math.floor(this.b-this.diffB).toString(16);
                if(this.newR.length == 1) this.newR = "0" + this.newR;
                if(this.newG.length == 1) this.newG = "0" + this.newG;
                if(this.newB.length == 1) this.newB = "0" + this.newB;
                this.newColString = this.newR + this.newG + this.newB;    // neue Farbe zusammensetzen und zuweisen
                this.col.setRGB(parseInt(this.newColString,16));
            }else{
                this.cnt=0;
                delete this.onEnterFrame;   
            }
    }
} 

Er legt Eventhandler nicht an bzw. führt den Eventhandler nicht aus. Warum denn nicht. Der Pfad stimmt doch.

Es gibt keinen Übergang, sondern ein spontanes Farbwechseln.

[ludabruda]

also, bei mir funktioniert es so, wie ich es gepostet habe.
_level0 wird eben nicht angesprochen, weil ich ein Objekt übergebe, welches ich dann verwende.

Bei deinem Prototype brauchst du wohl wiederum nur this, da es einen direkten Bezug zum Objekt gibt; diese Funktion ist ja quasi ein Bestandteil deines Objekts.

Ich hab meins nochmal angehangen, wie es bei mir funktioniert.

Grüße
Sascha

[TheFreeman]

Naja, wenn ich Deine Scripts bei mir übertrage, dann funzt es nicht mehr.

Wie ich es im vorhergehenden Threat geschrieben habe, wird der EnterFrame _ Handler nicht angelegt. :-(

Ich dreh noch durch. Ich kapiers nicht.

[ludabruda]

dabb schick doch mal deine fla...

Grüße
Sascha

[TheFreeman]

Na gut. Hier ist es:

[ludabruda]

Hi,

ich habe dir meine Version angehngen, die funktioniert.
Ich habe wiederum direkt das Objekt übergeben.

Das eigentliche Problem ist aber, dass deine Objekte Schaltflächen waren und keine MCs. Die kennen natürlich auch kein onEnterFrame....

Grüße
Sascha

[TheFreeman]

Vielen Dank.

Das wußt ich noch nicht !

Du hast mir sehr geholfen.