« Archives in July, 2009

Add methods to native Classes in ActionScript 3.0 – Prototype functions

9. July 2009 / posted in ActionScript / 3 Comments

Hi again!
Yesterday I’ve found out a cool new feature of ActionScript 3.0. You will sometimes have to use associative Arrays. The problem with these is that you can’t easily loop through them with a for-loop like

ActionScript
var  myAssocArray:Array = [],
    i      :int,
    intLength  :int;
 
myAssocArray['foo'] = 'one';
myAssocArray[1] = 'two';
myAssocArray['bar'] = 'three';
myAssocArray[0] = 'four';
intLength = myAssocArray.length;
 
for(; i< intLength; ++i)
{
  trace(myAssocArray[i]);
}

The trace will probably print out “four, two, undefined, undefined”. The fact is that you can get the elements 0 & 1 via the variable i, but the the other keys can’t be accessed with this method.
As I also like PHP very much, I also know the function array_keys(array) of PHP, which returns the key-values of the array given in the parameters. I thought that I really need this functionality within AS3, so I tried a lot, searched the internet and finally got it! It’s pretty simple for those knowing AS2 – prototype functions.
What do we need to do? Place the following code in your main, unnamed package below or above the class-definition and you can use it everywhere else in the code:

ActionScript
package
{
  public class foo
  {
    public function foo():void
    {
      trace('bar');
    }
  }
 
  Array.prototype.arrayKeys = function():Array
  {
    var  arrReturn  :Array = [],
      strKey    :String;
 
    for(strKey in this)
    {
      if(typeof this[strKey] == 'function') continue;
      trace('in Array:: value->'+ strKey +' typeOf:'+ typeof strKey +' proto:'+ ((this[strKey] !== false) ? typeof this[strKey] : 'NULL'));
      arrReturn[arrReturn.length] = strKey;
    }
 
    return arrReturn;
  }
 
  Number.prototype.give = function():String
  {
    return 'Number::giveItToMeBaby';
  }
}

You can now use this method to get the keys of the variable:

ActionScript
var arrKeys    :Array = myAssocArray.arrayKeys(),
  i      :int,
  intLength  :int = arrKeys.length;
 
for(; i < intLength; ++i)
{
  trace(myAssocArray[arrKeys[i]]);
}

Pretty easy, isn't it? Well, it is easy because the native Array-Class is dynamic, but what do we do with Number (final class)? Let's see...

ActionScript
var num:Number = 4;
num.give(); //doesn't work! final class, can't add methods to it?
 
num['give'](); //does work :) you can dynamically add methods to a class even if it's final; problem is that this code is hard to read, but it actually works

So far...
Daniel

ActionScript 3.0 ListenerProxy goes public

6. July 2009 / posted in ActionScript / No Comments

Hello everybody!
Since February I wanted to put my great ListenerProxy-class onto the page, but I forgot it every day… So now I’m here and remembered that there was a Class to publish!

Hey Daniel, tell me what the heck is a ListenerProxy and why did ya write that piece of code man? Let’s go on…
Since ActionScript is enourmously memory-consuming, I often tried to get rid of this. Once I found out that you can’t remove any objects that are still having a Listener registered on them. So what do you have to do, to get an object out of the memory? Setting the value to null or probably 0 (ints and so on), doesn’t seem to do the trick. You also have to remove the EventListeners – and of course – ALL of them!
Some time ago in an old Flash CS3-Version, you could find a listeners-Array of every object when you debugged the movie, but you can’t access this array – no way!
Well that was really annoising me, so I decided to write a class that keeps track of all the listeners registered on an object.

So what else can we do with your ListenerProxy, Daniel?
You probably already had some code where you needed to add multiple Listeners with the same callback-function. You then had to write code like this:

ActionScript
var myLoader:Loader = new Loader();
  myLoader.addEventListener(Event.COMPLETE,        this.loadHandler);
  myLoader.addEventListener(IOErrorEvent.IO_ERROR,    this.loadHandler);
  myLoader.addEventListener(HTTPStatusEvent.HTTP_STATUS,  this.loadHandler);
  myLoader.addEventListener(ProgressEvent.PROGRESS,    this.loadHandler);

This are four lines of code for the listeners…. Wanna do it within a single line? Watch this:

ActionScript
ListenerProxy.getInstance().addListener(myLoader, [Event.COMPLETE, IOErrorEvent.IO_ERROR, HTTPStatusEvent.HTTP_STATUS, ProgressEvent.PROGRESS], this.loadHandler);

You can of course add a single Listener for a object, just pass the type as second parameter without the brackets:

ActionScript
ListenerProxy.getInstance().addListener(myLoader, Event.COMPLETE, this.loadHandler);

Ok that’s nice, isn’t it? So you have multiple objects to listen for the same Event calling the same callback-function? Hmmm….

ActionScript
var myLoader_1:Loader = new Loader();
var myLoader_2:Loader = new Loader();
var myLoader_3:Loader = new Loader();
var myLoader_4:Loader = new Loader();
  myLoader_1.addEventListener(Event.COMPLETE,  this.loadHandler);
  myLoader_2.addEventListener(Event.COMPLETE,  this.loadHandler);
  myLoader_3.addEventListener(Event.COMPLETE,  this.loadHandler);
  myLoader_4.addEventListener(Event.COMPLETE,  this.loadHandler);

Argh*!$# I hate such crappy code :)

ActionScript
ListenerProxy.getInstance().addListener([myLoader_1, myLoader_2, myLoader_3, myLoader_4], Event.COMPLETE, this.loadHandler);

Yeeehaa! It makes the whole thing a bit easier, don’t you think so?

And that’s not all. If you have multiple objects with multiple listeners and the same callback-function, you can simply pass the elements as arrays as shown above.

So what are the key-functions to use?

ActionScript
1. ListenerProxy.getInstance():ListenerProxy //Singleton-Pattern is used
2. addListener(objToAddTo:*, strListenerType:*, funcCallback:Function):void //to add Listeners
3. removeListener(objToRemoveFrom:*, strListenerType:*, funcCallback:Function):void //to remove Listeners
4. hasListener(objToAsk:*, strListenerType:String, funcCallback:Function = null):Boolean //check whether the specified object has that listener or not
5. pop(objToPop:*, blnRemoveAllListeners:Boolean = false):* //remove the object from ListenerProxy's Dictionary (the 2nd param is VERY USEFUL!)

Get the Code here!

[UPDATE]

::06th August 2009 { fixed bug with adding/removing multiple listeners to multiple objects; also remove duplicate entries of “if(objToAdd.hasOwnProperty(‘addEventListener’))” }

[/UPDATE]