animator.as

flash as编程的库和源代码

		this.durationInFrames = APCore.milliseconds2frames(this.duration);		
		this.invokeAnimation(this.startPercent, this.endPercent);
	}

	private function invokeAnimation(start:Number, end:Number):void {
			
		this.finished = false;		
		/*important for pause/resume/stop*/
		if(this.caller == this) {
			this.myAnimator = this;
		}		
		this.caller.setTweening(true);
		
		this.initStartEndValues(start, end);
		var myTweenAction:TweenAction = this.initTweenAction();
		
		if(this.caller.getTweenMode() == AnimationCore.INTERVAL) {
			initializeTimeTween(myTweenAction);
		} else if(this.caller.getTweenMode() == AnimationCore.FRAMES) {
			initializeFrameTween(myTweenAction);
		}
		
		var setterObj:Object = this.retrieveSetters();
		
		this.myTween.setTweenHandlers(setterObj.update, 
								setterObj.end);
		this.myTween.easingEquation = this.easing;
		this.myTween.start();
		this.dispatchOnStart();
	}
	
	private function initializeTimeTween(myTweenAction:TweenAction):void {
		this.myTween = new TimeTween(myTweenAction, 
								this.initVal, 
								this.endVal, 
								this.duration, 
								this.caller.easingParams);	
	}
	
	private function initializeFrameTween(myTweenAction:TweenAction):void {
		this.myTween = new FrameTween(myTweenAction, 
								this.initVal, 
								this.endVal, 
								this.durationInFrames, 
								this.caller.easingParams);
	}	
	
	private function initStartEndValues(start:Number, end:Number):void {

		if(this.arrayLength > 1) {
						
			var startValues:Array = this.getStartValues();
			var endValues:Array = this.getEndValues();			
			var startRelArr:Array = [];
			var endRelArr:Array = [];
			var i:Number;
			var len:Number = this.arrayLength;
			for(i = 0; i < len; i++) {				
				startRelArr.push(start / 100 * (endValues[i] - startValues[i]) + startValues[i]);
				endRelArr.push(end / 100 * (endValues[i] - startValues[i]) + startValues[i]);
			}
			this.initVal = startRelArr;
			this.endVal = endRelArr;			

		} else {
			
			var startValue:Number = this.getStartValue();
			var endValue:Number = this.getEndValue();		
			var dif:Number = endValue - startValue;
			var startRel:Number = start / 100 * dif + startValue;		
			var endRel:Number = end / 100 * dif + startValue;
			this.initVal = startRel;
			this.endVal = endRel;
			
		}
	}
	
	private function initTweenAction():TweenAction {
		var scope:Object = this.setter[0][0];
		var targetStr:String = this.setter[0][1];		
		var identifier:* = scope[targetStr];
		var myTweenAction:TweenAction = new TweenAction(this, 
												this.initVal, 
												this.endVal);
		if(this.arrayMode == false) {
			myTweenAction.initSingleMode(scope, targetStr, identifier);
		} else {
			myTweenAction.initMultiMode(this.arrayLength);
		}
		
		return myTweenAction;
	}
	
	private function retrieveSetters():Object {
		
		/* 
		* Choose the most suitable callback method of TweenAction.
		* Optimized, less readable code.
		* o = onTweenUpdateOnce
		* m = onTweenUpdateMulitple
		* e = onTweenEnd
		* 2 = rounds the result
		* p = only properties
		* m = only methods
		* mu = multiple parameters
		* mu2 = rounded multiple parameters
		*/
		/*first compute identifierTokens for another abstration*/
		this.computeSetters();
		
		var setterObj:Object = new Object();
		var rounded:Boolean = this.caller.isRounded();
		if(this.arrayMode == false) {			
			if(!rounded) {
				if(this.identifierToken == 0) {
					setterObj.update = "op";
				} else if(this.identifierToken == 1) {
					setterObj.update = "om";
				} else {
					setterObj.update = "o";
				}
			} else {
				if(this.identifierToken == 0) {
					setterObj.update = "o2p";
				} else if(this.identifierToken == 1) {
					setterObj.update = "o2m";
				} else {
					setterObj.update = "o2";
				}
			}			
		} else {
			if(!rounded) {				
				if(this.identifierToken == 0) {
					setterObj.update = "mp";
				} else if(this.identifierToken == 1) {
					setterObj.update = "mm";
				} else if(this.identifierToken == 2) {
					setterObj.update = "m";
				} else {
					setterObj.update = "mu";
				}
			} else {
				if(this.identifierToken == 0) {
					setterObj.update = "m2p";
				} else if(this.identifierToken == 1) {					
					setterObj.update = "m2m";
				} else if(this.identifierToken == 2) {
					setterObj.update = "m2";
				}else {
					setterObj.update = "mu2";
				}
			}
		}
		setterObj.end = "e";
		return setterObj;
	}
	
	private function computeSetters():void {
		var scope:Object = this.setter[0][0];
		var targetStr:String = this.setter[0][1];
		var identifier:* = scope[targetStr];
		/*
		* initialize TweenAction and check if either only properties, only methods or both are used. 
		* Needed for optimisation. The corresponding callback method of TweenAction 
		* will be chosen later in retrieveSetters.
		*/
		if(this.arrayMode == false) {
			this.checkIfFunction(identifier);			
		} else {
			/*
			* if there are more values to animate than setters, Animator assigns a 
			* special callback method of TweenAction, 
			* which sends all animated values to the first setter.
			*/
			if(this.setter.length < this.arrayLength) {
				this.identifierToken = 3;
			} else {		
				var i:Number = this.setter.length-1;
				var result:Boolean = this.checkIfFunction(this.setter[i][0][this.setter[i][1]]);
				while(--i>-1) {
					if(this.checkIfFunction(this.setter[i][0][this.setter[i][1]]) != result) {
						this.identifierToken = 2;
						break;
					}
				}
			}	
		}
	}
	
	/*
	* 0 = Property
	* 1 = Method
	* 2 = Both
	* 3 = multiple parameters
	*/
	private function checkIfFunction(identifier:*):Boolean {		
		if(identifier is Function) {
			this.identifierToken = 1;
			return true;
		} else {
			this.identifierToken = 0;
			return false;
		}
	}	

	private function createMultiSetter(setter:Array):void {
		/*
		* if the multiStart property is defined, Animator fills 
		* the start parameter with the return values of the methods or
		* properties of the multiStart Array.
		* This way each IAnimatable user class can present different 
		* start values to Animator for each animation target with setting 
		* the multiStart and multiSetter properties.
		*/
		var init:Boolean;
		var startVal:Array;
		var startValue:Number;
		var startTargetStr:String;
		if(this.multiStart == null) {
			init = false;
			startVal = this.start;
		} else {			
			init = true;
		}
		var s:Array = this.start = [];
		var endVal:Array = this.end;
		var endValue:Number;
		var e:Array = this.end = [];
		var se:Array = this.setter = [];
		var scopes:Array;
		var len1:Number = setter.length;	
		var i:Number = len1;
		while(--i>-1) {
			if(init) {
				startTargetStr = this.multiStart[i];
			} else {
				startValue = startVal[i];
			}
			endValue = endVal[i];
			scopes = setter[i][0];
			var targetStr:String = setter[i][1];
			var len2:Number = scopes.length;	
			var j:Number = len2;
			while(--j>-1) {
				var scope:Object = scopes[j];				
				if(init) {
					if(this.checkIfFunction(scope[startTargetStr])) {
						s.unshift(scope[startTargetStr]());
					} else {
						s.unshift(scope[startTargetStr]);
					}
				} else {
					s.unshift(startValue);					
				}
				e.unshift(endValue);
				se.unshift([scope,targetStr]);
			}			
		}	
		if(scopes.length == 0) {			
			this.caller.setStartValue(s);
			this.caller.setEndValue(e);
			this.caller.setStartValues(undefined);
			this.caller.setEndValues(undefined);
			this.caller.setCurrentValues(undefined);
		} else {
			this.caller.setStartValues(s);
			this.caller.setEndValues(e);
			this.caller.setStartValue(undefined);
			this.caller.setEndValue(undefined);
			this.caller.setCurrentValue(undefined);
		}
	}
	
	override public function getDurationElapsed():Number {		
		if(this.paused == true || this.stopped == true) {
			return this.elapsedDuration;
		} else {
			return this.computeElapsedDuration();
		}
	}
	
	override public function getDurationRemaining():Number {
		var r:Number;
		if(this.stopped == false) {
			if(this.caller.getTweenMode() == AnimationCore.INTERVAL) {
				r = this.duration - this.getDurationElapsed();
			} else if(this.caller.getTweenMode() == AnimationCore.FRAMES) {
				if(this.caller.getDurationMode() == AnimationCore.MS) {	
					r = this.duration - this.getDurationElapsed();
					if(this.finished == true) {
						r = 0;
					}
				} else {
					r = this.durationInFrames - this.getDurationElapsed();
				}
			}
			if(r < 0) {
				r = 0;
			}
		} else {
			r = 0;
		}
		if(isNaN(r)) {
			return undefined;
		} else {
			return r;
		}
	}
	
	private function computeElapsedDuration():Number {
		var r:Number;
		if(this.finished == true) {
			r = this.duration;
		} else {
			if(this.myTween != null) {
				if(this.caller.getTweenMode() == AnimationCore.INTERVAL) {
					r = getTimer() - this.myTween.startTime;
				} else if(this.caller.getTweenMode() == AnimationCore.FRAMES) {
					if(this.caller.getDurationMode() == AnimationCore.MS) {
						r = APCore.getFPS() * (APCore.frame - this.myTween.startTime);			
					} else {
						r = APCore.frame - this.myTween.startTime;
					}		
				}
			}
		}
		if(isNaN(r)) {
			return undefined;
		} else {
			return r;
		}
	}

	public function stopMe():void {
		this.elapsedDuration = this.computeElapsedDuration();
		deleteAnimation();
		this.stopped = true;
	}
	
	public function pauseMe():void {	
		this.elapsedDuration = this.computeElapsedDuration();
		this.myTween.pause();
	}
	
	public function resumeMe():void {
		this.myTween.resume();
	}
}

}