AS3 Delegate

[Tsuken]

Wat ik in AS3 mis is de mogelijkheid om arguments met een eventlistener mee te sturen.

Na op internet te kijken had ik wel wat mogelijke manieren gevonden maar niets waar ook removeEventListener op werkt.

Dus bij deze een Delegate class die dat wel kan:
package nl.tsuken{
import flash.events.Event;

public class Delegate{

private static var storedObjects:Array = new Array();

public static function add(mc:*, clickType:String, method:Function, ... args:Array):void{
var length = storedObjects.push(new Object());
var obj = storedObjects[length-1];
obj.mc = mc;
obj.clickType = clickType;
obj.method = method;
obj.newMethod = create(method, args);
obj.mc.addEventListener(obj.clickType, obj.newMethod);
}

public static function remove(mc:*, clickType:String, method:Function):Boolean{
for (var i in storedObjects){
var obj = storedObjects[i];
if(obj.mc == mc && obj.clickType == clickType && obj.method == method){
obj.mc.removeEventListener(obj.clickType, obj.newMethod);
delete storedObjects[i];
storedObjects.splice(i, 1);
return true;
}
}
return false;
}

public static function create(method:Function, args:Array){
return function(event:Event):void{
method.apply(null, [event].concat(args));
}
}
}
}

gebruik als volgt:

import nl.tsuken.Delegate;

Delegate.add(mc, MouseEvent.CLICK, McClicked, "Een argument");
Delegate.remove(mc, MouseEvent.CLICK,McClicked);

[TheDutch]

Tsuken, ik ben erg benieuwd in wat voor een situatie jij deze functionaliteit mist. Het zit niet in ActionScript 3 en het zit óók niet in ActionScript 2. Daar is een reden voor die ik later zal toelichten :).

[Tsuken]

ik gebruikte het vrijwel altijd in AS2 omdat anders de scope mis gaat.

bijvoorbeeld AS2:

for (var i=0; i<222; i++){
var myButton = this.attachMovie("myButton", "myButton"+i, i);
myButton.onRelease = Delegate.create(this, buttonRelease, myButton, i);
}

function buttonRelease(myButton, i){
trace("button: "+myButton+" i:"+i);
}


bijvoorbeeld AS3:

for (var i=0; i<222; i++){
var myButton = new MyButton();
myButton.buttonMode = true;
Delegate.add(myButton, MouseEvent.CLICK, buttonClick, myButton, i);
this.addChild(myButton);
}

function buttonClick(e:Event, myButton, i){
trace("button: "+myButton+" i:"+i);
}

[TheDutch]

Apart, het meegeven van argumenten aan Delegate.create() (http://livedocs.adobe.com/flash/8/main/00003431.html) moet dan een undocumented feature zijn geweest want in de documentie van ActionScript 2 bestaat die functionaliteit namelijk niet :).

Het mag duidelijk zijn dat we de Delegate class toen gebruikte om de scoping goed te houden, dat was juist het doel van de class. Het meegeven van het betreffende object als argument is niet nodig in ActionScript 3 en was ook niet nodig in ActionScript 2 wanneer het goed gebruikt werd ;).

In ActionScript 2 kon je het betreffende object met event.target benaderen wanneer je gebruik maakte van addEventListener(). Echter wanneer je daar geen gebruik van maakte, maar in plaats daarvan gebruik maakte van inline functies, dan had je inderdaad een probleem omdat je dan geen referentie meer had naar het betreffende object.

addEventListener() - ActionScript 2

button_mc.addEventListener("click", Delegate.create(this, onButtonClick));

function onButtonClick(event:Object):Void
{
trace(event.target) // Referentie naar het betreffende object.
}


Inline - ActionScript 2

button_mc.click = Delegate.create(this, onButtonClick);

function onButtonClick():Void
{
// Geen referentie meer naar het betreffende object.
}

Binnen ActionScript 3 gebruik je event.currentTarget om het betreffende object te benaderen. Je hoeft dus helemaal geen argument mee te geven om het betreffende object in de handler functie te kunnen benaderen, die heb je namelijk altijd via het event object.

addEventListener - ActionScript 3

button_mc.addEventListener("click", onButtonClick);

function onButtonClick(event:Event):void
{
trace(event.currentTarget) // Referentie naar het betreffende object.
}

Zijn er nog meer redenen voor jou om argumenten te gaan meegeven aan de listener? Want in mijn ogen is dat namelijk vrij ongebruikelijk en zeker niet nodig. Kijk uit dat je niet allemaal classes gaat verzinnen en hacks gaat maken voor scenarios die helemaal niet meer van toepassing zijn :).

[Tsuken]

Tja eigenlijk gebruik ik in AS2 voornamelijk Delegate voor de scope en om argumenten mee te sturen. Ik gebruikte wel een custom Delegate (com.bigspaceship.utils.Delegate), dus niet die van flash.

In AS3 wil ik dus alleen Delegate zodat ik argumenten mee kan sturen :) Ik ben zelf heel blij met mijn nieuwe Delegate class voor as3 zodat ik argumenten mee kan sturen. Ik gebruik het de hele tijd. Wat voorbeelden:

SwfAddress veranderen:
Delegate.add(choiceMc.architectureMc, MouseEvent.CLICK,setAddress, "Architecture");

Xml onComplete:
Delegate.add(navLoader, Event.COMPLETE, pageXmlLoaded, name, choice);

Image url meesturen:
Delegate.add(projectDetailsMc.magnifyMc, MouseEvent.CLICK, magnify, projectObj.Image);

[TheDutch]

Je moet uiteraard helemaal zelf weten of je het gebruikt, maar ik zou het je erg willen afraden. Jouw methode is zeer bad-practice en buiten dat ook onnodig. Dit komt waarschijnlijk omdat het niet altijd even eenvoudig is het hele OO principe en Event Architectuur goed te begrijpen en toe te passen. Hier zou je aan kunnen werken wanneer je jezelf steeds beter wilt laten worden. Geen enkel professioneel bedrijf wat gebruik maakt van Flash zal dit soort vormen van code namelijk toestaan, dus het is ook goed voor je carrière om zo snel als mogelijk dit soort dingen goed aan te leren.

Aan jou de keuze natuurlijk :).

[Tsuken]

Ik werk al een tijd full-time in een professioneel 100% Flash bedrijf :P

[TheDutch]

Dan hoop ik voor je dat ze je code nooit te zien krijgen of dat jullie er allemaal geen kaas van gegeten hebben :P.
Met een professioneel bedrijf bedoel ik een bedrijf dat kwaliteit software maakt met code die goed in elkaar steekt.

[Flashkiddy]

Delegates met argumenten zijn geen bad practice (vind ik dus helemaal niet). "event.target" en "event.currentTarget" geven de instance terug, maar niet de argumenten die tsuken mee wil geven. En deze bad practice zit ook gewoon in het asapframework van Lost Boys onder de Event package (en die boys daar verstaan hun vak echt wel). Ik gebruik t ook soms.

[theFlashWizard]

Laten we de discussies over elkanders bedrijf eens ergens anders gaan voeren.
Ik sta achter theDutch. Als het een goede feature zou zijn geweest had het in as3.0 gezeten.
2 mogelijke oplossingen voor jou probleem:

Haal de informatie uit de event target (ik heb bijv. vaak een soort button class met een id property.)
Haal informatie op uit een algemeen gebruikte databron. Mogelijk weer met data uit je event target.

[Tsuken]

Als het een goede feature zou zijn geweest had het in as3.0 gezeten.
Er zijn zat custom classes / frameworks te vinden hoor, zoals Tweener en SWFAddress, of gebruiken jullie die ook niet?

Maar dit topic is niet om te discussiëren of het good practice is in jullie ogen, dit topic is voor de mensen die een Delegate class willen in AS3, zoals ze die in AS2 hadden.

[TheDutch]

Delegates met argumenten zijn geen bad practice (vind ik dus helemaal niet). "event.target" en "event.currentTarget" geven de instance terug, maar niet de argumenten die tsuken mee wil geven. En deze bad practice zit ook gewoon in het asapframework van Lost Boys onder de Event package (en die boys daar verstaan hun vak echt wel). Ik gebruik t ook soms.
Zoals reeds gezegd is het meegeven van argumenten aan de listener inderdaad soms nodig bij inline(!) gebruik met ActionScript 2. Veel mensen gebruikte die methode, i.p.v. de veel betere addEventListener(), gewoon om eigenlijk dezelfde reden dat mensen nu moeite hebben met het overstappen naar ActionScript 3. De OO principes en Event Architectuur is voor velen gewoon een grens waar ze moeilijk overheen kunnen stappen.

Binnen het ASAPFramework bestaat er inderdaad een class genaamd EventDelegate, dat is ook niet meer dan logisch. Het ASAPFramework is namelijk gemaakt voor ActionScript 2 en niet(!) voor ActionScript 3. Sterker nog je kunt hem niet eens gebruiken met ActionScript 3 omdat er tot op heden geen versie gelanceerd is voor ActionScript 3. Eigenlijk ligt de ontwikkeling van het ASAPFramework volledig stil, al sinds eind vorig jaar. Mocht je ASAPFramework gebruiken en over willen op ActionScript 3 ontwikkeling, dan is het denk ik verstandig je alvast te gaan verdiepen in PureMVC (http://puremvc.org). Dit PureMVC Framework is op het moment het meest gerespecteerde ActionScript Framework wat er bestaat en waar volop aan ontwikkelt wordt (open-source) :).


Er zijn zat custom classes / frameworks te vinden hoor, zoals Tweener en SWFAddress, of gebruiken jullie die ook niet?

Maar dit topic is niet om te discussiëren of het good practice is in jullie ogen, dit topic is voor de mensen die een Delegate class willen in AS3, zoals ze die in AS2 hadden.

Het gaat er niet om of iets zelf gemaakt is. Het gaat erom of iets onnodig is neergezet en waarbij gebruik bad-practice in de hand wordt gewerkt.

Het doel van de meer ervaren mensen zoals theFlashWizard en ikzelf is het helpen van andere mensen op dit forum. Zie het als educatie zodat je later tegen minder problemen aan zult lopen. Mocht jij je niet zoveel bekommeren om later en je huidige niveau prima vinden voor de rest van je carrière dan moet je vooral niets van ons aantrekken of van andere mensen die je behulpzaam ergens op willen wijzen. Wil je jezelf wel graag verder ontwikkelen op ActionScript gebied dan is het leerzaam om wat meer open te staan voor (opbouwende) kritiek :).

ps. Dit forum is openbaar wat betekent dat iedereen hier zijn of haar mening mag geven over een onderwerp zoals deze. Wil jij eigen gemaakt werk online plaatsen zonder dat mensen daar hun mening over mogen geven, dan raad ik je graag aan om een blog te openen en voortaan daar het spul te plaatsen. Cheerio!

[Flashkiddy]

Eigenlijk ligt de ontwikkeling van het ASAPFramework volledig stil, al sinds eind vorig jaar.
Dat is helemaal niet waar :)
Check : http://asaplibrary.org
Dat is gewoon asasframework maar dan voor as3. Alleen met een naamswijziging. Hij wordt nog steeds geupdate wat ik onlangs hoorde ....

Waarom zouden argumenten bij as2 wel nuttig zijn en bij AS3 niet? Qua OO design is er op dat vlak niets veranderd. Alla, je kunt een instance maken van een class, daar een id op zetten en die dan weer benaderen via event.target. Maar dat is ronduit omslachtig, vooral met simpele buttons, dan moet je nml gaan subclassen op een Button class, terwijl je die class eigenlijk niet nodig hebt. Je kunt ook direct gewoon die Proxy/EventDelegate gebruiken en bovendien kun je dan direct reeds bestaande methods aanroepen INCLUSIEF de strictly-typed parameters van die method.

PureMVC rockt hard trouwens. Ik bouw altijd met MVC pattern, wil niet zonder :)

[TheDutch]

Dat is helemaal niet waar :)
Check : http://asaplibrary.org
Dat is gewoon asasframework maar dan voor as3. Alleen met een naamswijziging. Hij wordt nog steeds geupdate wat ik onlangs hoorde ....

Noem het beestje dan bij zijn naam ;).

Binnen de ASAPLibrary bestaat er ook niet zoiets als een EventDelegate class. Er wordt daar gewoon gewerkt met FlowManager.addEventListener() wat een inherited functie is van de ActionScript 3 class EventDispatcher. Dus geen mogelijkheid tot het meegeven van extra argumenten aan een event listener.


Waarom zouden argumenten bij as2 wel nuttig zijn en bij AS3 niet? Qua OO design is er op dat vlak niets veranderd. Alla, je kunt een instance maken van een class, daar een id op zetten en die dan weer benaderen via event.target. Maar dat is ronduit omslachtig, vooral met simpele buttons, dan moet je nml gaan subclassen op een Button class, terwijl je die class eigenlijk niet nodig hebt.
Argumenten meegeven aan een event listener was alleen in ActionScript 2 nodig wanneer je inline event listeners toewees. In ActionScript 3 is er geen enkele reden om argumenten mee te geven aan event listeners. Zelfs niet voor een loop die buttons neerzet waarbij mensen regelmatig een property 'id' aanmaken om daar een waarde aan mee te geven, wat overigens helemaal overbodig is. Elke class die extend van DisplayObject heeft namelijk een property 'name (http://livedocs.adobe.com/flex/2/langref/flash/display/DisplayObject.html#name)', die gebruikt kan worden om een naam mee te geven aan de instantie. Op die manier kan je via event.currentTarget.name altijd achterhalen om welke knop het precies gaat en met DisplayObjectContainer.getChildByName() (http://livedocs.adobe.com/flex/2/langref/flash/display/DisplayObjectContainer.html#getChildByName()) de knop ook zelf ophalen met de naam mocht je de instantie niet reeds tot je beschikking hebben. Persoonlijk zou ik dit ook nog niet eens gebruiken omdat dit ook niet nodig is en vrij beperkt. Ik zou een instantie gebruiken van de Dictionary class (http://livedocs.adobe.com/flex/2/langref/flash/utils/Dictionary.html) als property waarin ik als key de button instantie gebruik en als waarde hetgeen ik wil opslaan, dat kan een string zijn maar ook een object met meerdere waarden. Je hebt dus nooit(!) extra argumenten nodig bij een event listener.

Om eerlijk te zijn heb ik verder helemaal geen zin in welles nietes. Ik heb alles reeds toegelicht in deze en mijn vorige reacties. Wat je er verder mee doet moet je zelf weten :).

[Tsuken]

stuur je nooit argumenten naar een functie?

[Flashkiddy]

@Tsuken : bij welk bedrijf werk jij dan eigenlijk?
@TheDutch: und du?

Ik ben zelf freelancer en dat bevalt me erg goed.

[meester]

Hallo daar,

Delegate gebeuren sla ik altijd over door een simpel trucje uit te voeren in AS2 bijv.
Scope gaat goed als je het volgende doet. Voorbeeld.



mc["callBack"] = this; //this verwijst gewoon naar de class en dan kan je gewoon het volgende doen.

mc.onRelease = function(){
this.callBack.testFunc();
}


function testFunc(){
trace("doet het");
}


groet Carli

[mknol]

@FlashKiddy: Let even op, we gaan elkaars bedrijven niet in een negatief daglicht stellen, anders wordt het topic onmiddelijk gesloten. Dan ben je bij FlashFocus aan het verkeerde adres. Gaarne hier niet meer over te beginnen aub.Laten we de discussies over elkanders bedrijf eens ergens anders gaan voeren.

@Tsuken: Aangezien je zelf een classe MyButton hebt gemaakt, kun je daar ook zelf een publieke var aan toevoegen, zoals bijvoorbeeld index.

public var index:int = 0;
Dit kun je dan zo gebruiken, en zo heb je geen extra parameters meer nodig in je listener, aangezien de waarde op deze manier bewaard blijft.
for ( var i:int = 0; i < 222; i ++ )
{
var myButton:MyButton = new MyButton();
myButton.index = i;
myButton.buttonMode = true;
myButton.addEventListener ( MouseEvent.CLICK , onButtonClick );
this.addChild ( myButton );
}

function onButtonClick ( e:Event )
{
var button:MyButton = e.currentTarget;
trace( "Button: " + button, "i:" + button.index );
}
Zelf ben ik blij dat ik geen delegates meer hoef toe te passen sinds AS3. Ik gebruikte delegates alleen voor scoping problemen, maar heb wel eens zelfde soort delegate-class ook gebruikt. Als je er eigenlijk even over nadenkt, dan merk je wel dat het niet heel verstandig is en dat het makkelijker kan. Vooral als je je eigen classes hebt, dan kun je daar waardes aan toewijzen, wat veel overzichtelijker en beter programmeren is.

Misschien kun je er wat mee.

[Tsuken]

Ik werk in Nieuw-Zeeland bij een redelijk klein bedrijf, maar die wel vrijwel geheel op flash websites gericht is. Maar NZ is een klein land (4 miljoen mensen) en het is niet enorm groot op flash gebied, niet zoals Nederland. Het gaat heel goed overigens met het bedrijf, maar ik noem geen namen.

mknol, je kunt niet altijd een nieuwe variabel toevoegen aan het object waar je een eventlistener aan toevoegt. Dit werkt wel voor Movieclips en Sprites, maar niet voor bijvoorbeeld de Loader class of een flvplayback component om maar iets te noemen. Ik vind het wel handig om met Event.COMPLETE argumenten mee te kunnen sturen.

Toen ik dit topic maakte was ik nog niet zo lang met AS3 bezig en gebruikte zelf in AS2 constant Delegate voor het meesturen van argumenten, dus dit miste ik meteen in AS3.

Ik was al wel op de hoogte van Dictionaries en gebruik die ook, maar Delegate is soms gewoon zoveel makkelijker en sneller. Het ligt een beetje aan de situatie en op welk niveau van de applicatie je bent.

Een eventlistener roept een functie aan, dus dan is het toch niet zo raar dat je argumenten naar die functie wil meesturen?

[mknol]

Ik snap je punt wel eigenlijk, maar sneller is niet altijd beter.

Je kunt toch objecten extenden? Stel je moet iets toevoegen aan een loader, dan maak je toch je eigen MyLoader class, waar je wel variables aan kunt toewijzen. Dat is de normale manier van werken, dacht ik zo.

[CremFresh]

Hallo,

Je zou ook je eigen event Class kunnen schrijven op basis van een extension van de Event class in AS3. Daar een payload als extra property (argument) toevoegen. Payload kan zijn wat je ervan wilt maken een type "Object", "Array", "String". Persoonlijk kies ik voor een "Object".

Eerlijk gezegt als je scoping problemen hebt dan klopt er iets niet in architectuur van je applicatie.

[Flashkiddy]

@FlashKiddy: Let even op, we gaan elkaars bedrijven niet in een negatief daglicht stellen, anders wordt het topic onmiddelijk gesloten. Dan ben je bij FlashFocus aan het verkeerde adres. Gaarne hier niet meer over te beginnen aub.

Lol, dude, chill out. Ik ben gewoon benieuwd waar iedereen werkt. 't Kan mij geen **** schelen hoe iemand programmeert. We hebben het hier over puristische programmeer-ideeen, niet over de expertise. Iedereen die hier meediscusseert programmeert op een niveau wat ver boven gemiddeld ligt. Zwartmakerij, hoe kom je erbij? Gaarne wat meer vertrouwen in de mens ajb.

[Flashkiddy]

Hallo daar,

Delegate gebeuren sla ik altijd over door een simpel trucje uit te voeren in AS2 bijv.
Scope gaat goed als je het volgende doet. Voorbeeld.



mc["callBack"] = this; //this verwijst gewoon naar de class en dan kan je gewoon het volgende doen.

mc.onRelease = function(){
this.callBack.testFunc();
}


function testFunc(){
trace("doet het");
}


groet Carli

Dit is een AS2 issue. Je kunt beter dit doen (dan hoef je geen dynamic vars te gebruiken, want dat is vragen om problemen als je iets verandert):



var papa = this; //this verwijst gewoon naar de class en dan kan je gewoon het volgende doen.

mc.onRelease = function(){
papa.testFunc();
}


function testFunc(){
trace("doet het");
}

[mknol]

@Flashkiddy: Excuses, ik heb je reactie inderdaad verkeerd geïnterpreteerd. Ik moet zo af en toe optreden zodat het hier niet verkeerd loopt. Sommige dingen kunnen ook anders opgevat worden, en ik had het dus blijkbaar anders opgevat. Nu weer ontopic :)

[meester]

Hallo daar,

klopt niet wat je zegt flashkiddy.
Op het moment dat je binnen de mc zit en papa aanroept. Is de variabele papa undefined!!! papa is op jouw manier namelijk buiten het object aangemaakt en is binnen het object "mc" niet bekend!

gr Carli

[Flashkiddy]

@knol: jolly good mate. Op ieder forum zijn eikels aanwezig. Maar no hard feelings huh :)

@meester: heb je't al geprobeerd dan? ;t Zit 'm niet zozeer in de scope van die variable , maar 'this' heeft binnen de inline function van de button een andere scope dan dat je 'this' daarbuiten gebruikt (welk genie dat nou ooit heeft verzonnen....). Je kunt 'this' dus niet gebruiken binnen de button-function, maar 'papa' daarentegen wel. 'papa' verwijst naar de scope van de class, niet naar de scope van de button. De variable is namelijk gedefinieerd in de class.

[meester]

als ik jou was, zou ik het even proberen. this > verwijst inderdaad naar de mc zelf.
Daarom is var['callBack'] = this; -> class object.

en kan ik met this.callBack -> class object weer aanspreken en op zijn beurt weer gewoon weer een functie aanroepen, zonder DELEGATE.
Maar we dwalen af... ik weet namelijk dat ik gelijk heb! :)

gr Carli

[Dauntless]

@Meester: Toch niet hoor ...

Oplossing 2:http://www.flashfocus.nl/forum/showpost.php?p=201685&postcount=3

Het is ook onlogisch dat het zou werken... but it does! :p

[Flashkiddy]

als ik jou was, zou ik het even proberen. this > verwijst inderdaad naar de mc zelf.
Daarom is var['callBack'] = this; -> class object.

en kan ik met this.callBack -> class object weer aanspreken en op zijn beurt weer gewoon weer een functie aanroepen, zonder DELEGATE.
Maar we dwalen af... ik weet namelijk dat ik gelijk heb! :)

gr Carli

Wat jij doet, werkt ook jah, maar je gaat dan dus dynamic variables gebruiken, wat alleen maar tot ontraceerbare problemen kan leiden. Kun je dus beter niet doen. Maar doe je ding. Probeer alleen het 'papa' trickje maar ff.

[meester]

haha is goed maat!

ps mijn voorbeeld was bestemd alleen voor AS2.
En toch blijf ik er in geloven dat jou shizzle in as2 niet werkt! sorry...Zal hem morgen eens proberen. Gr

[meester]

haha, is goed maat!

[domin8r]

Sorry dat ik ouwe koeien/threads uit de sloot haal.. Maar ik ben ook gewend om via de EventDelegate van asap argumenten door te geven aan de functie die aan de event listener hangt. Is mij zelfs zo geleerd in masterclass.

Stel ik luister naar een Event.COMPLETE event van een URLLoader en wil ook een parameter meegeven. Wat is dan de beste constructie hiervoor?

[Flashkiddy]

Sorry dat ik ouwe koeien/threads uit de sloot haal.. Maar ik ben ook gewend om via de EventDelegate van asap argumenten door te geven aan de functie die aan de event listener hangt. Is mij zelfs zo geleerd in masterclass.

Stel ik luister naar een Event.COMPLETE event van een URLLoader en wil ook een parameter meegeven. Wat is dan de beste constructie hiervoor?

class CustomURLLoader extends URLLoader
{
public var myParameter : String;
}

Geef in de constructor een extra parameter mee, sla die op in de member genaamd myParameter en je hebt een URLLoader instance , maar dan MET een extra waarde die je altijd weer kunt raadplegen op een later tijdstip (zoals op Event.COMPLETE).

[TheDutch]

Is mij zelfs zo geleerd in masterclass.
Een masterclass van een aantal jaren geleden hoeft niet meer te gelden voor hedendaags ;).

De oplossing die Flashkiddy aandraagt is een zeer nette en goede oplossing, maar ik kan me voorstellen dat overerven niet altijd wenselijk is voor een situatie zoals deze. Zelf kan ik me moeilijk een situatie voorstellen waarin je argumenten wilt meesturen met de event listener, omdat ik zowel de huidige scope als het gerelateerd object tot mijn beschikking heb. Daarnaast kunnen deze argumenten verouderen tijdens het uitvoeren van het event mocht je ze toch op een bepaalde manier mee sturen.

Mijn vraag is daarom; wat wil je meesturen en waarom? Kan je een scenario schetsen waarin jij denkt dat dit nodig is? :)

[lordbeezdje]

package {

import flash.display.Sprite;
import flash.events.MouseEvent;
import flash.utils.Dictionary;

public class mySprite extends Sprite {

private var _variables:Dictionary;

public function mySprite():void {
_variables = new Dictionary();
createButtons();
}

private function createButtons():void {
for(var i:uint=0; i<10; i++) {
var btn:Sprite = new Sprite();
btn.name = "button_"+i;
btn.x = (i*100);
btn.graphics.beginFill(0);
btn.graphics.drawRect(0, 0, 80, 20);
btn.graphics.endFill();
btn.addEventListener(MouseEvent.CLICK, buttonClick);
_variables[btn] = {buttonIndex:i, nogIets:"bla"};
addChild(btn);
}
}

private function buttonClick(e:MouseEvent):void {
var btn:Sprite = e.currentTarget as Sprite;
var vars:Object = _variables[btn];
trace(vars);
}
}
}

[domin8r]

Een masterclass van een aantal jaren geleden hoeft niet meer te gelden voor hedendaags ;).

De oplossing die Flashkiddy aandraagt is een zeer nette en goede oplossing, maar ik kan me voorstellen dat overerven niet altijd wenselijk is voor een situatie zoals deze. Zelf kan ik me moeilijk een situatie voorstellen waarin je argumenten wilt meesturen met de event listener, omdat ik zowel de huidige scope als het gerelateerd object tot mijn beschikking heb. Daarnaast kunnen deze argumenten verouderen tijdens het uitvoeren van het event mocht je ze toch op een bepaalde manier mee sturen.

Mijn vraag is daarom; wat wil je meesturen en waarom? Kan je een scenario schetsen waarin jij denkt dat dit nodig is? :)

Een situatie die zich wel geregeld voordoet is bijvoorbeeld dat je een Class hebt die XMLs laadt en parsed. Aangezien die met verschillende XMLs moet kunnen werken stuur ik normaal gesproken een identifier mee met request. Zo weet ik bij Event.COMPLETE nog die identifier en kan ik die mee terugsturen naar whatever de geparsde data weer ontvangt.

[TheDutch]

Aangezien je met een loader slechts een enkel request tegelijk kunt uitvoeren zou je dit prima binnen een variable kunnen opslaan. Die kan je dan weer vanuit de event handler uitlezen.

Echter is dit geen mooie manier van programmeren, iets waar je zeker geen punten mee zult scoren. Beter zou het zijn om in zo'n situatie een LoaderManager class te maken welke weer instanties aanmaakt van verschillende typen loaders aan de hand van meegegeven argumenten aan de LoaderManager.getLoader(type), zoals bijvoorbeeld een XMLLoader class voor het laden van XML. Die XMLLoader class is dan een subclass van de URLLoader class en heeft en bezit in jouw geval bijvoorbeeld een identifier property (de methode zoals Flashkiddy dat hierboven uitlegt).

Op die manier bouw je iets goed op en hoef je helemaal geen extra argumenten mee te gaan aan een event handler :).