FDMS/src/class/caurina/transitions/TweenListObj.as

package caurina.transitions {
    import caurina.transitions.AuxFunctions;
	/**
	 * The tween list object. Stores all of the properties and information that pertain to individual tweens.
	 *
	 * @author		Nate Chatellier, Zeh Fernando
	 * @version		1.0.4
	 * @private
	 */

	public class TweenListObj {
		
		public var scope					:Object;	// Object affected by this tweening
		public var properties				:Object;	// List of properties that are tweened (PropertyInfoObj instances)
			// .valueStart					:Number		// Initial value of the property
			// .valueComplete				:Number		// The value the property should have when completed
		public var timeStart				:Number;	// Time when this tweening should start
		public var timeComplete				:Number;	// Time when this tweening should end
		public var useFrames				:Boolean;	// Whether or not to use frames instead of time
		public var transition				:Function;	// Equation to control the transition animation
		public var transitionParams			:Object;	// Additional parameters for the transition
		public var onStart					:Function;	// Function to be executed on the object when the tween starts (once)
		public var onUpdate					:Function;	// Function to be executed on the object when the tween updates (several times)
		public var onComplete				:Function;	// Function to be executed on the object when the tween completes (once)
		public var onOverwrite				:Function;	// Function to be executed on the object when the tween is overwritten
		public var onError					:Function;	// Function to be executed if an error is thrown when tweener exectues a callback (onComplete, onUpdate etc)
		public var onStartParams			:Array;		// Array of parameters to be passed for the event
		public var onUpdateParams			:Array;		// Array of parameters to be passed for the event
		public var onCompleteParams			:Array;		// Array of parameters to be passed for the event
		public var onOverwriteParams		:Array;		// Array of parameters to be passed for the event
		public var onStartScope				:Object;	// Scope in which the event function is ran
		public var onUpdateScope			:Object;	// Scope in which the event function is ran
		public var onCompleteScope			:Object;	// Scope in which the event function is ran
		public var onOverwriteScope			:Object;	// Scope in which the event function is ran
		public var onErrorScope				:Object;	// Scope in which the event function is ran
		public var rounded					:Boolean;	// Use rounded values when updating
		public var isPaused					:Boolean;	// Whether or not this tween is paused
		public var timePaused				:Number;	// Time when this tween was paused
		public var isCaller					:Boolean;	// Whether or not this tween is a "caller" tween
		public var count					:Number;	// Number of times this caller should be called
		public var timesCalled				:Number;	// How many times the caller has already been called ("caller" tweens only)
		public var waitFrames				:Boolean;	// Whether or not this caller should wait at least one frame for each call execution ("caller" tweens only)
		public var skipUpdates				:Number;	// How many updates should be skipped (default = 0; 1 = update-skip-update-skip...)
		public var updatesSkipped			:Number;	// How many updates have already been skipped
		public var hasStarted				:Boolean;	// Whether or not this tween has already started

		// ==================================================================================================================================
		// CONSTRUCTOR function -------------------------------------------------------------------------------------------------------------

		/**
		 * Initializes the basic TweenListObj.
		 *
		 * @param	p_scope				Object		Object affected by this tweening
		 * @param	p_timeStart			Number		Time when this tweening should start
		 * @param	p_timeComplete		Number		Time when this tweening should end
		 * @param	p_useFrames			Boolean		Whether or not to use frames instead of time
		 * @param	p_transition		Function	Equation to control the transition animation
		 */
		function TweenListObj(p_scope:Object, p_timeStart:Number, p_timeComplete:Number, p_useFrames:Boolean, p_transition:Function, p_transitionParams:Object) {
			scope				=	p_scope;
			timeStart			=	p_timeStart;
			timeComplete		=	p_timeComplete;
			useFrames			=	p_useFrames;
			transition			=	p_transition;
			transitionParams	=	p_transitionParams;

			// Other default information
			properties		=	new Object();
			isPaused		=	false;
			timePaused		=	undefined;
			isCaller		=	false;
			updatesSkipped	=	0;
			timesCalled		=	0;
			skipUpdates		=	0;
			hasStarted		=	false;
		}


		// ==================================================================================================================================
		// OTHER functions ------------------------------------------------------------------------------------------------------------------
	
		/**
		 * Clones this tweening and returns the new TweenListObj
		 *
		 * @param	omitEvents		Boolean			Whether or not events such as onStart (and its parameters) should be omitted
		 * @return					TweenListObj	A copy of this object
		 */
		public function clone(omitEvents:Boolean):TweenListObj {
			var nTween:TweenListObj = new TweenListObj(scope, timeStart, timeComplete, useFrames, transition, transitionParams);
			nTween.properties = new Array();
			for (var pName:String in properties) {
				nTween.properties[pName] = properties[pName].clone();
			}
			nTween.skipUpdates = skipUpdates;
			nTween.updatesSkipped = updatesSkipped;
			if (!omitEvents) {
				nTween.onStart = onStart;
				nTween.onUpdate = onUpdate;
				nTween.onComplete = onComplete;
				nTween.onOverwrite = onOverwrite;
				nTween.onError = onError;
				nTween.onStartParams = onStartParams;
				nTween.onUpdateParams = onUpdateParams;
				nTween.onCompleteParams = onCompleteParams;
				nTween.onOverwriteParams = onOverwriteParams;
				nTween.onStartScope = onStartScope;
				nTween.onUpdateScope = onUpdateScope;
				nTween.onCompleteScope = onCompleteScope;
				nTween.onOverwriteScope = onOverwriteScope;
				nTween.onErrorScope = onErrorScope;
			}
			nTween.rounded = rounded;
			nTween.isPaused = isPaused;
			nTween.timePaused = timePaused;
			nTween.isCaller = isCaller;
			nTween.count = count;
			nTween.timesCalled = timesCalled;
			nTween.waitFrames = waitFrames;
			nTween.hasStarted = hasStarted;

			return nTween;
		}

		/**
		 * Returns this object described as a String.
		 *
		 * @return					String		The description of this object.
		 */
		public function toString():String {
			var returnStr:String = "\n[TweenListObj ";
			returnStr += "scope:" + String(scope);
			returnStr += ", properties:";
			var isFirst:Boolean = true;
			for (var i:String in properties) {
				if (!isFirst) returnStr += ",";
				returnStr += "[name:"+properties[i].name;
				returnStr += ",valueStart:"+properties[i].valueStart;
				returnStr += ",valueComplete:"+properties[i].valueComplete;
				returnStr += "]";
				isFirst = false;
			}
			returnStr += ", timeStart:" + String(timeStart);
			returnStr += ", timeComplete:" + String(timeComplete);
			returnStr += ", useFrames:" + String(useFrames);
			returnStr += ", transition:" + String(transition);
			returnStr += ", transitionParams:" + String(transitionParams);

			if (skipUpdates)		returnStr += ", skipUpdates:"		+ String(skipUpdates);
			if (updatesSkipped)		returnStr += ", updatesSkipped:"	+ String(updatesSkipped);

			if (Boolean(onStart))			returnStr += ", onStart:"			+ String(onStart);
			if (Boolean(onUpdate))			returnStr += ", onUpdate:"			+ String(onUpdate);
			if (Boolean(onComplete))		returnStr += ", onComplete:"		+ String(onComplete);
			if (Boolean(onOverwrite))		returnStr += ", onOverwrite:"		+ String(onOverwrite);
			if (Boolean(onError))			returnStr += ", onError:"			+ String(onError);
			
			if (onStartParams)		returnStr += ", onStartParams:"		+ String(onStartParams);
			if (onUpdateParams)		returnStr += ", onUpdateParams:"	+ String(onUpdateParams);
			if (onCompleteParams)	returnStr += ", onCompleteParams:"	+ String(onCompleteParams);
			if (onOverwriteParams)	returnStr += ", onOverwriteParams:" + String(onOverwriteParams);

			if (onStartScope)		returnStr += ", onStartScope:"		+ String(onStartScope);
			if (onUpdateScope)		returnStr += ", onUpdateScope:"		+ String(onUpdateScope);
			if (onCompleteScope)	returnStr += ", onCompleteScope:"	+ String(onCompleteScope);
			if (onOverwriteScope)	returnStr += ", onOverwriteScope:"	+ String(onOverwriteScope);
			if (onErrorScope)		returnStr += ", onErrorScope:"		+ String(onErrorScope);

			if (rounded)			returnStr += ", rounded:"			+ String(rounded);
			if (isPaused)			returnStr += ", isPaused:"			+ String(isPaused);
			if (timePaused)			returnStr += ", timePaused:"		+ String(timePaused);
			if (isCaller)			returnStr += ", isCaller:"			+ String(isCaller);
			if (count)				returnStr += ", count:"				+ String(count);
			if (timesCalled)		returnStr += ", timesCalled:"		+ String(timesCalled);
			if (waitFrames)			returnStr += ", waitFrames:"		+ String(waitFrames);
			if (hasStarted)			returnStr += ", hasStarted:"		+ String(hasStarted);
			
			returnStr += "]\n";
			return returnStr;
		}
		
		/**
		 * Checks if p_obj "inherits" properties from other objects, as set by the "base" property. Will create a new object, leaving others intact.
		 * o_bj.base can be an object or an array of objects. Properties are collected from the first to the last element of the "base" filed, with higher
		 * indexes overwritting smaller ones. Does not modify any of the passed objects, but makes a shallow copy of all properties.
		 *
		 * @param		p_obj		Object				Object that should be tweened: a movieclip, textfield, etc.. OR an array of objects
		 * @return					Object				A new object with all properties from the p_obj and p_obj.base.
		 */

		public static function makePropertiesChain(p_obj : Object) : Object{
			// Is this object inheriting properties from another object?
			var baseObject : Object = p_obj.base;
			if(baseObject){
				// object inherits. Are we inheriting from an object or an array
				var chainedObject : Object = {};
				var chain : Object;
				if (baseObject is Array){
					// Inheritance chain is the base array
					chain = [];
					// make a shallow copy
					for (var k : Number = 0 ; k< baseObject.length; k++) chain.push(baseObject[k]);
				}else{
					// Only one object to be added to the array
					chain = [baseObject];
				}
				// add the final object to the array, so it's properties are added last
				chain.push(p_obj);
				var currChainObj : Object;
				// Loops through each object adding it's property to the final object
				var len : Number = chain.length;
				for(var i : Number = 0; i < len ; i ++){
					if(chain[i]["base"]){
						// deal with recursion: watch the order! "parent" base must be concatenated first!
						currChainObj = AuxFunctions.concatObjects( makePropertiesChain(chain[i]["base"] ), chain[i]);
					}else{
						currChainObj = chain[i] ;
					}
					chainedObject = AuxFunctions.concatObjects(chainedObject, currChainObj );
				}
				if( chainedObject["base"]){
				    delete chainedObject["base"];
				}
				return chainedObject;
			}else{
				// No inheritance, just return the object it self
				return p_obj;
			}
		}
		

	}
	
	

	
}