[Actionscript] Parent kent Child?

[Explore]

In Actionscript kan je mbv. de super operater een class-hierachy opbouwen, waar de child-classes de parent class kunnen aanspreken. Leuk, maar is omgekeerd ook mogelijk? Hoe?

[Verwijderd]

Volgens mij ben jij leuke dingen aan het leren...
Kan je een stukje pseudo code posten met wat je bedoelt? Ik stel mijzelf de vraag, welke vraag stelt ie nou ?

[Explore]

Dat probeerde ik al, maar liep er vervolgens zelf op vast. Dat gedoe met class-hierachies is behoorlijk complex. Het komt er op neer dat ik een super-class 'gui' wil maken, die een aantal subclasses heeft, waaronder buttons en sliders en dat soort zaken. Die buttons en sliders activeren of veranderen eigenschappen van andere objecten wat ook allemaal subclasses van de gui zijn.

Dus: click op button -> gui -> eigenschap in 'ding' wordt aangepast.

Ik moet van subclass, naar superclass en dan weer naar een andere subclass...

Wellicht kan dit makkelijker op een andere methode. Ik heb inmiddels een dergelijk iets uitgedacht, maar ik sta nog geheel open voor alternatieven.

[mpegernie]

in java is het zo dat je beide objecten declareert en vervolgens kun je het ene object initialiseren waarbij je het ander object meegeeft, en anderson. dacht ik me zo te kunnen herinnneren... Maar dat declareren is in flash al overbodig geloof ik. laat staan dat je objecten mee kunt geven bij het initialiseren?

[Verwijderd]

Ik had het idee dat je doordat je je class een subclass van een superclass laat zijn je fucties in je superclass kunt aan roepen met 'super.functieNaam();'. Ben er ook nog niet zo heel lang mee bezeig, maar het uitelkaar plukken van de componenten helpt en het boek van Branden Hall en Samual Wan ook (te vinden op Wheelmaker.org).

In de componenten is de FUIComponent Class de moederclass aller componenten: is dat ongeveer dat je probeert te bereiken op een GUI niveau?
(extra info over het FUIComponent door Peter Joel - heeft ook een simpel code voorbeeldje staan over superclasses).

[ Voor 0% gewijzigd door Verwijderd op 19-10-2002 10:51 . Reden: oopsie ]

[oh,when?]

ff kijken of ik het nu goed heb begrepen.

Je hebt een parent class, daar maak je een subclass ( child ) aan. Vervolgens maak je nog een andere subclass aan ( nephew ) en nu wil je van newphew een method aanroepen in child? Dus eigenlijk moet nephew zowel van child als parent de methods inhereten. Dus multiple inheritance?

Dat zal een moeilijke job worden, want zoals je wel weet is AS geen class-based language maar meer prototype based, dus zodra je subclassed maak je eigenlijk een branch aan die alleen in die richting kan groeien. Maak je via de parent een subclass aan met andere methods, dan maak je een nieuwe branch aan. Om dan via een child of zelfs grandchild een method te benaderen via een 'nephew' ( child of grandchild in een andere branch ) dan zal je heel die prototype chain moeten doorlopen, om uiteindelijk via die parent de andere branch te benaderen.

Nu heb ik een tijdje geleden wel een idee gehoord, van het misbruiken van __resolve__ om door die chain heen te lopen. Heb het hier nog in een .fla staan ( kwam voorbij op de Flashcoders list )

JavaScript:

Function.prototype.extends = function(class){
    var e = this._extends;
    if(e==undefined){
        this._extends = e = new Array();
        this.prototype.__resolve = function(p){
            var q;
            var i = e.length;
            while(i--){
                q = e[i][p];
                if(q !== undefined){
                    return q;
                }
            }
            return _global[p];
        }
    }else{
        var i = e.length;
        while(i--){
            if(e[i]==class.prototype){
                return this;
            }
        }
    }
    e.push(class.prototype);
    return this;
}

JavaScript:

    X = function(){}
    A = function(){}

    B = function(){}
    B.prototype = new A();

    C = function(){}
    C.extends(B).extends(X);

    D = function(){}
    // D.prototype = new C(): // BAD
    D.extends(C); // GOOD

[Verwijderd]

Als je structureel kijkt wil jij dit

Navigatie component-------->Button
|----->Button
|----->Button

Als je nou component wise gaat kijken, wat is er dan mis mee om dit ongeveer zo te doen (ik pak er de fscrollpane class bij, deze laat handig twee gecombineerde classes zien).

code:

#initclip 2

// ::: FScrollPaneClass

function FScrollPaneClass()
{
    this.init();
    this.width = this._width;
    this.height = this._height;
    this._xscale = this._yscale = 100;
    this.contentWidth = this.contentHeight = 0;

    if (this.hScroll==undefined) {
        this.hScroll=this.vScroll="auto";
        this.dragContent = false;
    }

    this.offset = new Object();
    function boolToString(str)
    {
        if (str=="false") return false;
        if (str=="true") return true;
        else return str;
    }
    this.vScroll = boolToString(this.vScroll);
    this.hScroll = boolToString(this.hScroll);
    
    this.attachMovie("FScrollBarSymbol", "hScrollBar_mc", 100, {hostStyle:this.styleTable});
    this.hScrollBar_mc.setHorizontal(true);
    this.hScrollBar_mc.setSmallScroll(5);
    this.hScrollBar_mc.setChangeHandler("onScroll", this);
    
    this.attachMovie("FScrollBarSymbol", "vScrollBar_mc", 99, {hostStyle:this.styleTable});
    this.vScrollBar_mc.setSmallScroll(5);
    this.vScrollBar_mc.setChangeHandler("onScroll", this);
    
    this.setSize(this.width, this.height);
    if (this.scrollContent!="") {
        this.setScrollContent(this.scrollContent);
    }
    this.setDragContent(this.dragContent);
}

FScrollPaneClass.prototype = new FUIComponentClass();
Object.registerClass("FScrollPaneSymbol", FScrollPaneClass);

Hier worden de subclasses binnen de class geinstantieerd, en daarme child gemaakt. Maar gewoon met attaches.....component/flash wise handiger, ook al breek je misschien gedeeltelijk uit een schone oop omgeving.

Persoonlijk vind ik dit een nette source (van stuart) om wat oop/mx van te leren:
http://www.illogicz.com/flashmx/3dengine/

Enjoy.

[Explore]

oh,when? schreef op 19 oktober 2002 @ 12:00:
ff kijken of ik het nu goed heb begrepen.

Je hebt een parent class, daar maak je een subclass ( child ) aan. Vervolgens maak je nog een andere subclass aan ( nephew ) en nu wil je van newphew een method aanroepen in child? Dus eigenlijk moet nephew zowel van child als parent de methods inhereten. Dus multiple inheritance?

Euh... Nee. Ik heb inderdaad een parent class en in die ene parent class hangen meerdere child classes, die met elkaar moeten kunnen communiceren. Dwz: properties gebruiken en methods aanroepen, etc.

Ik heb inmiddels al iets in elkaar gezet, wat heel erg overeenkomt met de methode die B-top suggereerd, alleen dan niet met attachMovie maar gewoon met iets als:

JavaScript:

function gui() {

    this.foo = new thing();
    this.foo.parent = this;

    this.bar = new plug();
    this.bar.parent = this;
    // ...
}

't Is een beetje maf, maar in 'foo' kan ik dan met 'parent' naar de parent class terugverwijzen. Het breekt wel een beetje je OO af, maar aangezien deze class structuur zo vast gedefinieerd is, wil ik er nog wel mee leven.

Dus als je nu in foo zit en je wilt een property uit bar hebben, dan kan dat:

JavaScript:

    var bla = this.parent.bar.prop;

Ik kon echt niks anders bedenken.

Ik heb wel eens eerder code gevonden voor een 'extends', maar die zat anders in elkaar: maakte gebruik van __proto__, ook al zo'n vage undocumented feature van Flash. __resolve__ ken ik niet.

Is met jouw extends method bovenstaand voorbeeld wat beter te implementeren? Zo ja, geef eens een voorbeeld. Ben wel benieuwd eigenlijk.

Bedankt voor de tips zo ver - de rest ook!