dojo._xdResourceLoaded({
depends: [["provide", "dojo._base.fx"],
["require", "dojo._base.Color"],
["require", "dojo._base.connect"],
["require", "dojo._base.declare"],
["require", "dojo._base.lang"],
["require", "dojo._base.html"]],
defineResource: function(dojo){if(!dojo._hasResource["dojo._base.fx"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
dojo._hasResource["dojo._base.fx"] = true;
dojo.provide("dojo._base.fx");
dojo.require("dojo._base.Color");
dojo.require("dojo._base.connect");
dojo.require("dojo._base.declare");
dojo.require("dojo._base.lang");
dojo.require("dojo._base.html");

/*
	Animation losely package based on Dan Pupius' work, contributed under CLA: 
		http://pupius.co.uk/js/Toolkit.Drawing.js
*/

dojo._Line = function(/*int*/ start, /*int*/ end){
	//	summary:
	//		dojo._Line is the object used to generate values from a start value
	//		to an end value
	//	start: int
	//		Beginning value for range
	//	end: int
	//		Ending value for range
	this.start = start;
	this.end = end;
	this.getValue = function(/*float*/ n){
		//	summary: returns the point on the line
		//	n: a floating point number greater than 0 and less than 1
		return ((this.end - this.start) * n) + this.start; // Decimal
	}
}

dojo.declare("dojo._Animation", null, {
	//	summary
	//		A generic animation object that fires callbacks into it's handlers
	//		object at various states
	//
	constructor: function(/*Object*/ args){
		dojo.mixin(this, args);
		if(dojo.isArray(this.curve)){
			/* curve: Array
				pId: a */
			this.curve = new dojo._Line(this.curve[0], this.curve[1]);
		}
	},
	
	// duration: Integer
	//	The time in milliseonds the animation will take to run
	duration: 1000,

/*=====
	// curve: dojo._Line||Array
	//	A two element array of start and end values, or a dojo._Line instance to be
	//	used in the Animation. 
	curve: null,

	// easing: Function
	//	A Function to adjust the acceleration (or deceleration) of the progress 
	//	across a dojo._Line
	easing: null,
=====*/

	// repeat: Integer
	//	The number of times to loop the animation
	repeat: 0,

	// rate: Integer
	//	the time in milliseconds to wait before advancing to next frame 
	//	(used as a fps timer: rate/1000 = fps)
	rate: 10 /* 100 fps */,

/*===== 
	// delay: Integer
	// 	The time in milliseconds to wait before starting animation after it has been .play()'ed
	delay: null,

	// events
	//
	// beforeBegin: Event
	//	Synthetic event fired before a dojo._Animation begins playing (synhcronous)
	beforeBegin: null,

	// onBegin: Event
	//	Synthetic event fired as a dojo._Animation begins playing (useful?)
	onBegin: null,

	// onAnimate: Event
	//	Synthetic event fired at each interval of a dojo._Animation
	onAnimate: null,

	// onEnd: Event
	//	Synthetic event fired after the final frame of a dojo._Animation
	onEnd: null,

	// ???
	onPlay: null,

	// onPause: Event
	//	Synthetic event fired when a dojo._Animation is paused
	onPause: null,

	// onStop: Event
	//	Synthetic event fires when a dojo._Animation is stopped
	onStop: null,

=====*/

	_percent: 0,
	_startRepeatCount: 0,

	fire: function(/*Event*/ evt, /*Array?*/ args){
		//	summary:
		//		Convenience function.  Fire event "evt" and pass it the
		//		arguments specified in "args".
		//	evt:
		//		The event to fire.
		//	args:
		//		The arguments to pass to the event.
		if(this[evt]){
			this[evt].apply(this, args||[]);
		}
		return this; // dojo._Animation
	},

	play: function(/*int?*/ delay, /*Boolean?*/ gotoStart){
		// summary:
		//		Start the animation.
		// delay:
		//		How many milliseconds to delay before starting.
		// gotoStart:
		//		If true, starts the animation from the beginning; otherwise,
		//		starts it from its current position.
		var _t = this;
		if(gotoStart){
			_t._stopTimer();
			_t._active = _t._paused = false;
			_t._percent = 0;
		}else if(_t._active && !_t._paused){
			return _t; // dojo._Animation
		}

		_t.fire("beforeBegin");

		var d = delay||_t.delay;
		var _p = dojo.hitch(_t, "_play", gotoStart);
		if(d > 0){
			setTimeout(_p, d);
			return _t; // dojo._Animation
		}
		_p();
		return _t;
	},

	_play: function(gotoStart){
		var _t = this;
		_t._startTime = new Date().valueOf();
		if(_t._paused){
			_t._startTime -= _t.duration * _t._percent;
		}
		_t._endTime = _t._startTime + _t.duration;

		_t._active = true;
		_t._paused = false;

		var value = _t.curve.getValue(_t._percent);
		if(!_t._percent){
			if(!_t._startRepeatCount){
				_t._startRepeatCount = _t.repeat;
			}
			_t.fire("onBegin", [value]);
		}

		_t.fire("onPlay", [value]);

		_t._cycle();
		return _t; // dojo._Animation
	},

	pause: function(){
		// summary: Pauses a running animation.
		this._stopTimer();
		if(!this._active){ return this; /*dojo._Animation*/}
		this._paused = true;
		this.fire("onPause", [this.curve.getValue(this._percent)]);
		return this; // dojo._Animation
	},

	gotoPercent: function(/*Decimal*/ percent, /*Boolean?*/ andPlay){
		//	summary:
		//		Sets the progress of the animation.
		//	percent:
		//		A percentage in decimal notation (between and including 0.0 and 1.0).
		//	andPlay:
		//		If true, play the animation after setting the progress.
		this._stopTimer();
		this._active = this._paused = true;
		this._percent = percent;
		if(andPlay){ this.play(); }
		return this; // dojo._Animation
	},

	stop: function(/*boolean?*/ gotoEnd){
		// summary: Stops a running animation.
		// gotoEnd: If true, the animation will end.
		if(!this._timer){ return; }
		this._stopTimer();
		if(gotoEnd){
			this._percent = 1;
		}
		this.fire("onStop", [this.curve.getValue(this._percent)]);
		this._active = this._paused = false;
		return this; // dojo._Animation
	},

	status: function(){
		// summary: Returns a string token representation of the status of
		//			the animation, one of: "paused", "playing", "stopped"
		if(this._active){
			return this._paused ? "paused" : "playing"; // String
		}
		return "stopped"; // String
	},

	_cycle: function(){
		var _t = this;
		if(_t._active){
			var curr = new Date().valueOf();
			var step = (curr - _t._startTime) / (_t._endTime - _t._startTime);

			if(step >= 1){
				step = 1;
			}
			_t._percent = step;

			// Perform easing
			if(_t.easing){
				step = _t.easing(step);
			}

			_t.fire("onAnimate", [_t.curve.getValue(step)]);

			if(step < 1){
				_t._startTimer();
			}else{
				_t._active = false;

				if(_t.repeat > 0){
					_t.repeat--;
					_t.play(null, true);
				}else if(_t.repeat == -1){
					_t.play(null, true);
				}else{
					if(_t._startRepeatCount){
						_t.repeat = _t._startRepeatCount;
						_t._startRepeatCount = 0;
					}
				}
				_t._percent = 0;
				_t.fire("onEnd");
			}
		}
		return _t; // dojo._Animation
	}
});

(function(){
	var d = dojo;
	var ctr = 0;
	var _globalTimerList = [];
	var runner = {
		run: function(){}
	};
	var timer = null;
	dojo._Animation.prototype._startTimer = function(){
		// this._timer = setTimeout(dojo.hitch(this, "_cycle"), this.rate);
		if(!this._timer){
			this._timer = dojo.connect(runner, "run", this, "_cycle");
			ctr++;
		}
		if(!timer){
			timer = setInterval(dojo.hitch(runner, "run"), this.rate);
		}
	};

	dojo._Animation.prototype._stopTimer = function(){
		dojo.disconnect(this._timer);
		this._timer = null;
		ctr--;
		if(!ctr){
			clearInterval(timer);
			timer = null;
		}
	};

	var _makeFadeable = (d.isIE) ? function(node){
		// only set the zoom if the "tickle" value would be the same as the
		// default
		var ns = node.style;
		if(!ns.zoom.length && d.style(node, "zoom") == "normal"){
			// make sure the node "hasLayout"
			// NOTE: this has been tested with larger and smaller user-set text
			// sizes and works fine
			ns.zoom = "1";
			// node.style.zoom = "normal";
		}
		// don't set the width to auto if it didn't already cascade that way.
		// We don't want to f anyones designs
		if(!ns.width.length && d.style(node, "width") == "auto"){
			ns.width = "auto";
		}
	} : function(){};

	dojo._fade = function(/*Object*/ args){
		//	summary: 
		//		Returns an animation that will fade the node defined by
		//		args.node from the start to end values passed (args.start
		//		args.end) (end is mandatory, start is optional)

		args.node = d.byId(args.node);
		var fArgs = d.mixin({ properties: {} }, args);
		var props = (fArgs.properties.opacity = {});
		props.start = !("start" in fArgs) ?
			function(){ return Number(d.style(fArgs.node, "opacity")); } : fArgs.start;
		props.end = fArgs.end;

		var anim = d.animateProperty(fArgs);
		d.connect(anim, "beforeBegin", d.partial(_makeFadeable, fArgs.node));

		return anim; // dojo._Animation
	}

	/*=====
	dojo.__fadeArgs = function(kwArgs){
		//	duration: Integer?
		//		Duration of the animation in milliseconds.
		// easing: Function?
		//		An easing function.
	}
	=====*/

	dojo.fadeIn = function(/*dojo.__fadeArgs*/ args){
		// summary: 
		//		Returns an animation that will fade node defined in 'args' from
		//		its current opacity to fully opaque.
		return d._fade(d.mixin({ end: 1 }, args)); // dojo._Animation
	}

	dojo.fadeOut = function(/*dojo.__fadeArgs*/  args){
		// summary: 
		//		Returns an animation that will fade node defined in 'args'
		//		from its current opacity to fully transparent.
		return d._fade(d.mixin({ end: 0 }, args)); // dojo._Animation
	}

	dojo._defaultEasing = function(/*Decimal?*/ n){
		// summary: The default easing function for dojo._Animation(s)
		return 0.5 + ((Math.sin((n + 1.5) * Math.PI))/2);
	}

	var PropLine = function(properties){
		this._properties = properties;
		for(var p in properties){
			var prop = properties[p];
			if(prop.start instanceof d.Color){
				// create a reusable temp color object to keep intermediate results
				prop.tempColor = new d.Color();
			}
		}
		this.getValue = function(r){
			var ret = {};
			for(var p in this._properties){
				var prop = this._properties[p];
				var start = prop.start;
				if(start instanceof d.Color){
					ret[p] = d.blendColors(start, prop.end, r, prop.tempColor).toCss();
				}else if(!d.isArray(start)){
					ret[p] = ((prop.end - start) * r) + start + (p != "opacity" ? prop.units||"px" : "");
				}
			}
			return ret;
		}
	}

	dojo.animateProperty = function(/*Object*/ args){
		//	summary: 
		//		Returns an animation that will transition the properties of
		//		node defined in 'args' depending how they are defined in
		//		'args.properties'
		//
		// description:
		//		The foundation of most dojo.fx animations, dojo.AnimateProperty
		//		will take an object of "properties" corresponding to style
		//		properties, and animate them in parallel over a set duration.
		//	
		//		args.node can be a String or a DomNode reference
		//	
		// 	example:
		//	|	dojo.animateProperty({ node: node, duration:2000,
		//	|		properties: {
		//	|			width: { start: '200', end: '400', unit:"px" },
		//	|			height: { start:'200', end: '400', unit:"px" },
		//	|			paddingTop: { start:'5', end:'50', unit:"px" } 
		//	|		}
		//	|	}).play();
		//

		args.node = d.byId(args.node);
		if(!args.easing){ args.easing = d._defaultEasing; }

		var anim = new d._Animation(args);
		d.connect(anim, "beforeBegin", anim, function(){
			var pm = {};
			for(var p in this.properties){
				// Make shallow copy of properties into pm because we overwrite some values below.
				// In particular if start/end are functions we don't want to overwrite them or
				// the functions won't be called if the animation is reused.
				var prop = (pm[p] = d.mixin({}, this.properties[p]));

				if(d.isFunction(prop.start)){
					prop.start = prop.start();
				}
				if(d.isFunction(prop.end)){
					prop.end = prop.end();
				}

				var isColor = (p.toLowerCase().indexOf("color") >= 0);
				function getStyle(node, p){
					// dojo.style(node, "height") can return "auto" or "" on IE; this is more reliable:
					var v = ({height: node.offsetHeight, width: node.offsetWidth})[p];
					if(v !== undefined){ return v; }
					v = d.style(node, p);
					return (p=="opacity") ? Number(v) : parseFloat(v);
				}
				if(!("end" in prop)){
					prop.end = getStyle(this.node, p);
				}else if(!("start" in prop)){
					prop.start = getStyle(this.node, p);
				}

				if(isColor){
					// console.debug("it's a color!");
					prop.start = new d.Color(prop.start);
					prop.end = new d.Color(prop.end);
				}else{
					prop.start = (p == "opacity") ? Number(prop.start) : parseFloat(prop.start);
				}
				// console.debug("start:", prop.start);
				// console.debug("end:", prop.end);
			}
			this.curve = new PropLine(pm);
		});
		d.connect(anim, "onAnimate", anim, function(propValues){
			// try{
			for(var s in propValues){
				// console.debug(s, propValues[s], this.node.style[s]);
				d.style(this.node, s, propValues[s]);
				// this.node.style[s] = propValues[s];
			}
			// }catch(e){ console.debug(dojo.toJson(e)); }
		});
		return anim; // dojo._Animation
	}
})();

}

}});