Function Overloading & MovieClip Dimensions

Today at work I wrote a nifty little piece of code that I couldn’t believe we hadn’t written before… To center a MovieClip on a point regardless of its registration point. Until now we had never really needed a MovieClip to center like this, and always justified things to 0,0. I’m creating an application that creates a group of movieclips in a spiral formation from the center of 0,0. This meant that I would have to figure out a way to center it to its absolute center, not just to 0,0. I added the following function to my AdvancedMovieClip class (which I’ll upload eventually).

public function absoluteCenterTo(p1:Object, p2:Object):Object{
var xCenter:Number;
var yCenter:Number;
if(p1 instanceof MovieClip){
xCenter = p1._x;
yCenter = p1._y
} else {
xCenter = Number(p1);
yCenter = Number(p2);
}

var bounds:Object = getBounds(this);

var newXPosition:Number = xCenter - (((bounds.xMin + bounds.xMax)/2)*this._xscale)/100;
var newYPosition:Number = yCenter - (((bounds.yMin + bounds.yMax)/2)*this._yscale)/100;
if(isNaN(newXPosition) or isNaN(newYPosition)){
throw new Error("ERROR: Parameter does not result in a valid number");
} else {
var returnObj:Object = {x:newXPosition, y:newYPosition};
}
return returnObj;
}

If the function looks weird to you, its becuase I’ve used (a somewhat hack version of) function overloading. What this means, is you can pass different types of parameters into the same function (although in other languages like Java you actually have multiple functions with the same name) and the program will treat the function differently based on those parameters. I’ll admit, I only did this to see if I could, and it will be a lot better with AS3 because of the is keyword which works simlar to instanceof but can detect primatives such as String, Number and Boolean.

As it is though, its kind of handy because you tell the function to center the clip over a specific location via centerTo(100,100) or tell it to center to the desired MovieClip’s registration, centerTo(myMovieClip_mc). It doesn’t center the MovieClip automatically, but instead returns an object that has the new coordinates to center it. You can then pass these into your tweening function, or directly. I of course recommend my EasyTween class!   **Update 102/24/2010:  EasyTween no longer available for download. **

The function uses getBounds() to calculate what the actual center of the MovieClip, not just where the registration point is. One of the most frustrating things I find when resizing MovieClips is the at _width, _height are based on the MovieClips fullsize dimensions – not what it is actually scaled to when called. So when trying to figure out the actual width and height of a MovieClip you must first multiply it by its respective scale value and divide that by 100 to get a useable value.

DelegatePlus: Delegate Plus Parameters!

DelegatePlus is a class which is almost exactly like the Delegate class except you can pass parameters with the function.

The Delegate class helps you manage scope when calling functions from with other functions, classes or events. Take the example code below:

import mx.utils.Delegate;

function traceThis(){
trace("Tracing!");
}
var myInt = setInterval(Delegate.create(this, traceThis), 1000);

A very simple class that just outputs “Tracing!” over and over again. But what if you wanted to pass it a string for the function to trace out? You can’t do it with the original delegate class! Now lets use DelegatePlus to pass parameters to the function.

import com.dcholth.utils.DelegatePlus;

function traceThis(aString:String){
trace("Tracing: " + aString);
}
var myInt = setInterval(DelegatePlus.create(this, traceThis, "http://blog.dcholth.com"), 1000);

The code will now trace “Tracing: http://blog.dcholth.com” indefinetly! No scope errors, no limit to the amount of parameters you want to specify. It runs the function exactly as if it were called within the original class.

This works by using the ‘arguments’ array which is passed with every function call regardless of the parameters used. The first two parameters in the ‘argument’ array are the scope object, and the second is the function being called. The rest of the array are the parameters passed, in order. The full delegate class can be seen below with commenting. You may notice it is very similar to the orginal Delegate class written by Mike Chambers.

/**

*/
//	****************************************************
//	DelegatePlus
//	****************************************************
//	By: Daniel Holth
//	eMail: dan [at] dcholth.com
//	web: http://blog.dcholth.com
//
//	The DelegatePlus class creates a function wrapper to let you
//	run a function in the context of the original object,
//	rather than in the context of the second object, when
//	you pass a function from one object to another.
//	The DelegatePlus class works exactly like Delegate but allows you
//	to pass parameters. (Its basically the same code!)
//
//	****************************************************
//	Last Modified 3/06/2007
//	****************************************************
//
/////////////////////////////////////////////
class com.dcholth.utils.DelegatePlus extends Object
{
/**
Creates a functions wrapper for the original function so that it runs
in the provided context.
@parameter obj Context in which to run the function.
@paramater func Function to run.
*/
static function create(obj:Object, func:Function):Function {
// Creates an array of the parameters that were also passed
                // with the create code.
                var parameters:Array = new Array();
// Using the arguments variable fill the array with the
                // parameters passed.  Start i at 2 because obj and func
                // use the first to positions in the arguments array
                for(var i:Number = 2; i < arguments.length; i++) {
parameters[i - 2] = arguments[i];
}

var f = function() {
// set the target scope and function
                        var target = arguments.callee.target;
var func = arguments.callee.func;
// use concat to link all the arguments together
                        var newArguments = arguments.concat(parameters);
//apply the function to the target with the arguments
                        return func.apply(target, newArguments);
};

f.target = obj;
f.func = func;
// using the return value from f will return the
                // result of the original function designated
                return f;
}

function DelegatePlus(f:Function){
func = f;
}

private var func:Function;

function createDelegatePlus(obj:Object):Function{
return create(obj, func);
}
}