dojo-rails 0.9.8 → 0.9.9

data/vendor/assets/javascripts/dojo/_base/event.js

@@ -0,0 +1,36 @@
+/*
+	Copyright (c) 2004-2011, The Dojo Foundation All Rights Reserved.
+	Available via Academic Free License >= 2.1 OR the modified BSD license.
+	see: http://dojotoolkit.org/license for details
+*/
+
+//>>built
+define("dojo/_base/event",["./kernel","../on","../has","../dom-geometry"],function(_1,on,_2,_3){
+if(on._fixEvent){
+var _4=on._fixEvent;
+on._fixEvent=function(_5,se){
+_5=_4(_5,se);
+if(_5){
+_3.normalizeEvent(_5);
+}
+return _5;
+};
+}
+_1.fixEvent=function(_6,_7){
+if(on._fixEvent){
+return on._fixEvent(_6,_7);
+}
+return _6;
+};
+_1.stopEvent=function(_8){
+if(_2("dom-addeventlistener")||(_8&&_8.preventDefault)){
+_8.preventDefault();
+_8.stopPropagation();
+}else{
+_8=_8||window.event;
+_8.cancelBubble=true;
+on._preventDefault.call(_8);
+}
+};
+return {fix:_1.fixEvent,stop:_1.stopEvent};
+});

data/vendor/assets/javascripts/dojo/_base/event.js.uncompressed.js

@@ -0,0 +1,51 @@
+define("dojo/_base/event", ["./kernel", "../on", "../has", "../dom-geometry"], function(dojo, on, has, dom){
+  //  module:
+  //    dojo/_base/event
+  //  summary:
+  //    This module defines dojo DOM event API.
+	if(on._fixEvent){
+		var fixEvent = on._fixEvent;
+		on._fixEvent = function(evt, se){
+			// add some additional normalization for back-compat, this isn't in on.js because it is somewhat more expensive
+			evt = fixEvent(evt, se);
+			if(evt){
+				dom.normalizeEvent(evt);
+			}
+			return evt;
+		};		
+	}
+	dojo.fixEvent = function(/*Event*/ evt, /*DOMNode*/ sender){
+		// summary:
+		//		normalizes properties on the event object including event
+		//		bubbling methods, keystroke normalization, and x/y positions
+		// evt: Event
+		//		native event object
+		// sender: DOMNode
+		//		node to treat as "currentTarget"
+		if(on._fixEvent){
+			return on._fixEvent(evt, sender);
+		}
+		return evt;	// Event
+	};
+	
+	dojo.stopEvent = function(/*Event*/ evt){
+		// summary:
+		//		prevents propagation and clobbers the default action of the
+		//		passed event
+		// evt: Event
+		//		The event object. If omitted, window.event is used on IE.
+		if(has("dom-addeventlistener") || (evt && evt.preventDefault)){
+			evt.preventDefault();
+			evt.stopPropagation();
+		}else{
+			evt = evt || window.event;
+			evt.cancelBubble = true;
+			on._preventDefault.call(evt);
+		}
+	};
+
+	return {
+		fix: dojo.fixEvent,
+		stop: dojo.stopEvent
+	};
+});

data/vendor/assets/javascripts/dojo/_base/fx.js

@@ -0,0 +1,295 @@
+/*
+	Copyright (c) 2004-2011, The Dojo Foundation All Rights Reserved.
+	Available via Academic Free License >= 2.1 OR the modified BSD license.
+	see: http://dojotoolkit.org/license for details
+*/
+
+//>>built
+define("dojo/_base/fx",["./kernel","./lang","../Evented","./Color","./connect","./sniff","../dom","../dom-style"],function(_1,_2,_3,_4,_5,_6,_7,_8){
+var _9=_2.mixin;
+_1._Line=function(_a,_b){
+this.start=_a;
+this.end=_b;
+};
+_1._Line.prototype.getValue=function(n){
+return ((this.end-this.start)*n)+this.start;
+};
+_1.Animation=function(_c){
+_9(this,_c);
+if(_2.isArray(this.curve)){
+this.curve=new _1._Line(this.curve[0],this.curve[1]);
+}
+};
+_1.Animation.prototype=new _3();
+_1._Animation=_1.Animation;
+_2.extend(_1.Animation,{duration:350,repeat:0,rate:20,_percent:0,_startRepeatCount:0,_getStep:function(){
+var _d=this._percent,_e=this.easing;
+return _e?_e(_d):_d;
+},_fire:function(_f,_10){
+var a=_10||[];
+if(this[_f]){
+if(_1.config.debugAtAllCosts){
+this[_f].apply(this,a);
+}else{
+try{
+this[_f].apply(this,a);
+}
+catch(e){
+console.error("exception in animation handler for:",_f);
+console.error(e);
+}
+}
+}
+return this;
+},play:function(_11,_12){
+var _13=this;
+if(_13._delayTimer){
+_13._clearTimer();
+}
+if(_12){
+_13._stopTimer();
+_13._active=_13._paused=false;
+_13._percent=0;
+}else{
+if(_13._active&&!_13._paused){
+return _13;
+}
+}
+_13._fire("beforeBegin",[_13.node]);
+var de=_11||_13.delay,_14=_2.hitch(_13,"_play",_12);
+if(de>0){
+_13._delayTimer=setTimeout(_14,de);
+return _13;
+}
+_14();
+return _13;
+},_play:function(_15){
+var _16=this;
+if(_16._delayTimer){
+_16._clearTimer();
+}
+_16._startTime=new Date().valueOf();
+if(_16._paused){
+_16._startTime-=_16.duration*_16._percent;
+}
+_16._active=true;
+_16._paused=false;
+var _17=_16.curve.getValue(_16._getStep());
+if(!_16._percent){
+if(!_16._startRepeatCount){
+_16._startRepeatCount=_16.repeat;
+}
+_16._fire("onBegin",[_17]);
+}
+_16._fire("onPlay",[_17]);
+_16._cycle();
+return _16;
+},pause:function(){
+var _18=this;
+if(_18._delayTimer){
+_18._clearTimer();
+}
+_18._stopTimer();
+if(!_18._active){
+return _18;
+}
+_18._paused=true;
+_18._fire("onPause",[_18.curve.getValue(_18._getStep())]);
+return _18;
+},gotoPercent:function(_19,_1a){
+var _1b=this;
+_1b._stopTimer();
+_1b._active=_1b._paused=true;
+_1b._percent=_19;
+if(_1a){
+_1b.play();
+}
+return _1b;
+},stop:function(_1c){
+var _1d=this;
+if(_1d._delayTimer){
+_1d._clearTimer();
+}
+if(!_1d._timer){
+return _1d;
+}
+_1d._stopTimer();
+if(_1c){
+_1d._percent=1;
+}
+_1d._fire("onStop",[_1d.curve.getValue(_1d._getStep())]);
+_1d._active=_1d._paused=false;
+return _1d;
+},status:function(){
+if(this._active){
+return this._paused?"paused":"playing";
+}
+return "stopped";
+},_cycle:function(){
+var _1e=this;
+if(_1e._active){
+var _1f=new Date().valueOf();
+var _20=(_1f-_1e._startTime)/(_1e.duration);
+if(_20>=1){
+_20=1;
+}
+_1e._percent=_20;
+if(_1e.easing){
+_20=_1e.easing(_20);
+}
+_1e._fire("onAnimate",[_1e.curve.getValue(_20)]);
+if(_1e._percent<1){
+_1e._startTimer();
+}else{
+_1e._active=false;
+if(_1e.repeat>0){
+_1e.repeat--;
+_1e.play(null,true);
+}else{
+if(_1e.repeat==-1){
+_1e.play(null,true);
+}else{
+if(_1e._startRepeatCount){
+_1e.repeat=_1e._startRepeatCount;
+_1e._startRepeatCount=0;
+}
+}
+}
+_1e._percent=0;
+_1e._fire("onEnd",[_1e.node]);
+!_1e.repeat&&_1e._stopTimer();
+}
+}
+return _1e;
+},_clearTimer:function(){
+clearTimeout(this._delayTimer);
+delete this._delayTimer;
+}});
+var ctr=0,_21=null,_22={run:function(){
+}};
+_2.extend(_1.Animation,{_startTimer:function(){
+if(!this._timer){
+this._timer=_5.connect(_22,"run",this,"_cycle");
+ctr++;
+}
+if(!_21){
+_21=setInterval(_2.hitch(_22,"run"),this.rate);
+}
+},_stopTimer:function(){
+if(this._timer){
+_5.disconnect(this._timer);
+this._timer=null;
+ctr--;
+}
+if(ctr<=0){
+clearInterval(_21);
+_21=null;
+ctr=0;
+}
+}});
+var _23=_6("ie")?function(_24){
+var ns=_24.style;
+if(!ns.width.length&&_8.get(_24,"width")=="auto"){
+ns.width="auto";
+}
+}:function(){
+};
+_1._fade=function(_25){
+_25.node=_7.byId(_25.node);
+var _26=_9({properties:{}},_25),_27=(_26.properties.opacity={});
+_27.start=!("start" in _26)?function(){
+return +_8.get(_26.node,"opacity")||0;
+}:_26.start;
+_27.end=_26.end;
+var _28=_1.animateProperty(_26);
+_5.connect(_28,"beforeBegin",_2.partial(_23,_26.node));
+return _28;
+};
+_1.fadeIn=function(_29){
+return _1._fade(_9({end:1},_29));
+};
+_1.fadeOut=function(_2a){
+return _1._fade(_9({end:0},_2a));
+};
+_1._defaultEasing=function(n){
+return 0.5+((Math.sin((n+1.5)*Math.PI))/2);
+};
+var _2b=function(_2c){
+this._properties=_2c;
+for(var p in _2c){
+var _2d=_2c[p];
+if(_2d.start instanceof _4){
+_2d.tempColor=new _4();
+}
+}
+};
+_2b.prototype.getValue=function(r){
+var ret={};
+for(var p in this._properties){
+var _2e=this._properties[p],_2f=_2e.start;
+if(_2f instanceof _4){
+ret[p]=_4.blendColors(_2f,_2e.end,r,_2e.tempColor).toCss();
+}else{
+if(!_2.isArray(_2f)){
+ret[p]=((_2e.end-_2f)*r)+_2f+(p!="opacity"?_2e.units||"px":0);
+}
+}
+}
+return ret;
+};
+_1.animateProperty=function(_30){
+var n=_30.node=_7.byId(_30.node);
+if(!_30.easing){
+_30.easing=_1._defaultEasing;
+}
+var _31=new _1.Animation(_30);
+_5.connect(_31,"beforeBegin",_31,function(){
+var pm={};
+for(var p in this.properties){
+if(p=="width"||p=="height"){
+this.node.display="block";
+}
+var _32=this.properties[p];
+if(_2.isFunction(_32)){
+_32=_32(n);
+}
+_32=pm[p]=_9({},(_2.isObject(_32)?_32:{end:_32}));
+if(_2.isFunction(_32.start)){
+_32.start=_32.start(n);
+}
+if(_2.isFunction(_32.end)){
+_32.end=_32.end(n);
+}
+var _33=(p.toLowerCase().indexOf("color")>=0);
+function _34(_35,p){
+var v={height:_35.offsetHeight,width:_35.offsetWidth}[p];
+if(v!==undefined){
+return v;
+}
+v=_8.get(_35,p);
+return (p=="opacity")?+v:(_33?v:parseFloat(v));
+};
+if(!("end" in _32)){
+_32.end=_34(n,p);
+}else{
+if(!("start" in _32)){
+_32.start=_34(n,p);
+}
+}
+if(_33){
+_32.start=new _4(_32.start);
+_32.end=new _4(_32.end);
+}else{
+_32.start=(p=="opacity")?+_32.start:parseFloat(_32.start);
+}
+}
+this.curve=new _2b(pm);
+});
+_5.connect(_31,"onAnimate",_2.hitch(_8,"set",_31.node));
+return _31;
+};
+_1.anim=function(_36,_37,_38,_39,_3a,_3b){
+return _1.animateProperty({node:_36,duration:_38||_1.Animation.prototype.duration,properties:_37,easing:_39,onEnd:_3a}).play(_3b||0);
+};
+return {_Line:_1._Line,Animation:_1.Animation,_fade:_1._fade,fadeIn:_1.fadeIn,fadeOut:_1.fadeOut,_defaultEasing:_1._defaultEasing,animateProperty:_1.animateProperty,anim:_1.anim};
+});

data/vendor/assets/javascripts/dojo/_base/fx.js.uncompressed.js

@@ -0,0 +1,666 @@
+define("dojo/_base/fx", ["./kernel", "./lang", "../Evented", "./Color", "./connect", "./sniff", "../dom", "../dom-style"], function(dojo, lang, Evented, Color, connect, has, dom, style){
+	// module:
+	//		dojo/_base/fx
+	// summary:
+	//		This module defines the base dojo.fx implementation.
+	// notes:
+	//		Animation loosely package based on Dan Pupius' work, contributed under CLA; see
+	//		http://pupius.co.uk/js/Toolkit.Drawing.js
+
+	var _mixin = lang.mixin;
+
+	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;
+	};
+
+	dojo._Line.prototype.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.Animation = function(args){
+		//	summary:
+		//		A generic animation class that fires callbacks into its handlers
+		//		object at various states.
+		//	description:
+		//		A generic animation class that fires callbacks into its handlers
+		//		object at various states. Nearly all dojo animation functions
+		//		return an instance of this method, usually without calling the
+		//		.play() method beforehand. Therefore, you will likely need to
+		//		call .play() on instances of `dojo.Animation` when one is
+		//		returned.
+		// args: Object
+		//		The 'magic argument', mixing all the properties into this
+		//		animation instance.
+
+		_mixin(this, args);
+		if(lang.isArray(this.curve)){
+			this.curve = new dojo._Line(this.curve[0], this.curve[1]);
+		}
+
+	};
+	dojo.Animation.prototype = new Evented();
+	// Alias to drop come 2.0:
+	dojo._Animation = dojo.Animation;
+
+	lang.extend(dojo.Animation, {
+		// duration: Integer
+		//		The time in milliseonds the animation will take to run
+		duration: 350,
+
+	/*=====
+		// 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: 1000/rate = fps)
+		rate: 20 /* 50 fps */,
+
+	/*=====
+		// delay: Integer?
+		//		The time in milliseconds to wait before starting animation after it
+		//		has been .play()'ed
+		delay: null,
+
+		// beforeBegin: Event?
+		//		Synthetic event fired before a dojo.Animation begins playing (synchronous)
+		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: Event?
+		//		Synthetic event fired any time a `dojo.Animation` is play()'ed
+		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,
+
+		_getStep: function(){
+			var _p = this._percent,
+				_e = this.easing
+			;
+			return _e ? _e(_p) : _p;
+		},
+		_fire: function(/*Event*/ evt, /*Array?*/ args){
+			//	summary:
+			//		Convenience function.  Fire event "evt" and pass it the
+			//		arguments specified in "args".
+			//	description:
+			//		Convenience function.  Fire event "evt" and pass it the
+			//		arguments specified in "args".
+			//		Fires the callback in the scope of the `dojo.Animation`
+			//		instance.
+			//	evt:
+			//		The event to fire.
+			//	args:
+			//		The arguments to pass to the event.
+			var a = args||[];
+			if(this[evt]){
+				if(dojo.config.debugAtAllCosts){
+					this[evt].apply(this, a);
+				}else{
+					try{
+						this[evt].apply(this, a);
+					}catch(e){
+						// squelch and log because we shouldn't allow exceptions in
+						// synthetic event handlers to cause the internal timer to run
+						// amuck, potentially pegging the CPU. I'm not a fan of this
+						// squelch, but hopefully logging will make it clear what's
+						// going on
+						console.error("exception in animation handler for:", evt);
+						console.error(e);
+					}
+				}
+			}
+			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.
+			// returns: dojo.Animation
+			//		The instance to allow chaining.
+
+			var _t = this;
+			if(_t._delayTimer){ _t._clearTimer(); }
+			if(gotoStart){
+				_t._stopTimer();
+				_t._active = _t._paused = false;
+				_t._percent = 0;
+			}else if(_t._active && !_t._paused){
+				return _t;
+			}
+
+			_t._fire("beforeBegin", [_t.node]);
+
+			var de = delay || _t.delay,
+				_p = lang.hitch(_t, "_play", gotoStart);
+
+			if(de > 0){
+				_t._delayTimer = setTimeout(_p, de);
+				return _t;
+			}
+			_p();
+			return _t;	// dojo.Animation
+		},
+
+		_play: function(gotoStart){
+			var _t = this;
+			if(_t._delayTimer){ _t._clearTimer(); }
+			_t._startTime = new Date().valueOf();
+			if(_t._paused){
+				_t._startTime -= _t.duration * _t._percent;
+			}
+
+			_t._active = true;
+			_t._paused = false;
+			var value = _t.curve.getValue(_t._getStep());
+			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.
+			var _t = this;
+			if(_t._delayTimer){ _t._clearTimer(); }
+			_t._stopTimer();
+			if(!_t._active){ return _t; /*dojo.Animation*/ }
+			_t._paused = true;
+			_t._fire("onPause", [_t.curve.getValue(_t._getStep())]);
+			return _t; // 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.
+			var _t = this;
+			_t._stopTimer();
+			_t._active = _t._paused = true;
+			_t._percent = percent;
+			if(andPlay){ _t.play(); }
+			return _t; // dojo.Animation
+		},
+
+		stop: function(/*boolean?*/ gotoEnd){
+			// summary: Stops a running animation.
+			// gotoEnd: If true, the animation will end.
+			var _t = this;
+			if(_t._delayTimer){ _t._clearTimer(); }
+			if(!_t._timer){ return _t; /* dojo.Animation */ }
+			_t._stopTimer();
+			if(gotoEnd){
+				_t._percent = 1;
+			}
+			_t._fire("onStop", [_t.curve.getValue(_t._getStep())]);
+			_t._active = _t._paused = false;
+			return _t; // 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.duration);
+
+				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(_t._percent < 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", [_t.node]);
+					!_t.repeat && _t._stopTimer();
+				}
+			}
+			return _t; // dojo.Animation
+		},
+
+		_clearTimer: function(){
+			// summary: Clear the play delay timer
+			clearTimeout(this._delayTimer);
+			delete this._delayTimer;
+		}
+
+	});
+
+	// the local timer, stubbed into all Animation instances
+	var ctr = 0,
+		timer = null,
+		runner = {
+			run: function(){}
+		};
+
+	lang.extend(dojo.Animation, {
+
+		_startTimer: function(){
+			if(!this._timer){
+				this._timer = connect.connect(runner, "run", this, "_cycle");
+				ctr++;
+			}
+			if(!timer){
+				timer = setInterval(lang.hitch(runner, "run"), this.rate);
+			}
+		},
+
+		_stopTimer: function(){
+			if(this._timer){
+				connect.disconnect(this._timer);
+				this._timer = null;
+				ctr--;
+			}
+			if(ctr <= 0){
+				clearInterval(timer);
+				timer = null;
+				ctr = 0;
+			}
+		}
+
+	});
+
+	var _makeFadeable =
+				has("ie") ? function(node){
+			// only set the zoom if the "tickle" value would be the same as the
+			// default
+			var ns = node.style;
+			// 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 && style.get(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 = dom.byId(args.node);
+		var fArgs = _mixin({ properties: {} }, args),
+			props = (fArgs.properties.opacity = {});
+
+		props.start = !("start" in fArgs) ?
+			function(){
+				return +style.get(fArgs.node, "opacity")||0;
+			} : fArgs.start;
+		props.end = fArgs.end;
+
+		var anim = dojo.animateProperty(fArgs);
+		connect.connect(anim, "beforeBegin", lang.partial(_makeFadeable, fArgs.node));
+
+		return anim; // dojo.Animation
+	};
+
+	/*=====
+	dojo.__FadeArgs = function(node, duration, easing){
+		//	node: DOMNode|String
+		//		The node referenced in the animation
+		//	duration: Integer?
+		//		Duration of the animation in milliseconds.
+		//	easing: Function?
+		//		An easing function.
+		this.node = node;
+		this.duration = duration;
+		this.easing = easing;
+	}
+	=====*/
+
+	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 dojo._fade(_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 dojo._fade(_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);	// Decimal
+	};
+
+	var PropLine = function(properties){
+		// PropLine is an internal class which is used to model the values of
+		// an a group of CSS properties across an animation lifecycle. In
+		// particular, the "getValue" function handles getting interpolated
+		// values between start and end for a particular CSS value.
+		this._properties = properties;
+		for(var p in properties){
+			var prop = properties[p];
+			if(prop.start instanceof Color){
+				// create a reusable temp color object to keep intermediate results
+				prop.tempColor = new Color();
+			}
+		}
+	};
+
+	PropLine.prototype.getValue = function(r){
+		var ret = {};
+		for(var p in this._properties){
+			var prop = this._properties[p],
+				start = prop.start;
+			if(start instanceof Color){
+				ret[p] = Color.blendColors(start, prop.end, r, prop.tempColor).toCss();
+			}else if(!lang.isArray(start)){
+				ret[p] = ((prop.end - start) * r) + start + (p != "opacity" ? prop.units || "px" : 0);
+			}
+		}
+		return ret;
+	};
+
+	/*=====
+	dojo.declare("dojo.__AnimArgs", [dojo.__FadeArgs], {
+		// Properties: Object?
+		//	A hash map of style properties to Objects describing the transition,
+		//	such as the properties of dojo._Line with an additional 'units' property
+		properties: {}
+
+		//TODOC: add event callbacks
+	});
+	=====*/
+
+	dojo.animateProperty = function(/*dojo.__AnimArgs*/ args){
+		// summary:
+		//		Returns an animation that will transition the properties of
+		//		node defined in `args` depending how they are defined in
+		//		`args.properties`
+		//
+		// description:
+		//		`dojo.animateProperty` is the foundation of most `dojo.fx`
+		//		animations. It takes an object of "properties" corresponding to
+		//		style properties, and animates them in parallel over a set
+		//		duration.
+		//
+		// example:
+		//		A simple animation that changes the width of the specified node.
+		//	|	dojo.animateProperty({
+		//	|		node: "nodeId",
+		//	|		properties: { width: 400 },
+		//	|	}).play();
+		//		Dojo figures out the start value for the width and converts the
+		//		integer specified for the width to the more expressive but
+		//		verbose form `{ width: { end: '400', units: 'px' } }` which you
+		//		can also specify directly. Defaults to 'px' if ommitted.
+		//
+		// example:
+		//		Animate width, height, and padding over 2 seconds... the
+		//		pedantic way:
+		//	|	dojo.animateProperty({ node: node, duration:2000,
+		//	|		properties: {
+		//	|			width: { start: '200', end: '400', units:"px" },
+		//	|			height: { start:'200', end: '400', units:"px" },
+		//	|			paddingTop: { start:'5', end:'50', units:"px" }
+		//	|		}
+		//	|	}).play();
+		//		Note 'paddingTop' is used over 'padding-top'. Multi-name CSS properties
+		//		are written using "mixed case", as the hyphen is illegal as an object key.
+		//
+		// example:
+		//		Plug in a different easing function and register a callback for
+		//		when the animation ends. Easing functions accept values between
+		//		zero and one and return a value on that basis. In this case, an
+		//		exponential-in curve.
+		//	|	dojo.animateProperty({
+		//	|		node: "nodeId",
+		//	|		// dojo figures out the start value
+		//	|		properties: { width: { end: 400 } },
+		//	|		easing: function(n){
+		//	|			return (n==0) ? 0 : Math.pow(2, 10 * (n - 1));
+		//	|		},
+		//	|		onEnd: function(node){
+		//	|			// called when the animation finishes. The animation
+		//	|			// target is passed to this function
+		//	|		}
+		//	|	}).play(500); // delay playing half a second
+		//
+		// example:
+		//		Like all `dojo.Animation`s, animateProperty returns a handle to the
+		//		Animation instance, which fires the events common to Dojo FX. Use `dojo.connect`
+		//		to access these events outside of the Animation definiton:
+		//	|	var anim = dojo.animateProperty({
+		//	|		node:"someId",
+		//	|		properties:{
+		//	|			width:400, height:500
+		//	|		}
+		//	|	});
+		//	|	dojo.connect(anim,"onEnd", function(){
+		//	|		console.log("animation ended");
+		//	|	});
+		//	|	// play the animation now:
+		//	|	anim.play();
+		//
+		// example:
+		//		Each property can be a function whose return value is substituted along.
+		//		Additionally, each measurement (eg: start, end) can be a function. The node
+		//		reference is passed direcly to callbacks.
+		//	|	dojo.animateProperty({
+		//	|		node:"mine",
+		//	|		properties:{
+		//	|			height:function(node){
+		//	|				// shrink this node by 50%
+		//	|				return dojo.position(node).h / 2
+		//	|			},
+		//	|			width:{
+		//	|				start:function(node){ return 100; },
+		//	|				end:function(node){ return 200; }
+		//	|			}
+		//	|		}
+		//	|	}).play();
+		//
+
+		var n = args.node = dom.byId(args.node);
+		if(!args.easing){ args.easing = dojo._defaultEasing; }
+
+		var anim = new dojo.Animation(args);
+		connect.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.
+				if(p == "width" || p == "height"){
+					this.node.display = "block";
+				}
+				var prop = this.properties[p];
+				if(lang.isFunction(prop)){
+					prop = prop(n);
+				}
+				prop = pm[p] = _mixin({}, (lang.isObject(prop) ? prop: { end: prop }));
+
+				if(lang.isFunction(prop.start)){
+					prop.start = prop.start(n);
+				}
+				if(lang.isFunction(prop.end)){
+					prop.end = prop.end(n);
+				}
+				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 = style.get(node, p);
+					return (p == "opacity") ? +v : (isColor ? v : parseFloat(v));
+				}
+				if(!("end" in prop)){
+					prop.end = getStyle(n, p);
+				}else if(!("start" in prop)){
+					prop.start = getStyle(n, p);
+				}
+
+				if(isColor){
+					prop.start = new Color(prop.start);
+					prop.end = new Color(prop.end);
+				}else{
+					prop.start = (p == "opacity") ? +prop.start : parseFloat(prop.start);
+				}
+			}
+			this.curve = new PropLine(pm);
+		});
+		connect.connect(anim, "onAnimate", lang.hitch(style, "set", anim.node));
+		return anim; // dojo.Animation
+	};
+
+	dojo.anim = function(	/*DOMNode|String*/	node,
+							/*Object*/			properties,
+							/*Integer?*/		duration,
+							/*Function?*/		easing,
+							/*Function?*/		onEnd,
+							/*Integer?*/		delay){
+		//	summary:
+		//		A simpler interface to `dojo.animateProperty()`, also returns
+		//		an instance of `dojo.Animation` but begins the animation
+		//		immediately, unlike nearly every other Dojo animation API.
+		//	description:
+		//		`dojo.anim` is a simpler (but somewhat less powerful) version
+		//		of `dojo.animateProperty`.  It uses defaults for many basic properties
+		//		and allows for positional parameters to be used in place of the
+		//		packed "property bag" which is used for other Dojo animation
+		//		methods.
+		//
+		//		The `dojo.Animation` object returned from `dojo.anim` will be
+		//		already playing when it is returned from this function, so
+		//		calling play() on it again is (usually) a no-op.
+		//	node:
+		//		a DOM node or the id of a node to animate CSS properties on
+		//	duration:
+		//		The number of milliseconds over which the animation
+		//		should run. Defaults to the global animation default duration
+		//		(350ms).
+		//	easing:
+		//		An easing function over which to calculate acceleration
+		//		and deceleration of the animation through its duration.
+		//		A default easing algorithm is provided, but you may
+		//		plug in any you wish. A large selection of easing algorithms
+		//		are available in `dojo.fx.easing`.
+		//	onEnd:
+		//		A function to be called when the animation finishes
+		//		running.
+		//	delay:
+		//		The number of milliseconds to delay beginning the
+		//		animation by. The default is 0.
+		//	example:
+		//		Fade out a node
+		//	|	dojo.anim("id", { opacity: 0 });
+		//	example:
+		//		Fade out a node over a full second
+		//	|	dojo.anim("id", { opacity: 0 }, 1000);
+		return dojo.animateProperty({ // dojo.Animation
+			node: node,
+			duration: duration || dojo.Animation.prototype.duration,
+			properties: properties,
+			easing: easing,
+			onEnd: onEnd
+		}).play(delay || 0);
+	};
+
+	return {
+		_Line: dojo._Line,
+		Animation: dojo.Animation,
+		_fade: dojo._fade,
+		fadeIn: dojo.fadeIn,
+		fadeOut: dojo.fadeOut,
+		_defaultEasing: dojo._defaultEasing,
+		animateProperty: dojo.animateProperty,
+		anim: dojo.anim
+	};
+});