CAAT.Module({

defines:"CAAT.Foundation.Actor",

aliases:[ "CAAT.Actor" ],

depends:[

"CAAT.Event.AnimationLoop",

"CAAT.Foundation.SpriteImage",

"CAAT.Core.Constants",

"CAAT.Behavior.PathBehavior",

"CAAT.Behavior.RotateBehavior",

"CAAT.Behavior.ScaleBehavior",

"CAAT.Behavior.Scale1Behavior",

"CAAT.PathUtil.LinearPath",

"CAAT.Event.AnimationLoop"

],

constants:{

ANCHOR_CENTER:0, // constant values to determine different affine transform

ANCHOR_TOP:1, // anchors.

ANCHOR_BOTTOM:2,

ANCHOR_LEFT:3,

ANCHOR_RIGHT:4,

ANCHOR_TOP_LEFT:5,

ANCHOR_TOP_RIGHT:6,

ANCHOR_BOTTOM_LEFT:7,

ANCHOR_BOTTOM_RIGHT:8,

ANCHOR_CUSTOM:9,

NO_CACHE:0,

CACHE_SIMPLE:1,

CACHE_DEEP:2

},

extendsWith:function () {

var __index = 0;

return {

__init:function () {

this.behaviorList = [];

this.styleCache = {};

this.lifecycleListenerList = [];

this.scaleAnchor = this.ANCHOR_CENTER;

this.behaviorList = [];

this.domElement = document.createElement('div');

this.domElement.style['position'] = 'absolute';

this.domElement.style['-webkit-transform'] = 'translate3d(0,0,0)';

this.domElement.style['-webkit-transition'] = 'all 0s linear';

this.style('display', 'none');

this.AABB = new CAAT.Rectangle();

this.viewVertices = [

new CAAT.Point(0, 0, 0),

new CAAT.Point(0, 0, 0),

new CAAT.Point(0, 0, 0),

new CAAT.Point(0, 0, 0)

];

this.setVisible(true);

this.resetTransform();

this.setScale(1, 1);

this.setRotation(0);

this.modelViewMatrix = new CAAT.Math.Matrix();

this.modelViewMatrixI = new CAAT.Math.Matrix();

this.worldModelViewMatrix = new CAAT.Math.Matrix();

this.worldModelViewMatrixI = new CAAT.Math.Matrix();

return this;

},

lifecycleListenerList:null, // Array of life cycle listener

behaviorList:null, // Array of behaviors to apply to the Actor

x:0, // x position on parent. In parent's local coord. system.

y:0, // y position on parent. In parent's local coord. system.

width:0, // Actor's width. In parent's local coord. system.

height:0, // Actor's height. In parent's local coord. system.

preferredSize:null, // actor's preferred size for layout. {CAAT.Dimension}

minimumSize:null, // actor's minimum size for layout. {CAAT.Dimension},

start_time:0, // Start time in Scene time.

duration:Number.MAX_VALUE, // Actor duration in Scene time

clip:false, // should clip the Actor's content against its contour.

tAnchorX:0,

tAnchorY:0,

scaleX:0, // transformation. width scale parameter

scaleY:0, // transformation. height scale parameter

scaleTX:.50, // transformation. scale anchor x position

scaleTY:.50, // transformation. scale anchor y position

scaleAnchor:0, // transformation. scale anchor

rotationAngle:0, // transformation. rotation angle in radians

rotationY:.50, // transformation. rotation center y

alpha:1, // alpha transparency value

rotationX:.50, // transformation. rotation center x

isGlobalAlpha:false, // is this a global alpha

frameAlpha:1, // hierarchically calculated alpha for this Actor.

expired:false, // set when the actor has been expired

discardable:false, // set when you want this actor to be removed if expired

domParent:null,

domElement:null,

visible:true,

mouseEnabled:true,

time:0, // Cache Scene time.

inFrame:false, // boolean indicating whether this Actor was present on last frame.

backgroundImage:null,

size_active:1, // number of animated children

size_total:1,

id:null,

__d_ax:-1, // for drag-enabled actors.

__d_ay:-1,

gestureEnabled:false,

AABB:null,

viewVertices:null, // model to view transformed vertices.

isAA:true,

preventLayout : false,

setPreventLayout : function(b) {

this.preventLayout= b;

return this;

},

invalidate:function () {

this.invalid = true;

return this;

},

invalidateLayout:function () {

if (this.parent && !this.parent.layoutInvalidated) {

this.parent.invalidateLayout();

}

return this;

},

__validateLayout:function () {

},

/**

* Set this actors preferred layout size.

*

* @param pw {number}

* @param ph {number}

* @return {*}

*/

setPreferredSize:function (pw, ph) {

if (!this.preferredSize) {

this.preferredSize = new CAAT.Dimension();

}

this.preferredSize.width = pw;

this.preferredSize.height = ph;

return this;

},

getPreferredSize:function () {

return this.preferredSize ? this.preferredSize :

this.getMinimumSize();

},

/**

* Set this actors minimum layout size.

*

* @param pw {number}

* @param ph {number}

* @return {*}

*/

setMinimumSize:function (pw, ph) {

if (!this.minimumSize) {

this.minimumSize = new CAAT.Dimension();

}

this.minimumSize.width = pw;

this.minimumSize.height = ph;

return this;

},

getMinimumSize:function () {

return this.minimumSize ? this.minimumSize :

new CAAT.Dimension(this.width, this.height);

},

isVisible:function () {

return this.visible;

},

/**

* @deprecated

* @return {*}

*/

create:function () {

return this;

},

/**

* Move this actor to a position.

* It creates and adds a new PathBehavior.

* @param x {number} new x position

* @param y {number} new y position

* @param duration {number} time to take to get to new position

* @param delay {=number} time to wait before start moving

* @param interpolator {=CAAT.Interpolator} a CAAT.Interpolator instance

*/

moveTo:function (x, y, duration, delay, interpolator) {

if (x === this.x && y === this.y) {

return;

}

var id = '__moveTo';

var b = this.getBehavior(id);

if (!b) {

b = new CAAT.PathBehavior().

setId(id).

setValues(new CAAT.LinearPath());

this.addBehavior(b);

}

b.path.setInitialPosition(this.x, this.y).setFinalPosition(x, y);

b.setDelayTime(delay ? delay : 0, duration);

if (interpolator) {

b.setInterpolator(interpolator);

}

return this;

},

/**

*

* @param angle {number} new rotation angle

* @param duration {number} time to rotate

* @param delay {number=} millis to start rotation

* @param anchorX {number=} rotation anchor x

* @param anchorY {number=} rotation anchor y

* @param interpolator {CAAT.Interpolator=}

* @return {*}

*/

rotateTo:function (angle, duration, delay, anchorX, anchorY, interpolator) {

if (angle === this.rotationAngle) {

return;

}

var id = '__rotateTo';

var b = this.getBehavior(id);

if (!b) {

b = new CAAT.RotateBehavior().

setId(id).

setValues(0, 0, .5, .5);

this.addBehavior(b);

}

b.setValues(this.rotationAngle, angle, anchorX, anchorY).

setDelayTime(delay ? delay : 0, duration);

if (interpolator) {

b.setInterpolator(interpolator);

}

return this;

},

/**

*

* @param scaleX {number} new X scale

* @param scaleY {number} new Y scale

* @param duration {number} time to rotate

* @param delay {=number} millis to start rotation

* @param anchorX {=number} rotation anchor x

* @param anchorY {=number} rotation anchor y

* @param interpolator {=CAAT.Interpolator}

* @return {*}

*/

scaleTo:function (scaleX, scaleY, duration, delay, anchorX, anchorY, interpolator) {

if (this.scaleX === scaleX && this.scaleY === scaleY) {

return;

}

var id = '__scaleTo';

var b = this.getBehavior(id);

if (!b) {

b = new CAAT.ScaleBehavior().

setId(id).

setValues(1, 1, 1, 1, .5, .5);

this.addBehavior(b);

}

b.setValues(this.scaleX, scaleX, this.scaleY, scaleY, anchorX, anchorY).

setDelayTime(delay ? delay : 0, duration);

if (interpolator) {

b.setInterpolator(interpolator);

}

return this;

},

/**

*

* @param scaleX {number} new X scale

* @param duration {number} time to rotate

* @param delay {=number} millis to start rotation

* @param anchorX {=number} rotation anchor x

* @param anchorY {=number} rotation anchor y

* @param interpolator {=CAAT.Interpolator}

* @return {*}

*/

scaleXTo:function (scaleX, duration, delay, anchorX, anchorY, interpolator) {

return this.__scale1To(

CAAT.Scale1Behavior.AXIS_X,

scaleX,

duration,

delay,

anchorX,

anchorY,

interpolator

);

},

/**

*

* @param scaleY {number} new Y scale

* @param duration {number} time to rotate

* @param delay {=number} millis to start rotation

* @param anchorX {=number} rotation anchor x

* @param anchorY {=number} rotation anchor y

* @param interpolator {=CAAT.Interpolator}

* @return {*}

*/

scaleYTo:function (scaleY, duration, delay, anchorX, anchorY, interpolator) {

return this.__scale1To(

CAAT.Scale1Behavior.AXIS_Y,

scaleY,

duration,

delay,

anchorX,

anchorY,

interpolator

);

},

/**

* @param axis {CAAT.Scale1Behavior.AXIS_X|CAAT.Scale1Behavior.AXIS_Y} scale application axis

* @param scale {number} new Y scale

* @param duration {number} time to rotate

* @param delay {=number} millis to start rotation

* @param anchorX {=number} rotation anchor x

* @param anchorY {=number} rotation anchor y

* @param interpolator {=CAAT.Interpolator}

* @return {*}

*/

__scale1To:function (axis, scale, duration, delay, anchorX, anchorY, interpolator) {

if (( axis === CAAT.Scale1Behavior.AXIS_X && scale === this.scaleX) ||

( axis === CAAT.Scale1Behavior.AXIS_Y && scale === this.scaleY)) {

return;

}

var id = '__scaleXTo';

var b = this.getBehavior(id);

if (!b) {

b = new CAAT.Scale1Behavior().

setId(id).

setValues(1, 1, axis === CAAT.Scale1Behavior.AXIS_X, .5, .5);

this.addBehavior(b);

}

b.setValues(

axis ? this.scaleX : this.scaleY,

scale,

anchorX,

anchorY).

setDelayTime(delay ? delay : 0, duration);

if (interpolator) {

b.setInterpolator(interpolator);

}

return this;

},

/**

* Touch Start only received when CAAT.TOUCH_BEHAVIOR= CAAT.TOUCH_AS_MULTITOUCH

* @param e <CAAT.TouchEvent>

*/

touchStart:function (e) {

},

touchMove:function (e) {

},

touchEnd:function (e) {

},

gestureStart:function (rotation, scaleX, scaleY) {

},

gestureChange:function (rotation, scaleX, scaleY) {

if (this.gestureEnabled) {

this.setRotation(rotation);

this.setScale(scaleX, scaleY);

}

return this;

},

gestureEnd:function (rotation, scaleX, scaleY) {

},

/**

* Calculates the 2D bounding box in canvas coordinates of the Actor.

* This bounding box takes into account the transformations applied hierarchically for

* each Scene Actor.

*

* @private

*

*/

setScreenBounds:function () {

var AABB = this.AABB;

var vv = this.viewVertices;

if (this.isAA) {

var m = this.worldModelViewMatrix.matrix;

AABB.x = m[2];

AABB.y = m[5];

AABB.x1 = m[2] + this.width;

AABB.y1 = m[5] + this.height;

AABB.width = AABB.x1 - AABB.x;

AABB.height = AABB.y1 - AABB.y;

return this;

}

var vvv;

vvv = vv[0];

vvv.x = 0;

vvv.y = 0;

vvv = vv[1];

vvv.x = this.width;

vvv.y = 0;

vvv = vv[2];

vvv.x = this.width;

vvv.y = this.height;

vvv = vv[3];

vvv.x = 0;

vvv.y = this.height;

this.modelToView(this.viewVertices);

var xmin = Number.MAX_VALUE, xmax = -Number.MAX_VALUE;

var ymin = Number.MAX_VALUE, ymax = -Number.MAX_VALUE;

vvv = vv[0];

if (vvv.x < xmin) {

xmin = vvv.x;

}

if (vvv.x > xmax) {

xmax = vvv.x;

}

if (vvv.y < ymin) {

ymin = vvv.y;

}

if (vvv.y > ymax) {

ymax = vvv.y;

}

vvv = vv[1];

if (vvv.x < xmin) {

xmin = vvv.x;

}

if (vvv.x > xmax) {

xmax = vvv.x;

}

if (vvv.y < ymin) {

ymin = vvv.y;

}

if (vvv.y > ymax) {

ymax = vvv.y;

}

vvv = vv[2];

if (vvv.x < xmin) {

xmin = vvv.x;

}

if (vvv.x > xmax) {

xmax = vvv.x;

}

if (vvv.y < ymin) {

ymin = vvv.y;

}

if (vvv.y > ymax) {

ymax = vvv.y;

}

vvv = vv[3];

if (vvv.x < xmin) {

xmin = vvv.x;

}

if (vvv.x > xmax) {

xmax = vvv.x;

}

if (vvv.y < ymin) {

ymin = vvv.y;

}

if (vvv.y > ymax) {

ymax = vvv.y;

}

AABB.x = xmin;

AABB.y = ymin;

AABB.x1 = xmax;

AABB.y1 = ymax;

AABB.width = (xmax - xmin);

AABB.height = (ymax - ymin);

return this;

},

setGestureEnabled:function (enable) {

this.gestureEnabled = !!enable;

return this;

},

isGestureEnabled:function () {

return this.gestureEnabled;

},

getId:function () {

return this.id;

},

setId:function (id) {

this.id = id;

return this;

},

/**

* Set this Actor's parent and connect in CSS a div with its parent.

* In case there's a parent set, previously the div will be removed from

* its old parent and reattached to the new one.

* @param parent {CAAT.ActorContainerCSS|CAAT.Actor}

* @return this

*/

setParent:function (parent) {

if (this.parent) {

try {

this.domParent.removeChild(this.domElement);

} catch (e) {

// when changing a parent, make sure the operation does not fail.

// it may happen a root node has had removed its children and all the dom hierarchy

// may have been lost.

}

}

this.parent = parent;

if (null != parent) {

this.parent.domElement.appendChild(this.domElement);

this.domParent = this.parent.domElement;

} else {

this.domParent = null;

}

this.dirty = true;

return this;

},

/**

* Set this actor's background image.

* The need of a background image is to kept compatibility with the new CSSDirector class.

* The image parameter can be either an Image/Canvas or a CAAT.SpriteImage instance. If an image

* is supplied, it will be wrapped into a CAAT.SriteImage instance of 1 row by 1 column.

* If the actor has set an image in the background, the paint method will draw the image, otherwise

* and if set, will fill its background with a solid color.

* If adjust_size_to_image is true, the host actor will be redimensioned to the size of one

* single image from the SpriteImage (either supplied or generated because of passing an Image or

* Canvas to the function). That means the size will be set to [width:SpriteImage.singleWidth,

* height:singleHeight].

*

* It is absolutely recommended not using a Canvas as argument. The performance

* of canvas.toDataURL (despite its result being cached) is very poor.

*

* @see CAAT.SpriteImage

*

* @param image {Image|Canvas|CAAT.SpriteImage}

* @param adjust_size_to_image {boolean} whether to set this actor's size based on image parameter.

* @throws 'Invalid image object to set actor's background' in case the image parameter is not of the

* valid type.

* @return this

*/

setBackgroundImage:function (image, adjust_size_to_image) {

if (image) {

// Opera will complaint about instanceof Image, so better HTMLImageElement.

if (image instanceof HTMLImageElement) {

image = new CAAT.Foundation.SpriteImage().initialize(image, 1, 1);

} else if (image instanceof HTMLCanvasElement) {

image.src = image.toDataURL();

image = new CAAT.Foundation.SpriteImage().initialize(image, 1, 1);

} else if (image instanceof CAAT.SpriteImage) {

if (image.image instanceof HTMLCanvasElement) {

if (!image.image.src) {

image.image.src = image.image.toDataURL();

}

}

} else if (isString(image)) {

image= new CAAT.Foundation.SpriteImage().initialize( CAAT.currentDirector.getImage(image), 1, 1 );

} else {

throw "Invalid image object to set actor's background";

}

image.setOwner(this);

this.backgroundImage = image;

if (typeof adjust_size_to_image === 'undefined' || adjust_size_to_image) {

this.setSize(image.getWidth(), image.getHeight());

}

this.style(

'background',

'url(' + this.backgroundImage.image.src + ') ' +

this.backgroundImage.getCurrentSpriteImageCSSPosition());

} else {

this.backgroundImage = null;

this.style('background', 'none');

}

return this;

},

/**

* Set the actor's SpriteImage index from animation sheet.

* @see CAAT.SpriteImage

* @param index {integer}

*

* @return this

*/

setSpriteIndex:function (index) {

if (this.backgroundImage) {

this.backgroundImage.setSpriteIndex(index);

this.style(

'background',

'url(' + this.backgroundImage.image.src + ') ' +

this.backgroundImage.getCurrentSpriteImageCSSPosition());

}

return this;

},

/**

* Set this actor's background SpriteImage offset displacement.

* The values can be either positive or negative meaning the texture space of this background

* image does not start at (0,0) but at the desired position.

* @see CAAT.SpriteImage

* @param ox {integer} horizontal offset

* @param oy {integer} vertical offset

*

* @return this

*/

setBackgroundImageOffset:function (ox, oy) {

if (this.backgroundImage) {

this.backgroundImage.setOffset(ox, oy);

this.style(

'background',

'url(' + this.backgroundImage.image.src + ') ' +

this.backgroundImage.getCurrentSpriteImageCSSPosition());

}

return this;

},

/**

* Set this actor's background SpriteImage its animation sequence.

* In its simplet's form a SpriteImage treats a given image as an array of rows by columns

* subimages. If you define d Sprite Image of 2x2, you'll be able to draw any of the 4 subimages.

* This method defines the animation sequence so that it could be set [0,2,1,3,2,1] as the

* animation sequence

* @param ii {array<integer>} an array of integers.

*/

setAnimationImageIndex:function (ii) {

if (this.backgroundImage) {

this.backgroundImage.setAnimationImageIndex(ii);

this.style(

'background',

'url(' + this.backgroundImage.image.src + ') ' +

this.backgroundImage.getCurrentSpriteImageCSSPosition());

}

return this;

},

addAnimation : function( name, array, time, callback ) {

if (this.backgroundImage) {

this.backgroundImage.addAnimation(name, array, time, callback);

}

return this;

},

playAnimation : function(name) {

if (this.backgroundImage) {

this.backgroundImage.playAnimation(name);

}

return this;

},

setAnimationEndCallback : function(f) {

if (this.backgroundImage) {

this.backgroundImage.setAnimationEndCallback(f);

}

},

setChangeFPS:function (time) {

if (this.backgroundImage) {

this.backgroundImage.setChangeFPS(time);

}

return this;

},

/**

* This method has no effect on ActorCSS

* @param it any value from CAAT.Actor.TR_*

* @return this

*/

setImageTransformation:function (it) {

this.transformation = it;

if (it === CAAT.Foundation.SpriteImage.TR_FIXED_TO_SIZE) {

this.style('background-size', '100%');

} else if (it === CAAT.Foundation.SpriteImage.TR_NONE) {

this.style('background-size', 'auto');

}

return this;

},

/**

* Center this actor at position (x,y).

* @param x {float} x position

* @param y {float} y position

*

* @return this

*/

centerOn:function (x, y) {

this.setLocation(x - this.width / 2, y - this.height / 2);

return this;

},

/**

* Center this actor at position (x,y).

* @param x {number} x position

* @param y {number} y position

*

* @return this

*/

centerAt:function (x, y) {

return this.centerOn(x, y);

},

/**

* Set this actor invisible.

* The actor is animated but not visible.

* A container won't show any of its children if set visible to false.

*

* @param visible {boolean} set this actor visible or not.

* @return this

*/

setVisible:function (visible) {

this.visible = visible;

return this;

},

style:function (attr, value) {

if (value !== this.styleCache[attr]) {

this.styleCache[attr] = value;

this.domElement.style[attr] = value;

}

},

style3:function () {

var imageop = '';

if (this.transformation === CAAT.Foundation.SpriteImage.TR_FLIP_HORIZONTAL) {

imageop = ' scale(-1,1) ';

}

this.rotationAngle = Math.round(this.rotationAngle * 100) / 100;

var value =

"translate(" + this.x + "px," + this.y + "px) " +

"rotate(" + this.rotationAngle + "rad) scale(" + this.scaleX + "," + this.scaleY + ")" +

imageop;

if (value !== this.styleCache['transform']) {

this.domElement.style['-ms-transform'] = value;

this.domElement.style['-webkit-transform'] = "translate3d(0,0,0) " + value;

this.domElement.style.OTransform = value;

this.domElement.style.MozTransform = value;

this.domElement.style['transform'] = value;

this.styleCache['transform'] = value;

}

var anchor = '' + (this.rotationX * 100) + '% ' +

(this.rotationY * 100) + '% ';

if (anchor !== this.styleCache['transform-origin']) {

this.domElement.style['transform-origin'] = anchor;

this.domElement.style['-webkit-transform-origin'] = anchor;

this.domElement.style['-ms-transform-origin'] = anchor;

this.domElement.style.OTransformOrigin = anchor;

this.domElement.style.MozTransformOrigin = anchor;

this.styleCache['transform-origin'] = anchor;

}

return this;

},

styleAlpha:function (alpha) {

if (this.alpha !== this.styleCache['opacity']) {

this.domElement.style['filter'] = 'alpha(opacity=' + ((this.alpha * 100) >> 0) + ')';

this.domElement.style.Oopacity = this.alpha;

this.domElement.style.MozOpacity = this.alpha;

this.domElement.style['-khtml-opacity'] = this.alpha;

this.domElement.style.opacity = this.alpha;

this.styleCache['opacity'] = this.alpha;

}

return this;

},

/**

* Puts an Actor out of time line, that is, won't be transformed nor rendered.

* @return this

*/

setOutOfFrameTime:function () {

this.setFrameTime(-1, 0);

this.style('display', 'none');

return this;

},

/**

* Adds an Actor's life cycle listener.

* The developer must ensure the actorListener is not already a listener, otherwise

* it will notified more than once.

* @param actorListener {object} an object with at least a method of the form:

* <code>actorLyfeCycleEvent( actor, string_event_type, long_time )</code>

*/

addListener:function (actorListener) {

this.lifecycleListenerList.push(actorListener);

},

/**

* Removes an Actor's life cycle listener.

* It will only remove the first occurrence of the given actorListener.

* @param actorListener {object} an Actor's life cycle listener.

*/

removeListener:function (actorListener) {

var n = this.lifecycleListenerList.length;

while (n--) {

if (this.lifecycleListenerList[n] === actorListener) {

// remove the nth element.

this.lifecycleListenerList.splice(n, 1);

return;

}

}

},

/**

* Set alpha composition scope. global will mean this alpha value will be its children maximum.

* If set to false, only this actor will have this alpha value.

* @param global {boolean} whether the alpha value should be propagated to children.

*/

setGlobalAlpha:function (global) {

this.isGlobalAlpha = global;

return this;

},

/**

* Notifies the registered Actor's life cycle listener about some event.

* @param sEventType an string indicating the type of event being notified.

* @param time an integer indicating the time related to Scene's timeline when the event

* is being notified.

*/

fireEvent:function (sEventType, time) {

for (var i = 0; i < this.lifecycleListenerList.length; i++) {

this.lifecycleListenerList[i].actorLifeCycleEvent(this, sEventType, time);

}

},

/**

* Sets this Actor as Expired.

* If this is a Container, all the contained Actors won't be nor drawn nor will receive

* any event. That is, expiring an Actor means totally taking it out the Scene's timeline.

* @param time {number} an integer indicating the time the Actor was expired at.

* @return this.

*/

setExpired:function (time) {

this.expired = true;

this.style('display', 'none');

this.fireEvent('expired', time);

return this;

},

/**

* Enable or disable the event bubbling for this Actor.

* @param enable {boolean} a boolean indicating whether the event bubbling is enabled.

* @return this

*/

enableEvents:function (enable) {

this.mouseEnabled = enable;

return this;

},

/**

* Removes all behaviors from an Actor.

* @return this

*/

emptyBehaviorList:function () {

this.behaviorList = [];

return this;

},

/*

emptyKeyframesList : function() {

this.keyframesList= [];

},

*/

/**

* Caches a fillStyle in the Actor.

* @param style a valid Canvas rendering context fillStyle.

* @return this

*/

setFillStyle:function (style) {

this.style('background', style);

return this;

},

/**

* Caches a stroke style in the Actor.

* @param style a valid canvas rendering context stroke style.

* @return this

*/

setStrokeStyle:function (style) {

return this;

},

/**

* @deprecated

* @param paint

*/

setPaint:function (paint) {

},

/**

* Stablishes the Alpha transparency for the Actor.

* If it globalAlpha enabled, this alpha will the maximum alpha for every contained actors.

* The alpha must be between 0 and 1.

* @param alpha a float indicating the alpha value.

* @return this

*/

setAlpha:function (alpha) {

this.alpha = alpha;

return this;

},

/**

* Remove all transformation values for the Actor.

* @return this

*/

resetTransform:function () {

this.rotationAngle = 0;

this.rotationX = .5;

this.rotationY = .5;

this.scaleX = 1;

this.scaleY = 1;

this.scaleTX = .5;

this.scaleTY = .5;

this.scaleAnchor = 0;

this.oldX = -1;

this.oldY = -1;

this.style3();

this.dirty = true;

return this;

},

/**

* Sets the time life cycle for an Actor.

* These values are related to Scene time.

* @param startTime an integer indicating the time until which the Actor won't be visible on the Scene.

* @param duration an integer indicating how much the Actor will last once visible.

* @return this

*/

setFrameTime:function (startTime, duration) {

this.start_time = startTime;

this.duration = duration;

this.expired = false;

this.dirty = true;

return this;

},

/**

* This method should me overriden by every custom Actor.

* It will be the drawing routine called by the Director to show every Actor.

* @param director the CAAT.Director instance that contains the Scene the Actor is in.

* @param time an integer indicating the Scene time in which the drawing is performed.

*/

paint:function (director, time) {

},

/**

* A helper method to setScaleAnchored with an anchor of ANCHOR_CENTER

*

* @see setScaleAnchored

*

* @param sx a float indicating a width size multiplier.

* @param sy a float indicating a height size multiplier.

* @return this

*/

setScale:function (sx, sy) {

this.setScaleAnchored(sx, sy, .5, .5);

return this;

},

/**

* Private.

* Gets a given anchor position referred to the Actor.

* @param anchor